# /// script # requires-python = ">=3.9" # dependencies = [ # "semhash", # "datasets", # "huggingface-hub", # "hf-transfer", # ] # /// """ Semantic deduplication for Hugging Face datasets using SemHash. This script removes duplicate or near-duplicate text samples from datasets based on semantic similarity, helping to clean training data and prevent train/test leakage. SemHash is CPU-optimized and uses Model2Vec embeddings that are 500x faster on CPU than traditional transformers. No GPU required! Example usage: # Basic deduplication uv run semantic-dedupe.py username/dataset text username/dataset-deduped # With custom threshold and max samples for testing uv run semantic-dedupe.py username/dataset text username/dataset-deduped \\ --threshold 0.85 --max-samples 1000 # Using HF Jobs (CPU is sufficient) hf jobs uv run --flavor cpu-4x-xlarge \\ -e HF_TOKEN=$(python3 -c "from huggingface_hub import get_token; print(get_token())") \\ https://huggingface.co/datasets/uv-scripts/deduplication/raw/main/semantic-dedupe.py \\ username/dataset text username/dataset-deduped """ import argparse import os import sys from datetime import datetime from typing import Optional from datasets import Dataset, load_dataset from huggingface_hub import DatasetCard, login from semhash import SemHash # Enable fast transfers os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1" def parse_args(): parser = argparse.ArgumentParser( description="Deduplicate a dataset using semantic similarity", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=""" Examples: # Basic usage uv run semantic-dedupe.py imdb text imdb-deduped # With options uv run semantic-dedupe.py squad question squad-deduped --threshold 0.85 --method duplicates # Test with small sample uv run semantic-dedupe.py large-dataset text test-dedup --max-samples 100 """, ) parser.add_argument("dataset", help="Input dataset ID (e.g., 'imdb' or 'username/dataset')") parser.add_argument("column", help="Text column to deduplicate on") parser.add_argument("output_repo", help="Output dataset repository name") parser.add_argument( "--split", default="train", help="Dataset split to process (default: train)", ) parser.add_argument( "--method", choices=["duplicates", "outliers", "representatives"], default="duplicates", help="Deduplication method (default: duplicates)", ) parser.add_argument( "--threshold", type=float, default=0.9, help="Similarity threshold for duplicates (default: 0.9)", ) parser.add_argument( "--batch-size", type=int, default=64, help="Batch size for processing (default: 64)", ) parser.add_argument( "--max-samples", type=int, help="Maximum number of samples to process (for testing)", ) parser.add_argument( "--private", action="store_true", help="Create private dataset repository", ) parser.add_argument( "--hf-token", default=os.environ.get("HF_TOKEN"), help="Hugging Face API token (defaults to HF_TOKEN env var)", ) return parser.parse_args() def create_dataset_card( original_dataset: str, column: str, method: str, threshold: float, original_size: int, deduped_size: int, ) -> str: """Create a dataset card with deduplication information.""" reduction_pct = ((original_size - deduped_size) / original_size) * 100 return f"""--- viewer: false tags: - deduplication - semhash - uv-script --- # Deduplicated {original_dataset} This dataset is a deduplicated version of [{original_dataset}](https://huggingface.co/datasets/{original_dataset}). ## Deduplication Details - **Method**: {method} - **Column**: `{column}` - **Threshold**: {threshold} - **Original size**: {original_size:,} samples - **Deduplicated size**: {deduped_size:,} samples - **Reduction**: {reduction_pct:.1f}% - **Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")} ## Method Description {get_method_description(method)} ## How to Use ```python from datasets import load_dataset # Load the deduplicated dataset dataset = load_dataset("{os.environ.get('HF_USERNAME', 'username')}/{os.path.basename(original_dataset)}-deduped") ``` ## Reproduce This dataset was created using the [uv-scripts/deduplication](https://huggingface.co/datasets/uv-scripts/deduplication) tool: ```bash uv run https://huggingface.co/datasets/uv-scripts/deduplication/raw/main/semantic-dedupe.py \\ {original_dataset} {column} {os.path.basename(original_dataset)}-deduped \\ --method {method} --threshold {threshold} ``` Generated with 🤖 UV Scripts """ def get_method_description(method: str) -> str: """Get description for deduplication method.""" descriptions = { "duplicates": "Removes semantic duplicates by finding samples with high similarity scores above the threshold.", "outliers": "Removes outlier samples that have low similarity to other samples in the dataset.", "representatives": "Keeps only representative samples, removing both duplicates and outliers.", } return descriptions.get(method, "Unknown method") def main(): args = parse_args() # Authenticate if args.hf_token: login(args.hf_token) else: print("Warning: No HF token provided. Using cached credentials or anonymous mode.") # Load dataset print(f"Loading dataset: {args.dataset}") dataset = load_dataset(args.dataset, split=args.split) # Apply max samples if specified if args.max_samples: dataset = dataset.select(range(min(args.max_samples, len(dataset)))) print(f"Limited to {len(dataset)} samples for testing") original_size = len(dataset) # Check if column exists if args.column not in dataset.column_names: print(f"Error: Column '{args.column}' not found in dataset") print(f"Available columns: {', '.join(dataset.column_names)}") sys.exit(1) # Convert dataset to records (preserves all columns) print("Converting dataset to records...") records = [dict(row) for row in dataset] # Initialize SemHash print("Initializing SemHash (CPU-optimized)...") semhash = SemHash.from_records(records=records, columns=[args.column]) # Perform deduplication print(f"Performing {args.method} deduplication on '{args.column}' column...") if args.method == "duplicates": result = semhash.self_deduplicate(threshold=args.threshold) elif args.method == "outliers": result = semhash.self_filter_outliers() elif args.method == "representatives": result = semhash.self_find_representative() else: raise ValueError(f"Unknown method: {args.method}") # Get deduplicated records (all columns preserved) deduplicated_records = result.selected # Convert back to HF Dataset result_dataset = Dataset.from_list(deduplicated_records) deduped_size = len(result_dataset) # Print statistics print(f"\nDeduplication complete!") print(f"Original size: {original_size:,}") print(f"Deduplicated size: {deduped_size:,}") print(f"Removed: {original_size - deduped_size:,} ({((original_size - deduped_size) / original_size) * 100:.1f}%)") print("\nNote: SemHash processes ~20,000 sentences/second on CPU") # Create dataset card card = create_dataset_card( args.dataset, args.column, args.method, args.threshold, original_size, deduped_size, ) # Push to hub print(f"\nPushing to hub: {args.output_repo}") result_dataset.push_to_hub( args.output_repo, private=args.private, commit_message=f"Deduplicated using {args.method} method", ) # Create and push dataset card dataset_card = DatasetCard(card) dataset_card.push_to_hub(args.output_repo) print(f"✅ Dataset successfully pushed to: https://huggingface.co/datasets/{args.output_repo}") if __name__ == "__main__": main()