feat: renaming output files and fixing a bug

crag_sampler/sampler.py

@@ -13,8 +13,8 @@ import subprocess
 from .utils import (
     read_jsonl_fields_fast,
     process_answer_types,
-    create_stratified_subsamples,
-    subsample_jsonl_file,
+    create_stratified_subsets,
+    subset_jsonl_file,
 )
 
 
@@ -51,23 +51,23 @@ class CragSampler:
         )
         return process_answer_types(df)
 
-    def create_subsamples(
+    def create_subsets(
         self,
-        n_subsamples: int = 5,
+        n_subsets: int = 5,
         stratify_columns: Optional[List[str]] = None,
         output_path: Optional[str] = None,
         force_compute: bool = False,
     ) -> Dict:
-        """Create stratified subsamples of the dataset.
+        """Create stratified subsets of the dataset.
 
         Args:
-            n_subsamples: Number of subsamples to create
+            n_subsets: Number of subsets to create
             stratify_columns: Columns to use for stratification. If None, uses defaults
             output_path: Path to save/load the JSON output
-            force_compute: If True, always compute subsamples even if file exists
+            force_compute: If True, always compute subsets even if file exists
 
         Returns:
-            Dictionary containing the subsamples information
+            Dictionary containing the subsets information
         """
         if stratify_columns is None:
             stratify_columns = [
@@ -80,37 +80,37 @@ class CragSampler:
         if output_path is None:
             output_path = os.path.join(
                 os.path.dirname(self.input_file),
-                f"{os.path.splitext(os.path.basename(self.input_file))[0]}_subsamples.json",
+                f"{os.path.splitext(os.path.basename(self.input_file))[0]}_subsets.json",
             )
 
-        return create_stratified_subsamples(
+        return create_stratified_subsets(
             self.df,
-            n_subsamples=n_subsamples,
+            n_subsets=n_subsets,
             stratify_columns=stratify_columns,
             output_path=output_path,
             force_compute=force_compute,
         )
 
-    def write_subsamples(
+    def write_subsets(
         self,
-        subsamples_file: str,
+        subsets_file: str,
         output_dir: Optional[str] = None,
         compress: bool = True,
         n_processes: Optional[int] = None,
         overwrite: bool = False,
     ) -> None:
-        """Write subsamples to separate files.
+        """Write subsets to separate files.
 
         Args:
-            subsamples_file: Path to JSON file containing subsample indices
-            output_dir: Directory to save subsample files
+            subsets_file: Path to JSON file containing subset indices
+            output_dir: Directory to save subset files
             compress: Whether to compress output files with bz2
             n_processes: Number of processes to use
             overwrite: If False, skip existing output files
         """
-        subsample_jsonl_file(
+        subset_jsonl_file(
             self.input_file,
-            subsamples_file,
+            subsets_file,
             output_dir=output_dir,
             compress=compress,
             n_processes=n_processes,

crag_sampler/utils.py

@@ -167,82 +167,80 @@ def process_answer_types(df: pd.DataFrame) -> pd.DataFrame:
     return df
 
 
-def create_stratified_subsamples(
+def create_stratified_subsets(
     df: pd.DataFrame,
-    n_subsamples: int,
+    n_subsets: int,
     stratify_columns: List[str] = [
         "domain",
         "answer_type",
         "question_type",
         "static_or_dynamic",
     ],
-    output_path: str = "subsamples.json",
+    output_path: str = "subsets.json",
     force_compute: bool = False,
 ) -> Dict[str, Any]:
     """
-    Create stratified subsamples of the dataset and save them to a JSON file.
-    Each subsample gets a unique ID based on its indices.
+    Create stratified subsets of the dataset and save them to a JSON file.
+    Each subset gets a unique ID based on its indices.
 
     Args:
         df: Input DataFrame
-        n_subsamples: Number of subsamples to create
+        n_subsets: Number of subsets to create
         stratify_columns: Columns to use for stratification
         output_path: Path to save/load the JSON output
-        force_compute: If True, always compute subsamples even if file exists
+        force_compute: If True, always compute subsets even if file exists
 
     Returns:
-        Dictionary containing the subsamples information
+        Dictionary containing the subsets information
     """
     # Check if file exists and we can use it
     if not force_compute and os.path.exists(output_path):
         try:
             with open(output_path, "r") as f:
-                subsamples_data = json.load(f)
+                subsets_data = json.load(f)
 
             # Validate the loaded data has the expected structure
             if (
-                subsamples_data.get("metadata", {}).get("n_subsamples") == n_subsamples
-                and subsamples_data.get("metadata", {}).get("stratify_columns")
+                subsets_data.get("metadata", {}).get("n_subsets") == n_subsets
+                and subsets_data.get("metadata", {}).get("stratify_columns")
                 == stratify_columns
             ):
-                print(f"Loading existing subsamples from {output_path}")
-                return subsamples_data
+                print(f"Loading existing subsets from {output_path}")
+                return subsets_data
             else:
-                print(
-                    "Existing subsamples file has different parameters, recomputing..."
-                )
+                print("Existing subsets file has different parameters, recomputing...")
         except Exception as e:
-            print(f"Error loading existing subsamples file: {e}, recomputing...")
+            print(f"Error loading existing subsets file: {e}, recomputing...")
 
     # Create a combined category for stratification
     df["strat_category"] = df[stratify_columns].astype(str).agg("_".join, axis=1)
 
-    # Initialize the subsampleter
-    skf = StratifiedKFold(n_splits=n_subsamples, shuffle=True, random_state=42)
+    # Initialize the subsetter
+    skf = StratifiedKFold(n_splits=n_subsets, shuffle=True, random_state=42)
 
-    # Create subsamples
-    subsamples_info = []
-    for subsample_idx, (_, subsample_indices) in enumerate(
+    # Create subsets
+    subsets_info = []
+    for subset_idx, (_, subset_indices) in enumerate(
         skf.split(df, df["strat_category"])
     ):
         # Sort indices for consistent hashing
-        sorted_indices = sorted(subsample_indices.tolist())
+        sorted_indices = sorted(subset_indices.tolist())
 
         # Create a deterministic ID from the indices
-        subsample_id = hashlib.md5(str(sorted_indices).encode()).hexdigest()[:8]
+        subset_id = hashlib.md5(str(sorted_indices).encode()).hexdigest()[:8]
 
-        # Calculate statistics for this subsample
+        # Calculate statistics for this subset
         stats = {}
-        subsample_df = df.iloc[subsample_indices]
+        subset_df = df.iloc[subset_indices]
         for col in stratify_columns:
-            stats[col] = subsample_df[col].value_counts().to_dict()
+            stats[col] = subset_df[col].value_counts().to_dict()
 
-        subsamples_info.append(
+        subsets_info.append(
             {
-                "id": subsample_id,
+                "index": subset_idx,
                 "statistics": stats,
                 "indices": sorted_indices,
-                "size": len(subsample_indices),
+                "size": len(subset_indices),
             }
         )
 
@@ -253,12 +251,12 @@ def create_stratified_subsamples(
 
     output_data = {
         "metadata": {
-            "n_subsamples": n_subsamples,
+            "n_subsets": n_subsets,
             "total_samples": len(df),
             "stratify_columns": stratify_columns,
             "global_statistics": global_stats,
         },
-        "subsamples": subsamples_info,
+        "subsets": subsets_info,
     }
 
     # Save to JSON
@@ -268,11 +266,10 @@ def create_stratified_subsamples(
     return output_data
 
 
-def write_subsample(
+def write_subset(
     input_file: str, indices: List[int], output_file: str, compress: bool = True
 ) -> None:
-    """
-    Write a single subsample to a file using awk.
+    """Write a single subset to a file using awk.
 
     Args:
         input_file: Path to input JSONL file
@@ -280,15 +277,10 @@ def write_subsample(
         output_file: Path to output file
         compress: Whether to compress output
     """
-    # Convert indices to awk condition
-    # NR is the current line number in awk
+    # Convert indices to 1-based indexing and create NR condition
     indices_set = set(i + 1 for i in indices)  # Convert to 1-based indexing
-    indices_str = ",".join(str(i) for i in sorted(indices_set))
-
-    # Create awk script with escaped curly braces
-    awk_script = (
-        f'BEGIN {{subsample("{indices_str}",a,","); for(i in a) n[a[i]];}} NR in n'
-    )
+    nr_conditions = " || ".join(f"NR == {i}" for i in sorted(indices_set))
+    awk_script = f"{nr_conditions}"
 
     if input_file.endswith(".bz2"):
         if compress:
@@ -301,7 +293,7 @@ def write_subsample(
         else:
             cmd = f"awk '{awk_script}' '{input_file}' > '{output_file}'"
 
-    print(f"Process {os.getpid()} - Starting subsample to {output_file}")
+    print(f"Process {os.getpid()} - Starting subset to {output_file}")
     try:
         result = subprocess.run(
             cmd,
@@ -311,12 +303,12 @@ def write_subsample(
             stdout=subprocess.PIPE,
             text=True,
         )
-        print(f"Process {os.getpid()} - Finished subsample to {output_file}")
+        print(f"Process {os.getpid()} - Finished subset to {output_file}")
 
-        # Verify the output file exists and has content
         if os.path.exists(output_file) and os.path.getsize(output_file) > 0:
             print(
-                f"Process {os.getpid()} - Successfully created {output_file} ({os.path.getsize(output_file)} bytes)"
+                f"Process {os.getpid()} - Successfully created {output_file} "
+                f"({os.path.getsize(output_file)} bytes)"
             )
         else:
             raise Exception(f"Output file {output_file} is empty or doesn't exist")
@@ -330,33 +322,33 @@ def write_subsample(
         raise
 
 
-def subsample_jsonl_file(
+def subset_jsonl_file(
     input_file: str,
-    subsamples_file: str,
+    subsets_file: str,
     output_dir: Optional[str] = None,
     compress: bool = True,
     n_processes: Optional[int] = None,
     overwrite: bool = False,
 ) -> None:
     """
-    subsample a large JSONL file into multiple files using sed for maximum performance.
+    subset a large JSONL file into multiple files using sed for maximum performance.
 
     Args:
         input_file: Path to input JSONL file (can be bz2 compressed)
-        subsamples_file: Path to JSON file containing subsample indices
-        output_dir: Directory to save subsample files (defaults to input file directory)
+        subsets_file: Path to JSON file containing subset indices
+        output_dir: Directory to save subset files (defaults to input file directory)
         compress: Whether to compress output files with bz2
-        n_processes: Number of processes to use (defaults to min(n_subsamples, cpu_count))
+        n_processes: Number of processes to use (defaults to min(n_subsets, cpu_count))
         overwrite: If False, skip existing output files (default: False)
     """
-    # Load subsamples information
-    with open(subsamples_file, "r") as f:
-        subsamples_data = json.load(f)
+    # Load subsets information
+    with open(subsets_file, "r") as f:
+        subsets_data = json.load(f)
 
     # Determine optimal number of processes
-    n_subsamples = len(subsamples_data["subsamples"])
+    n_subsets = len(subsets_data["subsets"])
     if n_processes is None:
-        n_processes = min(n_subsamples, cpu_count())
+        n_processes = min(n_subsets, cpu_count())
 
     if output_dir is None:
         output_dir = os.path.dirname(input_file)
@@ -369,9 +361,9 @@ def subsample_jsonl_file(
     # Prepare arguments for parallel processing
     write_args = []
     skipped_files = []
-    for subsample in subsamples_data["subsamples"]:
-        subsample_id = subsample["id"]
-        output_name = f"{base_name}_subsample_{subsample_id}.jsonl"
+    for subset in subsets_data["subsets"]:
+        subset_idx = subset["index"]
+        output_name = f"{base_name}_subset_{subset_idx+1}.jsonl"
         if compress:
             output_name += ".bz2"
         output_path = os.path.join(output_dir, output_name)
@@ -381,7 +373,7 @@ def subsample_jsonl_file(
             skipped_files.append(output_path)
             continue
 
-        write_args.append((input_file, subsample["indices"], output_path, compress))
+        write_args.append((input_file, subset["indices"], output_path, compress))
 
     if skipped_files:
         print(f"Skipping {len(skipped_files)} existing files:")
@@ -389,8 +381,8 @@ def subsample_jsonl_file(
             print(f"  - {file}")
 
     if write_args:
-        print(f"Processing {len(write_args)} subsamples using {n_processes} processes")
+        print(f"Processing {len(write_args)} subsets using {n_processes} processes")
         with Pool(processes=n_processes) as pool:
-            pool.starmap(write_subsample, write_args)
+            pool.starmap(write_subset, write_args)
     else:
         print("No files to process - all files exist and overwrite=False")

examples/basic_sampling.py

@@ -7,7 +7,7 @@ import os
 def run_crag_task_1_and_2(
     file_path: str,
     fields_to_extract: list[str] = None,
-    n_subsamples: int = 5,
+    n_subsets: int = 5,
     output_dir: str = None,
     compress: bool = True,
     n_processes: int = None,
@@ -18,7 +18,7 @@ def run_crag_task_1_and_2(
     Args:
         file_path: Path to input JSONL file
         fields_to_extract: List of fields to extract from JSONL
-        n_subsamples: Number of subsamples to create
+        n_subsets: Number of subsets to create
         output_dir: Directory for output files
         compress: Whether to compress output files
         n_processes: Number of processes for parallel processing
@@ -29,27 +29,25 @@ def run_crag_task_1_and_2(
         input_file=file_path, required_fields=fields_to_extract, use_cache=True
     )
 
-    # Create output path for subsamples
+    # Create output path for subsets
     output_path = os.path.join(
         os.path.dirname(file_path),
-        f"{os.path.splitext(os.path.basename(file_path))[0]}_subsamples.json",
+        f"{os.path.splitext(os.path.basename(file_path))[0]}_subsets.json",
     )
 
-    # Create subsamples
-    subsamples_data = sampler.create_subsamples(
-        n_subsamples=n_subsamples, output_path=output_path
-    )
+    # Create subsets
+    subsets_data = sampler.create_subsets(n_subsets=n_subsets, output_path=output_path)
 
     # Print statistics
-    print(f"Created {subsamples_data['metadata']['n_subsamples']} subsamples")
+    print(f"Created {subsets_data['metadata']['n_subsets']} subsets")
     print("\nGlobal statistics:")
-    print(json.dumps(subsamples_data["metadata"]["global_statistics"], indent=2))
-    print("\nFirst subsample statistics:")
-    print(json.dumps(subsamples_data["subsamples"][0]["statistics"], indent=2))
+    print(json.dumps(subsets_data["metadata"]["global_statistics"], indent=2))
+    print("\nFirst subset statistics:")
+    print(json.dumps(subsets_data["subsets"][0]["statistics"], indent=2))
 
-    # Write subsamples to files
-    sampler.write_subsamples(
-        subsamples_file=output_path,
+    # Write subsets to files
+    sampler.write_subsets(
+        subsets_file=output_path,
         output_dir=output_dir,
         compress=compress,
         n_processes=n_processes,
@@ -61,5 +59,9 @@ def run_crag_task_1_and_2(
 if __name__ == "__main__":
     file_path = "./local_data/crag_task_1_and_2_dev_v4.jsonl.bz2"
     fields_to_extract = ["domain", "answer", "question_type", "static_or_dynamic"]
+    n_subsets = 20
+    output_dir = "./subset/crag_task_1_and_2"
 
-    run_crag_task_1_and_2(file_path, fields_to_extract)
+    run_crag_task_1_and_2(
+        file_path, fields_to_extract, n_subsets=n_subsets, overwrite=True
+    )