Upload scripts/sample_atomic_commites.py with huggingface_hub

scripts/sample_atomic_commites.py

@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+"""
+Script to sample atomic commits from CCS dataset for concern extraction.
+Applies atomic sampling strategy with token filtering and SHA deduplication.
+"""
+
+import pandas as pd
+import tiktoken
+from typing import Dict, List, Set
+
+# Processing configuration
+CONVENTIONAL_COMMIT_TYPES: List[str] = ["cicd", "refactor", "fix", "test"]
+SAMPLES_PER_TYPE: int = 2
+TARGET_TOKEN_LIMIT: int = 12288  # 16384 - 4096
+ENCODING_MODEL: str = "cl100k_base"  # GPT-4 encoding
+
+# Column name constants
+COLUMN_SHA: str = "sha"
+COLUMN_ANNOTATED_TYPE: str = "annotated_type"
+COLUMN_GIT_DIFF: str = "git_diff"
+COLUMN_MASKED_COMMIT_MESSAGE: str = "masked_commit_message"
+OUTPUT_COLUMNS: List[str] = [
+    COLUMN_ANNOTATED_TYPE,
+    COLUMN_MASKED_COMMIT_MESSAGE,
+    COLUMN_GIT_DIFF,
+    COLUMN_SHA,
+]
+
+# Data transformation constants
+CI_TO_CICD_REPLACEMENT: str = "cicd"
+
+# File paths
+CCS_SOURCE_PATH: str = "data/CCS Dataset Training Data.csv"
+SAMPLED_CSV_PATH: str = "data/sampled_ccs_dataset.csv"
+DIFF_OUTPUT_DIR: str = "data/types"
+
+
+def normalize_dataset(df: pd.DataFrame) -> pd.DataFrame:
+    """Apply CI to CICD label normalization using pandas vectorized operations."""
+    # Use pandas replace for vectorized string replacement
+    df[COLUMN_ANNOTATED_TYPE] = (
+        df[COLUMN_ANNOTATED_TYPE]
+        .str.lower()
+        .str.strip()
+        .replace("ci", CI_TO_CICD_REPLACEMENT)
+    )
+    print("Applied CI -> CICD normalization using pandas replace()")
+    return df
+
+
+def apply_token_filtering(df: pd.DataFrame) -> pd.DataFrame:
+    """Apply token-based filtering using GPT-4 tokenizer with pandas operations."""
+    encoding = tiktoken.get_encoding(ENCODING_MODEL)
+
+    # Create combined text column for token counting using pandas string operations
+    combined_text = (
+        df[COLUMN_GIT_DIFF].astype(str)
+        + " "
+        + df[COLUMN_MASKED_COMMIT_MESSAGE].astype(str)
+    )
+
+    # Apply token counting function and create boolean mask using pandas apply()
+    token_counts = combined_text.apply(lambda x: len(encoding.encode(x)))
+    token_mask = token_counts <= TARGET_TOKEN_LIMIT
+
+    # Filter using pandas boolean indexing
+    filtered_df = df[token_mask].copy()
+
+    removed_count = len(df) - len(filtered_df)
+    if removed_count > 0:
+        print(
+            f"Token filtering: removed {removed_count} commits exceeding {TARGET_TOKEN_LIMIT} tokens using pandas boolean indexing"
+        )
+
+    print(f"Token filtering: kept {len(filtered_df)} commits")
+    return filtered_df
+
+
+def apply_sha_deduplication(df: pd.DataFrame, excluded_shas: Set[str]) -> pd.DataFrame:
+    """Apply SHA deduplication using pandas isin() for efficient filtering."""
+    original_count = len(df)
+
+    # Use pandas isin() for vectorized membership testing
+    sha_mask = ~df[COLUMN_SHA].astype(str).isin(excluded_shas)
+    filtered_df = df[sha_mask].copy()
+
+    removed_count = original_count - len(filtered_df)
+    print(
+        f"SHA deduplication: removed {removed_count} duplicate commits using pandas isin()"
+    )
+    return filtered_df
+
+
+def load_existing_shas(file_path: str) -> Set[str]:
+    """Load existing SHAs from sampled dataset to exclude duplicates."""
+    try:
+        df = pd.read_csv(file_path)
+        sha_set = set(df[COLUMN_SHA].astype(str))
+        print(f"Loaded {len(sha_set)} SHAs for deduplication")
+        return sha_set
+    except FileNotFoundError:
+        print(f"No existing samples found at {file_path}")
+        return set()
+    except Exception as e:
+        print(f"Error loading existing SHAs: {e}")
+        return set()
+
+
+def load_ccs_dataset(file_path: str) -> pd.DataFrame:
+    """Load CCS dataset CSV file as pandas DataFrame."""
+    try:
+        df = pd.read_csv(file_path)
+        if df.empty:
+            raise ValueError("Dataset is empty")
+
+        required_columns = set(OUTPUT_COLUMNS)
+        available_columns = set(df.columns)
+
+        missing_columns = required_columns - available_columns
+        if missing_columns:
+            raise ValueError(f"Missing required columns: {missing_columns}")
+
+        print(f"Dataset validation passed: {len(df)} records with required columns")
+
+        print(f"Loaded {len(df)} records from CCS dataset as DataFrame")
+        return df
+    except Exception as e:
+        print(f"Error loading dataset: {e}")
+        raise
+
+
+def save_to_csv(
+    data: List[Dict[str, str]], output_path: str, columns: List[str]
+) -> None:
+    """Save processed data to CSV file."""
+    import os
+
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+
+    if data:
+        df = pd.DataFrame(data, columns=columns)
+        file_exists = os.path.exists(output_path)
+
+        df.to_csv(
+            output_path,
+            mode="a" if file_exists else "w",
+            header=not file_exists,
+            index=False,
+        )
+
+    print(f"Saved {len(data)} records to {output_path}")
+
+
+def group_commits_by_type(
+    df: pd.DataFrame, valid_types: List[str]
+) -> Dict[str, pd.DataFrame]:
+    """Group commits by their concern type using pandas groupby."""
+    # Filter valid types using pandas isin() for vectorized filtering
+    type_mask = df[COLUMN_ANNOTATED_TYPE].isin(valid_types)
+    valid_df = df[type_mask].copy()
+
+    excluded_count = len(df) - len(valid_df)
+    print(
+        f"Type filtering: excluded {excluded_count} records (invalid types) using pandas isin()"
+    )
+
+    # Use pandas groupby for efficient grouping
+    commits_by_type = {}
+    for commit_type, group_df in valid_df.groupby(COLUMN_ANNOTATED_TYPE):
+        commits_by_type[commit_type] = group_df
+        print(f"  {commit_type}: {len(group_df)} commits")
+
+    return commits_by_type
+
+
+def sample_commits_for_type(
+    df: pd.DataFrame, count: int, output_columns: List[str]
+) -> List[Dict[str, str]]:
+    """Randomly sample specified number of commits using pandas sample()."""
+    # Use pandas sample() for efficient random sampling
+    sampled_df = df.sample(n=count, random_state=None)
+
+    # Convert only the final result to dict list for compatibility
+    sampled_data = sampled_df[output_columns].to_dict("records")
+    return sampled_data
+
+
+def extract_diffs(sampled_data: List[Dict[str, str]], output_dir: str) -> None:
+    """Extract git diff files organized by type into separate directories."""
+    import os
+
+    type_counts = {}
+
+    for record in sampled_data:
+        commit_type = record[COLUMN_ANNOTATED_TYPE]
+
+        # Create type directory if needed
+        type_dir = os.path.join(output_dir, commit_type)
+        os.makedirs(type_dir, exist_ok=True)
+
+        # Count entries for this type
+        if commit_type not in type_counts:
+            type_counts[commit_type] = 0
+        type_counts[commit_type] += 1
+
+        # Generate filename
+        filename = f"{commit_type}_{type_counts[commit_type]}_{record[COLUMN_SHA]}.diff"
+        filepath = os.path.join(type_dir, filename)
+
+        # Create file content with metadata
+        content_lines = [
+            f"# Type: {commit_type}",
+            f"# Commit Message: {record[COLUMN_MASKED_COMMIT_MESSAGE]}",
+            f"# SHA: {record[COLUMN_SHA]}",
+            "",
+            "# === Git Diff Content ===",
+            "",
+            record[COLUMN_GIT_DIFF],
+        ]
+
+        with open(filepath, "w") as f:
+            f.write("\n".join(content_lines))
+
+    print(f"Extracted {len(sampled_data)} diff files to {output_dir}")
+
+
+def main() -> None:
+    """
+    Main function implementing atomic sampling strategy:
+    1. Load dataset and backup SHAs
+    2. Apply CI->CICD normalization
+    3. Apply token-based filtering
+    4. Apply SHA deduplication
+    5. Group by type and randomly sample
+    6. Save results and extract diffs
+    """
+    print("Starting atomic sampling strategy for CCS dataset")
+    print("=" * 50)
+
+    # Step 1: Load dataset and backup SHAs
+    print("Step 1: Loading dataset and backup SHAs")
+    excluded_shas = load_existing_shas(SAMPLED_CSV_PATH)
+    ccs_df = load_ccs_dataset(CCS_SOURCE_PATH)
+
+    # Step 2: Apply CI->CICD normalization
+    print("\nStep 2: Applying CI->CICD normalization")
+    ccs_df = normalize_dataset(ccs_df)
+
+    # Step 3: Apply token-based filtering
+    print("\nStep 3: Applying token-based filtering")
+    ccs_df = apply_token_filtering(ccs_df)
+
+    # Step 4: Apply SHA deduplication
+    print("\nStep 4: Applying SHA deduplication")
+    ccs_df = apply_sha_deduplication(ccs_df, excluded_shas)
+
+    # Step 5: Group by type and randomly sample
+    print("\nStep 5: Grouping by type and random sampling")
+    commits_by_type = group_commits_by_type(ccs_df, CONVENTIONAL_COMMIT_TYPES)
+
+    all_sampled_data = []
+    for commits_df in commits_by_type.values():
+        sampled_data = sample_commits_for_type(
+            commits_df, SAMPLES_PER_TYPE, OUTPUT_COLUMNS
+        )
+        all_sampled_data.extend(sampled_data)
+
+    print(f"Random sampling: generated {len(all_sampled_data)} samples total")
+
+    # Step 6: Save results and extract diffs
+    print("\nStep 6: Saving results and extracting diffs")
+    save_to_csv(all_sampled_data, SAMPLED_CSV_PATH, OUTPUT_COLUMNS)
+    extract_diffs(all_sampled_data, DIFF_OUTPUT_DIR)
+
+    # Final summary
+    print("\n" + "=" * 50)
+    print("Atomic sampling completed successfully!")
+
+    type_counts = {}
+    for record in all_sampled_data:
+        commit_type = record.get(COLUMN_ANNOTATED_TYPE, "")
+        type_counts[commit_type] = type_counts.get(commit_type, 0) + 1
+
+    print("Final sample distribution:")
+    for commit_type in sorted(type_counts.keys()):
+        print(f"  {commit_type}: {type_counts[commit_type]} samples")
+
+
+if __name__ == "__main__":
+    main()