Update README.md

README.md

@@ -106,8 +106,317 @@ pip install torch transformers datasets tqdm numpy
 ### Full Processing Script
 
 ```python
-# TODO: Add the complete processing code here
-# (ProCreations will insert the Ultra FineWeb EDU creator script)
+#!/usr/bin/env python3
+"""
+Ultra FineWeb EDU Dataset Creator
+Creates a high-quality educational dataset by filtering Ultra-FineWeb with edu classifier
+"""
+
+import os
+import json
+import time
+import pickle
+from datetime import datetime, timedelta
+from pathlib import Path
+import torch
+import numpy as np
+from tqdm.auto import tqdm
+from datasets import load_dataset, Dataset, DatasetDict
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import gc
+import logging
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class UltraFineWebEDUCreator:
+    def __init__(self, 
+                 output_dir="",
+                 checkpoint_interval_minutes=30,
+                 batch_size=512,
+                 max_length=512,
+                 edu_threshold=3.5,
+                 device=None):
+        
+        if output_dir:
+            self.output_dir = Path(output_dir)
+            self.output_dir.mkdir(exist_ok=True)
+        else:
+            self.output_dir = Path(".")
+        self.checkpoint_interval = timedelta(minutes=checkpoint_interval_minutes)
+        self.batch_size = batch_size
+        self.max_length = max_length
+        self.edu_threshold = edu_threshold
+        
+        # Setup device - prefer CUDA for maximum speed! 🚀
+        if device is None:
+            self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        else:
+            self.device = torch.device(device)
+        
+        logger.info(f"🔥 Using device: {self.device}")
+        if torch.cuda.is_available():
+            logger.info(f"⚡ CUDA device: {torch.cuda.get_device_name()}")
+        
+        # Initialize classifier
+        self._load_classifier()
+        
+        # Tracking variables
+        self.processed_count = 0
+        self.filtered_count = 0
+        self.last_checkpoint_time = datetime.now()
+        self.start_time = datetime.now()
+        
+    def _load_classifier(self):
+        """Load the educational classifier model"""
+        logger.info("🧠 Loading FineWeb-Edu classifier...")
+        logger.info("⚡ TURBO MODE: FP16 + Large batches for maximum speed!")
+        
+        model_name = "HuggingFaceFW/fineweb-edu-classifier"
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForSequenceClassification.from_pretrained(
+            model_name,
+            torch_dtype=torch.float16  # Force FP16 for max speed!
+        ).to(self.device)
+        
+        # Set to eval mode for inference
+        self.model.eval()
+        
+        logger.info("✅ Classifier loaded successfully!")
+    
+    def _classify_batch(self, texts):
+        """Classify a batch of texts and return edu scores - OPTIMIZED FOR SPEED!"""
+        with torch.no_grad(), torch.amp.autocast('cuda', dtype=torch.float16):
+            # Tokenize batch
+            inputs = self.tokenizer(
+                texts, 
+                return_tensors="pt", 
+                padding=True, 
+                truncation=True, 
+                max_length=self.max_length
+            ).to(self.device, non_blocking=True)  # Async transfer for speed
+            
+            # Get predictions
+            outputs = self.model(**inputs)
+            scores = outputs.logits.squeeze(-1).float().detach().cpu().numpy()
+            
+            # Handle single sample case
+            if scores.ndim == 0:
+                scores = np.array([scores])
+            
+            return scores
+    
+    def _save_checkpoint(self, filtered_data, split_name, resume_info):
+        """Save checkpoint data"""
+        checkpoint_path = self.output_dir / f"checkpoint_{split_name}_{self.processed_count}.pkl"
+        
+        checkpoint_data = {
+            'filtered_data': filtered_data,
+            'processed_count': self.processed_count,
+            'filtered_count': self.filtered_count,
+            'resume_info': resume_info,
+            'timestamp': datetime.now().isoformat()
+        }
+        
+        with open(checkpoint_path, 'wb') as f:
+            pickle.dump(checkpoint_data, f)
+        
+        logger.info(f"💾 Checkpoint saved: {checkpoint_path}")
+        return checkpoint_path
+    
+    def _should_checkpoint(self):
+        """Check if it's time to save a checkpoint"""
+        return datetime.now() - self.last_checkpoint_time >= self.checkpoint_interval
+    
+    def process_split(self, split_name, resume_from_checkpoint=None):
+        """Process a single split of the dataset"""
+        logger.info(f"🚀 Processing {split_name} split...")
+        
+        # Load dataset in streaming mode for memory efficiency
+        dataset = load_dataset(
+            "openbmb/Ultra-FineWeb", 
+            split=split_name,
+            streaming=True
+        )
+        
+        filtered_data = []
+        
+        # Resume from checkpoint if provided
+        start_idx = 0
+        if resume_from_checkpoint:
+            logger.info(f"📂 Resuming from checkpoint: {resume_from_checkpoint}")
+            with open(resume_from_checkpoint, 'rb') as f:
+                checkpoint_data = pickle.load(f)
+            filtered_data = checkpoint_data['filtered_data']
+            self.processed_count = checkpoint_data['processed_count']
+            self.filtered_count = checkpoint_data['filtered_count']
+            start_idx = checkpoint_data['resume_info']['start_idx']
+        
+        # Create progress bar
+        pbar = tqdm(
+            desc=f"Processing {split_name}",
+            unit="samples",
+            dynamic_ncols=True,
+            initial=self.processed_count
+        )
+        
+        # Process in batches for efficiency
+        batch_texts = []
+        batch_data = []
+        
+        for idx, example in enumerate(dataset):
+            if idx < start_idx:
+                continue
+                
+            # Extract content only (no metadata)
+            content = example['content']
+            batch_texts.append(content)
+            batch_data.append(example)
+            
+            # Process batch when full
+            if len(batch_texts) >= self.batch_size:
+                scores = self._classify_batch(batch_texts)
+                
+                # Filter by edu threshold
+                for i, (score, data) in enumerate(zip(scores, batch_data)):
+                    if score >= self.edu_threshold:
+                        # Only keep content field as requested
+                        filtered_data.append({'content': data['content']})
+                        self.filtered_count += 1
+                    
+                    self.processed_count += 1
+                    
+                    # Update progress bar with stats
+                    filter_rate = (self.filtered_count / self.processed_count) * 100
+                    pbar.set_postfix({
+                        'filtered': self.filtered_count,
+                        'rate': f'{filter_rate:.1f}%',
+                        'avg_score': f'{np.mean(scores):.2f}'
+                    })
+                    pbar.update(1)
+                
+                # Clear batch
+                batch_texts = []
+                batch_data = []
+                
+                # Checkpoint if needed
+                if self._should_checkpoint():
+                    self._save_checkpoint(
+                        filtered_data, 
+                        split_name, 
+                        {'start_idx': idx + 1}
+                    )
+                    self.last_checkpoint_time = datetime.now()
+                
+                # Clean GPU memory
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+        
+        # Process remaining batch
+        if batch_texts:
+            scores = self._classify_batch(batch_texts)
+            for score, data in zip(scores, batch_data):
+                if score >= self.edu_threshold:
+                    filtered_data.append({'content': data['content']})
+                    self.filtered_count += 1
+                self.processed_count += 1
+                pbar.update(1)
+        
+        pbar.close()
+        
+        logger.info(f"✅ {split_name} complete! Filtered {self.filtered_count}/{self.processed_count} samples")
+        return filtered_data
+    
+    def create_dataset(self, splits=['en'], resume_from_checkpoint=None):
+        """Create the Ultra FineWeb EDU dataset"""
+        logger.info(f"🎓 Starting Ultra FineWeb EDU creation!")
+        logger.info(f"📊 Using edu threshold: {self.edu_threshold} (PREMIUM QUALITY!)")
+        logger.info(f"🔄 Checkpoint interval: {self.checkpoint_interval}")
+        logger.info(f"⚡ Batch size: {self.batch_size} - TURBO SPEED ENGAGED!")
+        
+        all_filtered_data = {}
+        
+        for split in splits:
+            logger.info(f"\n📚 Processing {split} split...")
+            
+            # Reset counters for each split
+            self.processed_count = 0
+            self.filtered_count = 0
+            
+            filtered_data = self.process_split(split, resume_from_checkpoint)
+            all_filtered_data[split] = filtered_data
+            
+            # Save split results
+            split_path = self.output_dir / f"ultra_fineweb_edu_{split}.json"
+            with open(split_path, 'w', encoding='utf-8') as f:
+                json.dump(filtered_data, f, ensure_ascii=False, indent=2)
+            logger.info(f"💾 Saved {split} split to {split_path}")
+        
+        # Create HuggingFace dataset
+        logger.info("🤗 Creating HuggingFace dataset...")
+        
+        hf_datasets = {}
+        for split, data in all_filtered_data.items():
+            if data:  # Only create dataset if we have data
+                hf_datasets[split] = Dataset.from_list(data)
+        
+        if hf_datasets:
+            dataset_dict = DatasetDict(hf_datasets)
+            
+            # Save as HuggingFace dataset
+            dataset_path = self.output_dir / "dataset"
+            dataset_dict.save_to_disk(str(dataset_path))
+            logger.info(f"💾 Saved HuggingFace dataset to {dataset_path}")
+            
+            # Print final stats
+            total_samples = sum(len(data) for data in all_filtered_data.values())
+            elapsed_time = datetime.now() - self.start_time
+            
+            logger.info(f"\n🎉 ULTRA FINEWEB EDU CREATION COMPLETE! 🎉")
+            logger.info(f"📊 Total filtered samples: {total_samples:,}")
+            logger.info(f"⏱️  Total time: {elapsed_time}")
+            logger.info(f"⚡ Average speed: {total_samples / elapsed_time.total_seconds():.1f} samples/sec")
+            
+            return dataset_dict
+        else:
+            logger.warning("⚠️ No data passed the filter!")
+            return None
+
+def main():
+    """Main execution function"""
+    # Configuration - adjust these as needed!
+    config = {
+        'output_dir': '',  # Save in root directory
+        'checkpoint_interval_minutes': 30,
+        'batch_size': 512,  # MASSIVE batch size for your 24GB GPU!
+        'max_length': 512,
+        'edu_threshold': 3.5,  # Ultra high quality only!
+        'splits': ['en'],  # Add 'zh' for Chinese if needed
+    }
+    
+    print("🚀 ULTRA FINEWEB EDU DATASET CREATOR 🚀")
+    print("=" * 50)
+    
+    # Create the dataset creator
+    creator = UltraFineWebEDUCreator(**{k: v for k, v in config.items() if k != 'splits'})
+    
+    # Create the dataset
+    dataset = creator.create_dataset(splits=config['splits'])
+    
+    if dataset:
+        print(f"\n✨ Success! Your Ultra FineWeb EDU dataset is ready!")
+        print(f"📁 Location: {creator.output_dir}")
+        print(f"🔍 Preview:")
+        for split_name, split_data in dataset.items():
+            print(f"  {split_name}: {len(split_data):,} samples")
+            if len(split_data) > 0:
+                print(f"  Sample: {split_data[0]['content'][:100]}...")
+    else:
+        print("😞 Dataset creation failed or no samples passed the filter.")
+
+if __name__ == "__main__":
+    main()
 ```
 
 ## 📈 Quality Analysis
@@ -145,7 +454,7 @@ If you use Ultra FineWeb EDU in your research or applications, please cite:
   title={Ultra FineWeb EDU: High-Quality Educational Content from Ultra-FineWeb},
   author={ProCreations},
   year={2025},
-  url={https://huggingface.co/datasets/[dataset-url]},
+  url={https://huggingface.co/datasets/ProCreations/Ultra-FineWeb-EDU]},
   note={Filtered from Ultra-FineWeb using educational quality threshold 3.5+}
 }
 ```