Added script to create subsamples

crag_to_subsamples.py

@@ -0,0 +1,446 @@
+import bz2
+from typing import Iterator, Dict, Any
+import pandas as pd
+import os
+import hashlib
+import json
+from sklearn.model_selection import StratifiedKFold
+import numpy as np
+from multiprocessing import Pool, cpu_count
+from functools import partial
+import subprocess
+
+
+def get_cache_path(file_path: str, required_fields: list[str]) -> str:
+    """
+    Generate a unique cache file path based on input file and fields.
+
+    Args:
+        file_path: Path to the input JSONL file
+        required_fields: List of field names to extract
+
+    Returns:
+        Path to the cache file
+    """
+    # Create a unique hash based on the file path and fields
+    fields_str = ",".join(sorted(required_fields))
+    hash_input = f"{fields_str}"
+    hash_str = hashlib.md5(hash_input.encode()).hexdigest()[:10]
+
+    # Get the directory of the input file
+    base_dir = os.path.dirname(file_path)
+    # Get filename from file path
+    file_name = os.path.basename(file_path).split(".")[0]
+    cache_name = f"{file_name}_cache_{hash_str}.parquet"
+    return os.path.join(base_dir, cache_name)
+
+
+def read_jsonl_fields_fast(
+    file_path: str, required_fields: list[str], use_cache: bool = True
+) -> pd.DataFrame:
+    """
+    Quickly extract specific fields from a compressed JSONL file using string operations.
+    Results are cached in parquet format for faster subsequent reads.
+
+    Args:
+        file_path: Path to the JSONL file (can be bz2 compressed)
+        required_fields: List of field names to extract from each JSON object
+        use_cache: Whether to use/create cache file (default: True)
+
+    Returns:
+        DataFrame containing the requested fields
+    """
+    cache_path = get_cache_path(file_path, required_fields)
+    print(f"Cache path: {cache_path}")
+    # Try to load from cache first
+    if use_cache and os.path.exists(cache_path):
+        return pd.read_parquet(cache_path)
+
+    # If no cache exists, process the file
+    records = []
+    patterns = [f'"{field}":' for field in required_fields]
+
+    with bz2.open(file_path, "rt") as file:
+        for line in file:
+            if not line.strip():
+                continue
+
+            result = {}
+            for field, pattern in zip(required_fields, patterns):
+                try:
+                    # Find the field in the line
+                    start_idx = line.find(pattern)
+                    if start_idx == -1:
+                        continue
+
+                    # Move to the start of the value
+                    start_idx += len(pattern)
+                    while start_idx < len(line) and line[start_idx].isspace():
+                        start_idx += 1
+
+                    # Handle different value types
+                    if start_idx >= len(line):
+                        continue
+
+                    if line[start_idx] == '"':
+                        # String value
+                        start_idx += 1
+                        end_idx = line.find('"', start_idx)
+                        value = line[start_idx:end_idx]
+                    elif line[start_idx] == "{" or line[start_idx] == "[":
+                        # Skip nested objects/arrays
+                        continue
+                    else:
+                        # Number, boolean, or null
+                        end_idx = line.find(",", start_idx)
+                        if end_idx == -1:
+                            end_idx = line.find("}", start_idx)
+                        value = line[start_idx:end_idx].strip()
+                        # Convert to appropriate type
+                        if value == "true":
+                            value = True
+                        elif value == "false":
+                            value = False
+                        elif value == "null":
+                            value = None
+                        else:
+                            try:
+                                value = float(value) if "." in value else int(value)
+                            except ValueError:
+                                continue
+
+                    result[field] = value
+                except Exception:
+                    continue
+
+            if result:
+                records.append(result)
+
+    # Convert to DataFrame
+    df = pd.DataFrame.from_records(records)
+
+    # Convert columns to appropriate types
+    for col in df.columns:
+        # If the column contains any strings, convert the whole column to strings
+        if (
+            df[col].dtype == object
+            and df[col].apply(lambda x: isinstance(x, str)).any()
+        ):
+            df[col] = df[col].astype(str)
+        # You can add more type conversions here if needed
+
+    # Save cache if enabled
+    if use_cache:
+        df.to_parquet(cache_path)
+
+    return df
+
+
+def process_answer_types(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Process the answer field to create a new answer_type field.
+
+    Args:
+        df: Input DataFrame with 'answer' column
+
+    Returns:
+        DataFrame with new 'answer_type' column
+    """
+    # Create a copy to avoid modifying the original
+    df = df.copy()
+
+    # Print unique answers to debug
+    print("Unique answers in dataset:")
+    print(df["answer"].unique())
+
+    # Create answer_type column with case-insensitive matching
+    conditions = [
+        df["answer"].str.lower() == "invalid question",
+        df["answer"].str.lower() == "i don't know",  # Try exact match
+    ]
+    choices = ["invalid", "no_answer"]
+    df["answer_type"] = np.select(conditions, choices, default="valid")
+
+    # Print distribution to verify
+    print("\nAnswer type distribution:")
+    print(df["answer_type"].value_counts())
+
+    return df
+
+
+def create_stratified_subsamples(
+    df: pd.DataFrame,
+    n_subsamples: int,
+    stratify_columns: list[str] = [
+        "domain",
+        "answer_type",
+        "question_type",
+        "static_or_dynamic",
+    ],
+    output_path: str = "subsamples.json",
+    force_compute: bool = False,
+) -> dict:
+    """
+    Create stratified subsamples of the dataset and save them to a JSON file.
+    Each subsample gets a unique ID based on its indices.
+
+    Args:
+        df: Input DataFrame
+        n_subsamples: Number of subsamples 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
+
+    Returns:
+        Dictionary containing the subsamples 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)
+
+            # 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")
+                == stratify_columns
+            ):
+                print(f"Loading existing subsamples from {output_path}")
+                return subsamples_data
+            else:
+                print(
+                    "Existing subsamples file has different parameters, recomputing..."
+                )
+        except Exception as e:
+            print(f"Error loading existing subsamples 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)
+
+    # Create subsamples
+    subsamples_info = []
+    for subsample_idx, (_, subsample_indices) in enumerate(
+        skf.split(df, df["strat_category"])
+    ):
+        # Sort indices for consistent hashing
+        sorted_indices = sorted(subsample_indices.tolist())
+
+        # Create a deterministic ID from the indices
+        subsample_id = hashlib.md5(str(sorted_indices).encode()).hexdigest()[:8]
+
+        # Calculate statistics for this subsample
+        stats = {}
+        subsample_df = df.iloc[subsample_indices]
+        for col in stratify_columns:
+            stats[col] = subsample_df[col].value_counts().to_dict()
+
+        subsamples_info.append(
+            {
+                "id": subsample_id,
+                "statistics": stats,
+                "indices": sorted_indices,
+                "size": len(subsample_indices),
+            }
+        )
+
+    # Add global statistics
+    global_stats = {}
+    for col in stratify_columns:
+        global_stats[col] = df[col].value_counts().to_dict()
+
+    output_data = {
+        "metadata": {
+            "n_subsamples": n_subsamples,
+            "total_samples": len(df),
+            "stratify_columns": stratify_columns,
+            "global_statistics": global_stats,
+        },
+        "subsamples": subsamples_info,
+    }
+
+    # Save to JSON
+    with open(output_path, "w") as f:
+        json.dump(output_data, f, indent=2)
+
+    return output_data
+
+
+def write_subsample(
+    input_file: str, indices: list[int], output_file: str, compress: bool = True
+) -> None:
+    """
+    Write a single subsample to a file using awk.
+
+    Args:
+        input_file: Path to input JSONL file
+        indices: List of indices to extract
+        output_file: Path to output file
+        compress: Whether to compress output
+    """
+    # Convert indices to awk condition
+    # NR is the current line number in awk
+    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'
+    )
+
+    if input_file.endswith(".bz2"):
+        if compress:
+            cmd = f"bzcat '{input_file}' | awk '{awk_script}' | bzip2 > '{output_file}'"
+        else:
+            cmd = f"bzcat '{input_file}' | awk '{awk_script}' > '{output_file}'"
+    else:
+        if compress:
+            cmd = f"awk '{awk_script}' '{input_file}' | bzip2 > '{output_file}'"
+        else:
+            cmd = f"awk '{awk_script}' '{input_file}' > '{output_file}'"
+
+    print(f"Process {os.getpid()} - Starting subsample to {output_file}")
+    try:
+        result = subprocess.run(
+            cmd,
+            shell=True,
+            check=True,
+            stderr=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            text=True,
+        )
+        print(f"Process {os.getpid()} - Finished subsample 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)"
+            )
+        else:
+            raise Exception(f"Output file {output_file} is empty or doesn't exist")
+
+    except subprocess.CalledProcessError as e:
+        print(f"Error executing command: {e.stderr}")
+        print(f"Command output: {e.stdout}")
+        raise
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        raise
+
+
+def subsample_jsonl_file(
+    input_file: str,
+    subsamples_file: str,
+    output_dir: str = None,
+    compress: bool = True,
+    n_processes: int = None,
+    overwrite: bool = False,
+) -> None:
+    """
+    subsample 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)
+        compress: Whether to compress output files with bz2
+        n_processes: Number of processes to use (defaults to min(n_subsamples, 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)
+
+    # Determine optimal number of processes
+    n_subsamples = len(subsamples_data["subsamples"])
+    if n_processes is None:
+        n_processes = min(n_subsamples, cpu_count())
+
+    if output_dir is None:
+        output_dir = os.path.dirname(input_file)
+    os.makedirs(output_dir, exist_ok=True)
+
+    base_name = os.path.splitext(os.path.basename(input_file))[0]
+    if base_name.endswith(".jsonl"):
+        base_name = os.path.splitext(base_name)[0]
+
+    # 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"
+        if compress:
+            output_name += ".bz2"
+        output_path = os.path.join(output_dir, output_name)
+
+        # Skip if file exists and overwrite is False
+        if not overwrite and os.path.exists(output_path):
+            skipped_files.append(output_path)
+            continue
+
+        write_args.append((input_file, subsample["indices"], output_path, compress))
+
+    if skipped_files:
+        print(f"Skipping {len(skipped_files)} existing files:")
+        for file in skipped_files:
+            print(f"  - {file}")
+
+    if write_args:
+        print(f"Processing {len(write_args)} subsamples using {n_processes} processes")
+        with Pool(processes=n_processes) as pool:
+            pool.starmap(write_subsample, write_args)
+    else:
+        print("No files to process - all files exist and overwrite=False")
+
+
+def run_crag_task_1_and_2(
+    file_path: str,
+    fields_to_extract: list[str],
+    n_subsamples: int = 5,
+    output_dir: str = None,
+    compress: bool = True,
+    n_processes: int = None,
+    overwrite: bool = False,
+):
+    # Load and process data
+    df = read_jsonl_fields_fast(file_path, fields_to_extract)
+    df = process_answer_types(df)
+    print(df.head())
+
+    output_path = os.path.join(
+        os.path.dirname(file_path),
+        os.path.basename(file_path).split(".")[0] + "_subsamples.json",
+    )
+
+    # This will load from file if it exists and parameters match
+    subsamples_data = create_stratified_subsamples(
+        df, n_subsamples=5, output_path=output_path
+    )
+
+    # Example of how to read and use the subsamples
+    with open(output_path, "r") as f:
+        subsamples_data = json.load(f)
+
+    # Print some information about the subsamples
+    print(f"Created {subsamples_data['metadata']['n_subsamples']} subsamples")
+    print("\nGlobal statistics:")
+    print(json.dumps(subsamples_data["metadata"]["global_statistics"], indent=2))
+
+    # Print statistics for first subsample
+    print("\nFirst subsample statistics:")
+    print(json.dumps(subsamples_data["subsamples"][0]["statistics"], indent=2))
+
+    # This will use all available CPU cores
+    subsample_jsonl_file(file_path, output_path, compress=True)
+
+
+# Example usage
+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"]
+
+    run_crag_task_1_and_2(file_path, fields_to_extract)

pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "lejuge"
+version = "0.1.0"
+description = "Add your description here"
+authors = [
+    { name = "Jacopo Chevallard", email = "[email protected]" }
+]
+dependencies = [
+    "ipykernel>=6.29.5",
+    "pandas>=2.2.3",
+    "fastparquet>=2024.11.0",
+    "scikit-learn>=1.6.1",
+]
+readme = "README.md"
+requires-python = ">= 3.11"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.rye]
+managed = true
+dev-dependencies = []
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/lejuge"]

requirements-dev.lock

@@ -0,0 +1,109 @@
+# generated by rye
+# use `rye lock` or `rye sync` to update this lockfile
+#
+# last locked with the following flags:
+#   pre: false
+#   features: []
+#   all-features: false
+#   with-sources: false
+#   generate-hashes: false
+#   universal: false
+
+-e file:.
+appnope==0.1.4
+    # via ipykernel
+asttokens==3.0.0
+    # via stack-data
+comm==0.2.2
+    # via ipykernel
+cramjam==2.9.1
+    # via fastparquet
+debugpy==1.8.12
+    # via ipykernel
+decorator==5.1.1
+    # via ipython
+executing==2.2.0
+    # via stack-data
+fastparquet==2024.11.0
+    # via lejuge
+fsspec==2024.12.0
+    # via fastparquet
+ipykernel==6.29.5
+    # via lejuge
+ipython==8.31.0
+    # via ipykernel
+jedi==0.19.2
+    # via ipython
+joblib==1.4.2
+    # via scikit-learn
+jupyter-client==8.6.3
+    # via ipykernel
+jupyter-core==5.7.2
+    # via ipykernel
+    # via jupyter-client
+matplotlib-inline==0.1.7
+    # via ipykernel
+    # via ipython
+nest-asyncio==1.6.0
+    # via ipykernel
+numpy==2.2.2
+    # via fastparquet
+    # via pandas
+    # via scikit-learn
+    # via scipy
+packaging==24.2
+    # via fastparquet
+    # via ipykernel
+pandas==2.2.3
+    # via fastparquet
+    # via lejuge
+parso==0.8.4
+    # via jedi
+pexpect==4.9.0
+    # via ipython
+platformdirs==4.3.6
+    # via jupyter-core
+prompt-toolkit==3.0.50
+    # via ipython
+psutil==6.1.1
+    # via ipykernel
+ptyprocess==0.7.0
+    # via pexpect
+pure-eval==0.2.3
+    # via stack-data
+pygments==2.19.1
+    # via ipython
+python-dateutil==2.9.0.post0
+    # via jupyter-client
+    # via pandas
+pytz==2024.2
+    # via pandas
+pyzmq==26.2.0
+    # via ipykernel
+    # via jupyter-client
+scikit-learn==1.6.1
+    # via lejuge
+scipy==1.15.1
+    # via scikit-learn
+six==1.17.0
+    # via python-dateutil
+stack-data==0.6.3
+    # via ipython
+threadpoolctl==3.5.0
+    # via scikit-learn
+tornado==6.4.2
+    # via ipykernel
+    # via jupyter-client
+traitlets==5.14.3
+    # via comm
+    # via ipykernel
+    # via ipython
+    # via jupyter-client
+    # via jupyter-core
+    # via matplotlib-inline
+typing-extensions==4.12.2
+    # via ipython
+tzdata==2025.1
+    # via pandas
+wcwidth==0.2.13
+    # via prompt-toolkit

requirements.lock

@@ -0,0 +1,109 @@
+# generated by rye
+# use `rye lock` or `rye sync` to update this lockfile
+#
+# last locked with the following flags:
+#   pre: false
+#   features: []
+#   all-features: false
+#   with-sources: false
+#   generate-hashes: false
+#   universal: false
+
+-e file:.
+appnope==0.1.4
+    # via ipykernel
+asttokens==3.0.0
+    # via stack-data
+comm==0.2.2
+    # via ipykernel
+cramjam==2.9.1
+    # via fastparquet
+debugpy==1.8.12
+    # via ipykernel
+decorator==5.1.1
+    # via ipython
+executing==2.2.0
+    # via stack-data
+fastparquet==2024.11.0
+    # via lejuge
+fsspec==2024.12.0
+    # via fastparquet
+ipykernel==6.29.5
+    # via lejuge
+ipython==8.31.0
+    # via ipykernel
+jedi==0.19.2
+    # via ipython
+joblib==1.4.2
+    # via scikit-learn
+jupyter-client==8.6.3
+    # via ipykernel
+jupyter-core==5.7.2
+    # via ipykernel
+    # via jupyter-client
+matplotlib-inline==0.1.7
+    # via ipykernel
+    # via ipython
+nest-asyncio==1.6.0
+    # via ipykernel
+numpy==2.2.2
+    # via fastparquet
+    # via pandas
+    # via scikit-learn
+    # via scipy
+packaging==24.2
+    # via fastparquet
+    # via ipykernel
+pandas==2.2.3
+    # via fastparquet
+    # via lejuge
+parso==0.8.4
+    # via jedi
+pexpect==4.9.0
+    # via ipython
+platformdirs==4.3.6
+    # via jupyter-core
+prompt-toolkit==3.0.50
+    # via ipython
+psutil==6.1.1
+    # via ipykernel
+ptyprocess==0.7.0
+    # via pexpect
+pure-eval==0.2.3
+    # via stack-data
+pygments==2.19.1
+    # via ipython
+python-dateutil==2.9.0.post0
+    # via jupyter-client
+    # via pandas
+pytz==2024.2
+    # via pandas
+pyzmq==26.2.0
+    # via ipykernel
+    # via jupyter-client
+scikit-learn==1.6.1
+    # via lejuge
+scipy==1.15.1
+    # via scikit-learn
+six==1.17.0
+    # via python-dateutil
+stack-data==0.6.3
+    # via ipython
+threadpoolctl==3.5.0
+    # via scikit-learn
+tornado==6.4.2
+    # via ipykernel
+    # via jupyter-client
+traitlets==5.14.3
+    # via comm
+    # via ipykernel
+    # via ipython
+    # via jupyter-client
+    # via jupyter-core
+    # via matplotlib-inline
+typing-extensions==4.12.2
+    # via ipython
+tzdata==2025.1
+    # via pandas
+wcwidth==0.2.13
+    # via prompt-toolkit