Add uv-script tag, fix Key Finding to use yearly averages

- Add uv-script tag to generated dataset cards
- Key Finding now shows yearly averages (more representative than single dumps)
- Update docstring to reflect 50M+ docs

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

HuggingFaceFW_fineweb-edu_summary.json

@@ -0,0 +1,58 @@
+{
+  "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
+  }
+}

README.md

@@ -0,0 +1,259 @@
+---
+viewer: false
+tags:
+  - uv-script
+  - dataset-statistics
+  - data-quality
+  - text-analysis
+license: apache-2.0
+---
+
+# Dataset Statistics
+
+Calculate essential text statistics for HuggingFace datasets using streaming mode. No ML models, pure Python, works on datasets of any size.
+
+## Scripts
+
+### `basic-stats.py` - Essential Text Statistics
+
+Calculate fundamental text statistics using pure Python (no ML dependencies). 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 using Welford's algorithm
+- Character type distributions (alphanumeric, digits, punctuation, whitespace, special characters)
+- Length statistics (min, max)
+- Derived metrics (words per line, chars per word, words per sentence)
+
+**Features:**
+- ✅ Pure Python (no ML models required)
+- ✅ Streaming mode (constant memory usage)
+- ✅ Progress tracking with tqdm
+- ✅ Optional per-sample CSV output
+- ✅ Works on datasets of any size
+- ✅ Fast: ~10k-50k samples/sec on CPU
+
+## Installation
+
+No installation needed! Just use `uv run`:
+
+```bash
+# Run directly with uv
+uv run https://huggingface.co/datasets/uv-scripts/dataset-stats/raw/main/basic-stats.py --help
+```
+
+## Usage Examples
+
+### Quick Test (10k samples)
+
+```bash
+uv run basic-stats.py HuggingFaceFW/fineweb-edu --max-samples 10000
+```
+
+### Full Dataset Statistics
+
+```bash
+uv run basic-stats.py allenai/c4 --split train
+```
+
+### Different Text Column
+
+```bash
+uv run basic-stats.py username/dataset --text-column content
+```
+
+### Save Per-Sample Statistics
+
+```bash
+uv run basic-stats.py username/dataset --per-sample --output-file my-stats.csv
+```
+
+### Using HF Jobs (for large datasets)
+
+```bash
+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/very-large-dataset --max-samples 100000
+```
+
+## Example Output
+
+```json
+{
+  "dataset": "HuggingFaceFW/fineweb-edu",
+  "split": "train",
+  "text_column": "text",
+  "total_samples": 10000,
+  "statistics": {
+    "character_count": {
+      "count": 10000,
+      "mean": 3542.18,
+      "std": 2134.52,
+      "min": 120.0,
+      "max": 45231.0
+    },
+    "word_count": {
+      "count": 10000,
+      "mean": 642.34,
+      "std": 387.21,
+      "min": 18.0,
+      "max": 8234.0
+    },
+    "line_count": {
+      "count": 10000,
+      "mean": 28.5,
+      "std": 16.3,
+      "min": 2.0,
+      "max": 234.0
+    },
+    "sentence_count": {
+      "count": 10000,
+      "mean": 24.7,
+      "std": 14.2,
+      "min": 1.0,
+      "max": 187.0
+    },
+    "mean_word_length": {
+      "count": 10000,
+      "mean": 5.52,
+      "std": 0.87,
+      "min": 2.1,
+      "max": 12.4
+    }
+  },
+  "character_type_distribution": {
+    "alphanumeric": 0.8234,
+    "alphabetic": 0.7891,
+    "digit": 0.0343,
+    "uppercase": 0.0456,
+    "lowercase": 0.9544,
+    "whitespace": 0.1523,
+    "punctuation": 0.0187,
+    "special": 0.0056
+  },
+  "derived_metrics": {
+    "avg_words_per_line": 22.54,
+    "avg_chars_per_word": 5.52,
+    "avg_words_per_sentence": 26.01
+  }
+}
+```
+
+## Performance
+
+- **Speed**: ~10,000-50,000 samples/sec on CPU (depending on text length)
+- **Memory**: Constant O(1) memory usage (streaming statistics)
+- **Dependencies**: Pure Python + datasets library
+- **GPU**: Not needed
+
+## Use Cases
+
+### Understanding Dataset Characteristics
+
+Get a quick overview of your dataset's basic properties:
+```bash
+uv run basic-stats.py username/my-dataset --max-samples 10000
+```
+
+### Comparing Datasets
+
+Generate statistics for multiple datasets to compare their characteristics:
+```bash
+for dataset in "allenai/c4" "HuggingFaceFW/fineweb" "cerebras/SlimPajama-627B"; do
+    uv run basic-stats.py $dataset --max-samples 50000
+done
+```
+
+### Quality Checking
+
+Check if your dataset has reasonable statistics before training:
+- Are word counts within expected range?
+- Is the character distribution reasonable?
+- Are there too many special characters (potential quality issues)?
+
+### Setting Filter Thresholds
+
+Use the statistics to inform filtering decisions:
+- If mean word count is 500, you might filter out samples < 50 or > 10,000 words
+- If punctuation ratio is very low, might indicate low-quality text
+- Character type distributions can reveal encoding issues
+
+## Command-Line Options
+
+```
+usage: basic-stats.py [-h] [--split SPLIT] [--text-column TEXT_COLUMN]
+                      [--max-samples MAX_SAMPLES] [--per-sample]
+                      [--output-file OUTPUT_FILE] [--streaming]
+                      dataset
+
+positional arguments:
+  dataset               Dataset name (e.g., 'HuggingFaceFW/fineweb-edu') or local path
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --split SPLIT         Dataset split to process (default: train)
+  --text-column TEXT_COLUMN
+                        Name of the text column (default: text)
+  --max-samples MAX_SAMPLES
+                        Maximum number of samples to process (for testing)
+  --per-sample          Save per-sample statistics to CSV file
+  --output-file OUTPUT_FILE
+                        Output file for per-sample stats (default: dataset-stats.csv)
+  --streaming           Use streaming mode (default: True)
+```
+
+## Technical Details
+
+### Welford's Algorithm
+
+The script uses Welford's algorithm for calculating streaming mean and variance. This provides:
+- Numerical stability (no catastrophic cancellation)
+- Constant memory usage (O(1))
+- Single-pass computation
+- Accurate results even for very large datasets
+
+### Character Type Classification
+
+Character types are classified as:
+- **Alphanumeric**: Letters + digits
+- **Alphabetic**: Letters only
+- **Digit**: Numbers (0-9)
+- **Uppercase/Lowercase**: Case ratios (relative to total letters)
+- **Whitespace**: Spaces, tabs, newlines
+- **Punctuation**: Standard ASCII punctuation
+- **Special**: Everything else (emojis, symbols, etc.)
+
+### Sentence Counting
+
+Simple heuristic-based sentence boundary detection using `.!?` as terminators. This is fast but not as accurate as NLP-based sentence tokenization. Good enough for statistical analysis.
+
+## Related Scripts
+
+Check out other scripts in the `uv-scripts` organization:
+- **dataset-creation**: Create datasets from PDFs and other formats
+- **vllm**: GPU-accelerated classification and inference
+- **ocr**: Document OCR using vision-language models
+
+## Contributing
+
+Have ideas for additional statistics or improvements? Feel free to:
+1. Fork this repository
+2. Add your script or improvements
+3. Submit a pull request
+
+Or open an issue on the [uv-scripts organization](https://huggingface.co/uv-scripts).
+
+## License
+
+Apache 2.0
+
+## Why UV Scripts?
+
+UV scripts are self-contained Python scripts that:
+- Run with a single `uv run` command (no setup required)
+- Include all dependencies in PEP 723 inline metadata
+- Work seamlessly on both local machines and HF Jobs
+- Serve as educational examples of best practices
+
+Learn more about UV: https://docs.astral.sh/uv/

basic-stats.py

@@ -0,0 +1,338 @@
+#!/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()

finepdfs-stats.py

@@ -12,7 +12,7 @@ Analyze educational quality trends across CommonCrawl dumps using Polars streami
 
 Answers: "Is the web getting more educational over time?"
 
-Demonstrates Polars HF Hub integration - process 23M+ docs without downloading 300GB.
+Demonstrates Polars HF Hub integration - process 50M+ docs without downloading 300GB+.
 
 Example usage:
     # Analyze English PDFs (default)
@@ -180,9 +180,21 @@ def create_readme(
     total_docs = stats.get("total_docs", 0)
     docs_per_sec = total_docs / scan_time if scan_time > 0 else 0
 
-    # Get first and last dumps for trend
-    first_dump = temporal_stats.head(1).to_dicts()[0]
-    last_dump = temporal_stats.tail(1).to_dicts()[0]
+    # Get first and last year averages for trend (more representative than single dumps)
+    yearly = (
+        temporal_stats.with_columns(
+            pl.col("dump").str.extract(r"CC-MAIN-(\d{4})", 1).alias("year")
+        )
+        .group_by("year")
+        .agg(
+            pl.col("doc_count").sum(),
+            pl.col("avg_edu_score").mean(),
+            pl.col("high_edu_rate").mean(),
+        )
+        .sort("year")
+    )
+    first_year = yearly.head(1).to_dicts()[0]
+    last_year = yearly.tail(1).to_dicts()[0]
 
     scope = (
         "all languages"
@@ -192,6 +204,7 @@ def create_readme(
 
     return f"""---
 tags:
+  - uv-script
   - statistics
   - polars
   - finepdfs-edu
@@ -217,10 +230,10 @@ Temporal analysis of educational quality across {stats.get("num_dumps", 0)} Comm
 
 ## Key Finding
 
-| Period | Avg Edu Score | High Edu Rate |
-|--------|---------------|---------------|
-| {first_dump["dump"]} | {first_dump["avg_edu_score"]:.3f} | {first_dump["high_edu_rate"] * 100:.1f}% |
-| {last_dump["dump"]} | {last_dump["avg_edu_score"]:.3f} | {last_dump["high_edu_rate"] * 100:.1f}% |
+| Year | Avg Edu Score | High Edu Rate |
+|------|---------------|---------------|
+| {first_year["year"]} | {first_year["avg_edu_score"]:.2f} | {first_year["high_edu_rate"] * 100:.1f}% |
+| {last_year["year"]} | {last_year["avg_edu_score"]:.2f} | {last_year["high_edu_rate"] * 100:.1f}% |
 
 ## Performance
 

stats_output/detailed_stats.parquet

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

stats_output/dump_stats.parquet

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

stats_output/extractor_stats.parquet

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

stats_output/global_stats.parquet

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

stats_output/language_stats.parquet

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

stats_output/temporal_stats.parquet

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