Remove local test files

HuggingFaceFW_fineweb-edu_summary.json

@@ -1,58 +0,0 @@
-{
-  "dataset": "HuggingFaceFW/fineweb-edu",
-  "split": "train",
-  "text_column": "text",
-  "total_samples": 10,
-  "statistics": {
-    "character_count": {
-      "count": 10,
-      "mean": 3761.2,
-      "std": 2456.61,
-      "min": 396,
-      "max": 7966
-    },
-    "word_count": {
-      "count": 10,
-      "mean": 591.2,
-      "std": 385.27,
-      "min": 56,
-      "max": 1272
-    },
-    "line_count": {
-      "count": 10,
-      "mean": 31.2,
-      "std": 27.54,
-      "min": 2,
-      "max": 93
-    },
-    "sentence_count": {
-      "count": 10,
-      "mean": 25.7,
-      "std": 18.8,
-      "min": 5,
-      "max": 71
-    },
-    "mean_word_length": {
-      "count": 10,
-      "mean": 5.45,
-      "std": 0.46,
-      "min": 4.7,
-      "max": 6.09
-    }
-  },
-  "character_type_distribution": {
-    "alphanumeric": 0.8164,
-    "alphabetic": 0.8093,
-    "digit": 0.0071,
-    "uppercase": 0.0293,
-    "lowercase": 0.78,
-    "whitespace": 0.1554,
-    "punctuation": 0.0276,
-    "special": 0.0006
-  },
-  "derived_metrics": {
-    "avg_words_per_line": 18.95,
-    "avg_chars_per_word": 6.36,
-    "avg_words_per_sentence": 23.0
-  }
-}

basic-stats.py

@@ -1,338 +0,0 @@
-#!/usr/bin/env python3
-# /// script
-# requires-python = ">=3.10"
-# dependencies = [
-#     "datasets",
-#     "huggingface-hub",
-#     "tqdm",
-# ]
-# ///
-
-"""Calculate basic text statistics for HuggingFace datasets.
-
-This script computes essential text statistics using pure Python (no ML models).
-It uses streaming mode by default, so it works on datasets of any size without
-downloading the full dataset.
-
-Statistics calculated:
-- Character, word, line, sentence counts (per sample and total)
-- Streaming mean and standard deviation (Welford's algorithm)
-- Character type distributions (alphanumeric, digits, punctuation, whitespace, special)
-- Length statistics (min, max, approximate percentiles)
-
-Examples:
-    # Quick test on 10k samples
-    uv run basic-stats.py HuggingFaceFW/fineweb-edu --max-samples 10000
-
-    # Full dataset statistics
-    uv run basic-stats.py allenai/c4 --split train
-
-    # Save per-sample statistics to CSV
-    uv run basic-stats.py username/dataset --per-sample --output-file stats.csv
-
-    # Use with HF Jobs (GPU not needed)
-    hf jobs uv run \
-        -e HF_TOKEN=$(python3 -c "from huggingface_hub import get_token; print(get_token())") \
-        https://huggingface.co/datasets/uv-scripts/dataset-stats/raw/main/basic-stats.py \
-        username/large-dataset --max-samples 100000
-
-Performance:
-    ~10,000-50,000 samples/sec on CPU (depending on text length)
-    Pure Python, minimal memory usage (constant O(1) for streaming stats)
-"""
-
-import argparse
-import json
-import re
-import string
-import sys
-from collections import defaultdict
-from dataclasses import asdict, dataclass
-from pathlib import Path
-from typing import Optional
-
-from datasets import load_dataset
-from tqdm import tqdm
-
-
-@dataclass
-class StreamingStats:
-    """Track streaming statistics using Welford's algorithm for numerical stability."""
-
-    count: int = 0
-    mean: float = 0.0
-    m2: float = 0.0  # Sum of squared differences from mean
-    min_val: float = float('inf')
-    max_val: float = float('-inf')
-
-    def update(self, value: float):
-        """Update statistics with new value."""
-        self.count += 1
-        delta = value - self.mean
-        self.mean += delta / self.count
-        delta2 = value - self.mean
-        self.m2 += delta * delta2
-        self.min_val = min(self.min_val, value)
-        self.max_val = max(self.max_val, value)
-
-    @property
-    def variance(self) -> float:
-        """Calculate variance."""
-        return self.m2 / self.count if self.count > 1 else 0.0
-
-    @property
-    def std(self) -> float:
-        """Calculate standard deviation."""
-        return self.variance ** 0.5
-
-    def to_dict(self) -> dict:
-        """Convert to dictionary for JSON output."""
-        return {
-            "count": self.count,
-            "mean": round(self.mean, 2),
-            "std": round(self.std, 2),
-            "min": round(self.min_val, 2),
-            "max": round(self.max_val, 2),
-        }
-
-
-def count_sentences(text: str) -> int:
-    """Count sentences using simple heuristic (. ! ?)."""
-    # Simple sentence boundary detection
-    sentence_endings = re.findall(r'[.!?]+', text)
-    return max(1, len(sentence_endings))  # At least 1 sentence
-
-
-def calculate_char_type_distribution(text: str) -> dict:
-    """Calculate distribution of character types."""
-    if not text:
-        return {
-            "alphanumeric": 0.0,
-            "alphabetic": 0.0,
-            "digit": 0.0,
-            "uppercase": 0.0,
-            "lowercase": 0.0,
-            "whitespace": 0.0,
-            "punctuation": 0.0,
-            "special": 0.0,
-        }
-
-    total_chars = len(text)
-    alpha_count = sum(1 for c in text if c.isalpha())
-    digit_count = sum(1 for c in text if c.isdigit())
-    upper_count = sum(1 for c in text if c.isupper())
-    lower_count = sum(1 for c in text if c.islower())
-    whitespace_count = sum(1 for c in text if c.isspace())
-    punct_count = sum(1 for c in text if c in string.punctuation)
-
-    return {
-        "alphanumeric": round((alpha_count + digit_count) / total_chars, 4),
-        "alphabetic": round(alpha_count / total_chars, 4),
-        "digit": round(digit_count / total_chars, 4),
-        "uppercase": round(upper_count / total_chars, 4) if alpha_count > 0 else 0.0,
-        "lowercase": round(lower_count / total_chars, 4) if alpha_count > 0 else 0.0,
-        "whitespace": round(whitespace_count / total_chars, 4),
-        "punctuation": round(punct_count / total_chars, 4),
-        "special": round((total_chars - alpha_count - digit_count - whitespace_count - punct_count) / total_chars, 4),
-    }
-
-
-def calculate_basic_stats(text: str) -> dict:
-    """Calculate basic statistics for a single text sample."""
-    if not text:
-        return {
-            "char_count": 0,
-            "word_count": 0,
-            "line_count": 0,
-            "sentence_count": 0,
-            "mean_word_length": 0.0,
-        }
-
-    char_count = len(text)
-    words = text.split()
-    word_count = len(words)
-    line_count = len(text.splitlines())
-    sentence_count = count_sentences(text)
-    mean_word_length = sum(len(w) for w in words) / word_count if word_count > 0 else 0.0
-
-    return {
-        "char_count": char_count,
-        "word_count": word_count,
-        "line_count": line_count,
-        "sentence_count": sentence_count,
-        "mean_word_length": round(mean_word_length, 2),
-    }
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Calculate basic text statistics for HuggingFace datasets",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=__doc__,
-    )
-    parser.add_argument(
-        "dataset",
-        help="Dataset name (e.g., 'HuggingFaceFW/fineweb-edu') or local path",
-    )
-    parser.add_argument(
-        "--split",
-        default="train",
-        help="Dataset split to process (default: train)",
-    )
-    parser.add_argument(
-        "--text-column",
-        default="text",
-        help="Name of the text column (default: text)",
-    )
-    parser.add_argument(
-        "--max-samples",
-        type=int,
-        help="Maximum number of samples to process (for testing)",
-    )
-    parser.add_argument(
-        "--per-sample",
-        action="store_true",
-        help="Save per-sample statistics to CSV file",
-    )
-    parser.add_argument(
-        "--output-file",
-        help="Output file for per-sample stats (default: dataset-stats.csv)",
-    )
-    parser.add_argument(
-        "--streaming",
-        action="store_true",
-        default=True,
-        help="Use streaming mode (default: True)",
-    )
-
-    args = parser.parse_args()
-
-    # Load dataset in streaming mode
-    print(f"Loading dataset: {args.dataset} (split: {args.split})")
-    print(f"Streaming mode: {args.streaming}")
-
-    try:
-        dataset = load_dataset(
-            args.dataset,
-            split=args.split,
-            streaming=args.streaming,
-        )
-    except Exception as e:
-        print(f"Error loading dataset: {e}")
-        sys.exit(1)
-
-    # Check if text column exists
-    if args.text_column not in dataset.column_names:
-        print(f"Error: Column '{args.text_column}' not found in dataset.")
-        print(f"Available columns: {dataset.column_names}")
-        sys.exit(1)
-
-    # Initialize streaming statistics
-    char_stats = StreamingStats()
-    word_stats = StreamingStats()
-    line_stats = StreamingStats()
-    sentence_stats = StreamingStats()
-    word_length_stats = StreamingStats()
-
-    # Character type distribution accumulator
-    char_type_totals = defaultdict(float)
-
-    # For per-sample output
-    per_sample_data = []
-
-    # Process dataset
-    total_samples = args.max_samples if args.max_samples else "unknown"
-    with tqdm(total=args.max_samples, desc="Processing samples") as pbar:
-        for i, sample in enumerate(dataset):
-            if args.max_samples and i >= args.max_samples:
-                break
-
-            text = sample[args.text_column]
-
-            # Calculate stats for this sample
-            stats = calculate_basic_stats(text)
-            char_dist = calculate_char_type_distribution(text)
-
-            # Update streaming statistics
-            char_stats.update(stats["char_count"])
-            word_stats.update(stats["word_count"])
-            line_stats.update(stats["line_count"])
-            sentence_stats.update(stats["sentence_count"])
-            word_length_stats.update(stats["mean_word_length"])
-
-            # Accumulate character type distributions
-            for key, value in char_dist.items():
-                char_type_totals[key] += value
-
-            # Store per-sample data if requested
-            if args.per_sample:
-                sample_data = {**stats, **char_dist}
-                per_sample_data.append(sample_data)
-
-            pbar.update(1)
-
-    # Calculate final statistics
-    num_samples = char_stats.count
-
-    if num_samples == 0:
-        print("No samples processed!")
-        sys.exit(1)
-
-    # Average character type distributions
-    char_type_means = {
-        key: round(value / num_samples, 4)
-        for key, value in char_type_totals.items()
-    }
-
-    # Create summary report
-    summary = {
-        "dataset": args.dataset,
-        "split": args.split,
-        "text_column": args.text_column,
-        "total_samples": num_samples,
-        "statistics": {
-            "character_count": char_stats.to_dict(),
-            "word_count": word_stats.to_dict(),
-            "line_count": line_stats.to_dict(),
-            "sentence_count": sentence_stats.to_dict(),
-            "mean_word_length": word_length_stats.to_dict(),
-        },
-        "character_type_distribution": char_type_means,
-        "derived_metrics": {
-            "avg_words_per_line": round(word_stats.mean / line_stats.mean, 2) if line_stats.mean > 0 else 0.0,
-            "avg_chars_per_word": round(char_stats.mean / word_stats.mean, 2) if word_stats.mean > 0 else 0.0,
-            "avg_words_per_sentence": round(word_stats.mean / sentence_stats.mean, 2) if sentence_stats.mean > 0 else 0.0,
-        }
-    }
-
-    # Print summary
-    print("\n" + "="*60)
-    print("BASIC TEXT STATISTICS SUMMARY")
-    print("="*60)
-    print(json.dumps(summary, indent=2))
-
-    # Save per-sample data if requested
-    if args.per_sample:
-        output_file = args.output_file or f"{args.dataset.replace('/', '_')}_stats.csv"
-
-        # Save as CSV
-        import csv
-
-        if per_sample_data:
-            with open(output_file, 'w', newline='') as f:
-                writer = csv.DictWriter(f, fieldnames=per_sample_data[0].keys())
-                writer.writeheader()
-                writer.writerows(per_sample_data)
-
-            print(f"\nPer-sample statistics saved to: {output_file}")
-
-    # Save summary as JSON
-    summary_file = f"{args.dataset.replace('/', '_')}_summary.json"
-    with open(summary_file, 'w') as f:
-        json.dump(summary, f, indent=2)
-
-    print(f"Summary saved to: {summary_file}")
-
-
-if __name__ == "__main__":
-    main()

stats_output/detailed_stats.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:40d8da68fd7af8ed27f28a7c2c7ff218e818dfd217a7c13ac99abcb032090a1d
-size 9770

stats_output/dump_stats.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a14fac91a0776f89c406e662aede9fc73535df26c9de0dbe3edbec16895f4db7
-size 3879

stats_output/extractor_stats.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7c26882ae83e18b22cd4538962a938216d90d49a85b5aad9f7a70dc12844c1b6
-size 2770

stats_output/global_stats.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:278ea6044f2d1d39fffb5a20afc248227d4870d5c397b97dcee0e4e14443c0da
-size 1936

stats_output/language_stats.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:619cc9e3e61a5b37a17b7b5cd3f073af1c7c781e1a591a67e85b0513e8caf3c4
-size 4021

stats_output/temporal_stats.parquet

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f1c643f4eff59c20344fd68c8a53b7f87f6d5df828f1eb7635c4943f8420df06
-size 3994