Upload folder using huggingface_hub

README.md

@@ -1,3 +1,234 @@
----
-license: apache-2.0
----
+# FineWeb Educational Dataset - Construction Guide
+
+This document explains how the FineWeb Educational dataset was constructed, sampled, and processed for training DeepSeek language models.
+
+## Dataset Source
+
+**Original Dataset**: [HuggingFaceFW/fineweb-edu](https://huggingface.co/datasets/HuggingFaceFW/fineweb-edu)
+
+**Full Dataset Size**: ~4TB (2,410 parquet files)
+**Content Type**: High-quality educational web content from Common Crawl
+
+## Sampling Strategy
+
+### Why Sampling?
+The full FineWeb dataset is massive (~4TB) and would take days to download and process. We implemented **Strategy 4: Single Parquet File Loading** for efficient processing.
+
+### Sampling Method
+- **Files Selected**: First 5 parquet files from the dataset
+- **Download Size**: ~10GB (vs 4TB full dataset)
+- **Percentage**: ~0.25% of total dataset
+- **Rationale**: Sequential loading is most efficient with HuggingFace datasets
+
+### Files Used
+```
+data/CC-MAIN-2024-42/
+├── 000_00000.parquet (~2.3GB)
+├── 000_00001.parquet (~2.3GB)  
+├── 000_00002.parquet (~2.3GB)
+├── 000_00003.parquet (~2.3GB)
+└── 000_00004.parquet (~2.3GB)
+```
+
+## Data Processing Pipeline
+
+### Step 1: Raw Data Loading
+```python
+# Load 5 parquet files (~10GB total)
+data_files = [
+    "data/CC-MAIN-2024-42/000_00000.parquet",
+    "data/CC-MAIN-2024-42/000_00001.parquet", 
+    "data/CC-MAIN-2024-42/000_00002.parquet",
+    "data/CC-MAIN-2024-42/000_00003.parquet",
+    "data/CC-MAIN-2024-42/000_00004.parquet"
+]
+
+ds = load_dataset("HuggingFaceFW/fineweb-edu", 
+                  data_files=data_files, 
+                  split='train')
+```
+
+**Result**: 2,294,208 raw examples loaded
+
+### Step 2: Quality Filtering
+```python
+def filter_by_length(example):
+    text_length = len(example.get('text', ''))
+    return (100 <= text_length <= 3000 and  # Length filter
+            example.get('score', 0) > 0.6)   # Quality filter
+
+ds = ds.filter(filter_by_length)
+```
+
+**Filtering Criteria**:
+- **Length**: 100-3000 characters (educational content range)
+- **Quality Score**: > 0.6 (high-quality content only)
+- **Language**: English content (from language detection)
+
+**Result**: 964,864 high-quality examples (42% of raw data)
+
+### Step 3: Dataset Splitting
+```python
+# 80/20 train/validation split
+train_val = ds.train_test_split(test_size=0.2, seed=42)
+
+ds = {
+    "train": train_val["train"],      # 80% for training
+    "validation": train_val["test"]   # 20% for validation
+}
+```
+
+**Final Split**:
+- **Training**: 771,891 examples (80%)
+- **Validation**: 192,973 examples (20%)
+
+### Step 4: Tokenization & Binary Conversion
+```python
+# Process each split
+for split_name, split_data in ds.items():
+    # Tokenize with GPT-2 tokenizer
+    tokenized = split_data.map(self.process, ...)
+    
+    # Convert to binary format
+    all_ids = []
+    for example in tokenized:
+        all_ids.extend(example['ids'])
+    
+    # Save as binary file
+    arr = np.array(all_ids, dtype=np.uint16)
+    filename = f"fineweb_{split_name}.bin"
+    arr.tofile(filename)
+```
+
+## Final Dataset Statistics
+
+### File Sizes
+- **`fineweb_train.bin`**: 646.95 MB (339,186,828 tokens)
+- **`fineweb_validation.bin`**: 161.80 MB (84,832,287 tokens)
+- **Total Processed**: 808.75 MB (424,019,115 tokens)
+
+### Content Distribution
+- **Training Examples**: 758,265 (after tokenization filtering)
+- **Validation Examples**: 189,518 (after tokenization filtering)
+- **Total Examples**: 947,783
+
+### Quality Metrics
+- **Original Raw Data**: 2,294,208 examples
+- **After Quality Filtering**: 964,864 examples (42% retention)
+- **After Tokenization**: 947,783 examples (98% of filtered)
+
+## Dataset Structure
+
+### Input Format
+Each example contains:
+```json
+{
+  "text": "Main educational content...",
+  "url": "https://example.com/article",
+  "date": "2024-01-15",
+  "language": "en",
+  "score": 0.95
+}
+```
+
+### Processing Output
+```python
+# Special tokens structure
+full_text = (
+    f"{self.special_tokens['content_start']} {content} {self.special_tokens['content_end']}"
+    f" {self.special_tokens['url_start']} {url} {self.special_tokens['url_end']}"
+    f" {self.special_tokens['date_start']} {date} {self.special_tokens['date_end']}"
+)
+```
+
+## Usage in Training
+
+### Training Script
+```bash
+python src/run_fineweb_training.py
+```
+
+### Data Loading
+```python
+from src.data.fineweb_processor import FineWebDataProcessor
+
+processor = FineWebDataProcessor()
+train_data = processor.load_binary_data('fineweb_train.bin')
+val_data = processor.load_binary_data('fineweb_validation.bin')
+```
+
+## Reproducibility
+
+### Random Seeds
+- **Dataset Split**: `seed=42` (reproducible train/val split)
+- **Processing**: Deterministic tokenization and filtering
+
+### File Selection
+- **Parquet Files**: First 5 files in chronological order
+- **Sampling**: Sequential loading (not random sampling)
+
+## Limitations & Considerations
+
+### Sampling Bias
+- **Chronological**: Only includes content from specific time periods
+- **Geographic**: May be biased toward certain regions/languages
+- **Content Type**: Web content may have different characteristics than curated datasets
+
+### Quality Trade-offs
+- **Filtering**: Aggressive filtering removes 58% of raw data
+- **Length**: 100-3000 character limit may exclude some valuable content
+- **Score Threshold**: 0.6 threshold is somewhat arbitrary
+
+## Future Improvements
+
+### Alternative Sampling Strategies
+1. **Random Sampling**: Load random parquet files across time periods
+2. **Stratified Sampling**: Ensure representation across different content types
+3. **Progressive Loading**: Start small, expand based on training results
+
+### Enhanced Filtering
+1. **Content Classification**: Filter by educational topic/domain
+2. **Language Detection**: Better multilingual support
+3. **Quality Metrics**: More sophisticated quality scoring
+
+## Technical Details
+
+### Tokenizer
+- **Type**: GPT-2 tokenizer (50,257 vocabulary)
+- **Special Tokens**: Custom tokens for content structure
+- **Context Window**: 1024 tokens (DeepSeek architecture)
+
+### Processing Pipeline
+- **Parallel Processing**: 8 processes for tokenization
+- **Memory Management**: Efficient streaming for large datasets
+- **Error Handling**: Graceful fallback for malformed examples
+
+### Storage Format
+- **Binary Format**: `.bin` files for efficient loading
+- **Data Type**: `uint16` (65,536 token limit, sufficient for GPT-2 vocab)
+- **Compression**: No compression (trade-off between size and loading speed)
+
+## Dataset Citation
+
+If you use this processed dataset, please cite:
+
+```bibtex
+@dataset{fineweb_edu_processed,
+  title={FineWeb Educational Dataset - 10GB Sampled (0.25% of Full Dataset)},
+  author={Your Name},
+  year={2024},
+  url={https://huggingface.co/datasets/your-username/fineweb-edu-10gb-5parquet-processed},
+  note={Processed subset of HuggingFaceFW/fineweb-edu for DeepSeek training}
+}
+```
+
+## Contact & Support
+
+For questions about this dataset construction:
+- **Repository**: [Tiny-Deepseek](https://github.com/your-username/Tiny-Deepseek)
+- **Issues**: GitHub Issues for technical problems
+- **Discussions**: GitHub Discussions for general questions
+
+---
+
+*This dataset was constructed as part of the Tiny-Deepseek project for training efficient language models on educational content.*

cleanup_fineweb.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+
+echo "🗑️  FineWeb Dataset Cleanup Script"
+echo "=================================="
+
+# Check current usage
+echo "📊 Current FineWeb cache usage:"
+du -sh /root/.cache/huggingface/hub/datasets--HuggingFaceFW--fineweb-edu 2>/dev/null || echo "No hub cache found"
+du -sh /root/.cache/huggingface/datasets/HuggingFaceFW___fineweb-edu 2>/dev/null || echo "No datasets cache found"
+
+echo ""
+echo "🧹 Cleaning up FineWeb cached data..."
+
+# Remove the hub cache (downloaded files)
+if [ -d "/root/.cache/huggingface/hub/datasets--HuggingFaceFW--fineweb-edu" ]; then
+    echo "Removing hub cache..."
+    rm -rf /root/.cache/huggingface/hub/datasets--HuggingFaceFW--fineweb-edu
+    echo "✅ Hub cache removed"
+else
+    echo "ℹ️  No hub cache found"
+fi
+
+# Remove the datasets cache (processed data)
+if [ -d "/root/.cache/huggingface/datasets/HuggingFaceFW___fineweb-edu" ]; then
+    echo "Removing datasets cache..."
+    rm -rf /root/.cache/huggingface/datasets/HuggingFaceFW___fineweb-edu
+    echo "✅ Datasets cache removed"
+else
+    echo "ℹ️  No datasets cache found"
+fi
+
+# Remove lock files
+if [ -d "/root/.cache/huggingface/hub/.locks/datasets--HuggingFaceFW--fineweb-edu" ]; then
+    echo "Removing lock files..."
+    rm -rf /root/.cache/huggingface/hub/.locks/datasets--HuggingFaceFW--fineweb-edu
+    echo "✅ Lock files removed"
+fi
+
+# Also clean up any processed binary files in our data directory
+if [ -f "src/data/fineweb_train.bin" ] || [ -f "src/data/fineweb_validation.bin" ] || [ -f "src/data/fineweb_finetune.bin" ]; then
+    echo "Removing processed FineWeb binary files..."
+    rm -f src/data/fineweb_*.bin
+    echo "✅ Binary files removed"
+fi
+
+echo ""
+echo "🎉 FineWeb cleanup completed!"
+echo "💾 Space freed: ~77GB"
+echo ""
+echo "📋 Summary:"
+echo "- Removed HuggingFace hub cache"
+echo "- Removed datasets cache" 
+echo "- Removed lock files"
+echo "- Removed processed binary files"
+echo ""
+echo "ℹ️  You can now run the processor again with the smaller dataset size."

data_processor.py

@@ -0,0 +1,287 @@
+"""
+Data Processor for DeepSeek Children's Stories Model
+Handles dataset loading, preprocessing, and tokenization for children's story generation
+"""
+
+import tiktoken
+import os
+import numpy as np
+from datasets import load_dataset
+from tqdm.auto import tqdm
+import torch
+from typing import Dict, List, Optional
+
+def load_encoder_decoder():
+    """Load the encoder and decoder for text processing"""
+    enc = tiktoken.get_encoding("gpt2")
+    return enc, enc
+
+class DeepSeekDataProcessor:
+    def __init__(self, config=None):
+        # Initialize tokenizer with GPT-2 encoding
+        self.enc = tiktoken.get_encoding("gpt2")
+        
+        # Special tokens for story structure (optimized for children's stories)
+        self.special_tokens = {
+            "story_start": "<|story|>",
+            "story_end": "</|story|>",
+            "prompt_start": "<|prompt|>",
+            "prompt_end": "</|prompt|>",
+            "moral_start": "<|moral|>",
+            "moral_end": "</|moral|>",
+            "character_start": "<|character|>",
+            "character_end": "</|character|>"
+        }
+        
+        # Ensure data directory exists
+        self.data_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "data")
+        os.makedirs(self.data_dir, exist_ok=True)
+        print(f"Data directory: {self.data_dir}")
+        
+        # Configuration for processing
+        self.max_length = 1024  # DeepSeek context window
+        self.min_length = 50    # Minimum story length
+        
+    def preprocess_text(self, text: str) -> str:
+        """Preprocess text for children's stories"""
+        # Basic text cleaning
+        text = text.lower()  # Convert to lowercase for consistency
+        text = text.replace('\n', ' ')  # Replace newlines with spaces
+        text = ' '.join(text.split())  # Normalize whitespace
+        
+        # Remove any inappropriate content markers (basic filtering)
+        inappropriate_phrases = ['adult content', 'mature', 'explicit']
+        for phrase in inappropriate_phrases:
+            if phrase in text:
+                return ""
+        
+        # Ensure the text is child-friendly
+        if len(text) < self.min_length:
+            return ""
+            
+        return text
+        
+    def extract_story_elements(self, example: Dict) -> Dict:
+        """Extract story elements for better structure"""
+        prompt = self.preprocess_text(example.get('prompt', ''))
+        story = self.preprocess_text(example.get('text', ''))
+        
+        # Extract potential moral or lesson
+        moral = ""
+        if 'moral' in example:
+            moral = self.preprocess_text(example['moral'])
+        elif 'lesson' in example:
+            moral = self.preprocess_text(example['lesson'])
+        
+        # Extract main character if available
+        character = ""
+        if 'character' in example:
+            character = self.preprocess_text(example['character'])
+        
+        return {
+            'prompt': prompt,
+            'story': story,
+            'moral': moral,
+            'character': character
+        }
+        
+    def process(self, example: Dict) -> Dict:
+        """Process a single example for DeepSeek model"""
+        # Extract story elements
+        elements = self.extract_story_elements(example)
+        
+        # Skip if no valid content
+        if not elements['story'] or not elements['prompt']:
+            return {'ids': [], 'len': 0}
+        
+        # Create structured text with special tokens
+        full_text = (
+            f"{self.special_tokens['prompt_start']} {elements['prompt']} {self.special_tokens['prompt_end']} "
+        )
+        
+        # Add character information if available
+        if elements['character']:
+            full_text += f"{self.special_tokens['character_start']} {elements['character']} {self.special_tokens['character_end']} "
+        
+        # Add the main story
+        full_text += f"{self.special_tokens['story_start']} {elements['story']} {self.special_tokens['story_end']}"
+        
+        # Add moral if available
+        if elements['moral']:
+            full_text += f" {self.special_tokens['moral_start']} {elements['moral']} {self.special_tokens['moral_end']}"
+        
+        # Tokenize with error handling
+        try:
+            ids = self.enc.encode_ordinary(full_text)
+            
+            # Ensure the sequence isn't too long
+            if len(ids) > self.max_length:
+                ids = ids[:self.max_length]
+            
+            # Skip if too short
+            if len(ids) < 20:
+                return {'ids': [], 'len': 0}
+                
+            out = {'ids': ids, 'len': len(ids)}
+            return out
+            
+        except Exception as e:
+            print(f"Error tokenizing text: {e}")
+            return {'ids': [], 'len': 0}
+        
+    def prepare_dataset(self) -> Dict:
+        """Prepare the Children Stories Collection dataset for DeepSeek training"""
+        # Load the Children Stories Collection dataset
+        print("Loading Children Stories Collection dataset...")
+        ds = load_dataset("ajibawa-2023/Children-Stories-Collection")
+        
+        train_bin_path = os.path.join(self.data_dir, "train.bin")
+        val_bin_path = os.path.join(self.data_dir, "validation.bin")
+        finetune_bin_path = os.path.join(self.data_dir, "finetune.bin")
+        
+        print(f"Checking for existing processed files...")
+        
+        # Check if all files exist
+        if (os.path.exists(train_bin_path) and 
+            os.path.exists(val_bin_path) and 
+            os.path.exists(finetune_bin_path)):
+            
+            print("Found existing processed files!")
+            print(f"Train file: {os.path.getsize(train_bin_path) / (1024*1024):.2f} MB")
+            print(f"Validation file: {os.path.getsize(val_bin_path) / (1024*1024):.2f} MB")
+            print(f"Finetune file: {os.path.getsize(finetune_bin_path) / (1024*1024):.2f} MB")
+            
+            return {
+                "train": train_bin_path,
+                "validation": val_bin_path,
+                "finetune": finetune_bin_path
+            }
+        
+        print("Processing dataset...")
+        
+        # Filter out examples that are too short or too long
+        def filter_by_length(example):
+            text_length = len(example.get('text', ''))
+            return self.min_length <= text_length <= 2000  # Reasonable length for children's stories
+        
+        ds = ds.filter(filter_by_length)
+        print(f"After filtering: {len(ds['train'])} examples")
+        
+        # Split the dataset into train, validation, and finetune sets
+        train_val_test = ds["train"].train_test_split(test_size=0.2, seed=42)
+        val_finetune = train_val_test["test"].train_test_split(test_size=0.5, seed=42)
+        
+        # Create a new dataset dictionary with all splits
+        ds = {
+            "train": train_val_test["train"],
+            "validation": val_finetune["train"],
+            "finetune": val_finetune["test"]
+        }
+        
+        print(f"Dataset split sizes:")
+        print(f"Training set: {len(ds['train'])} examples")
+        print(f"Validation set: {len(ds['validation'])} examples")
+        print(f"Finetune set: {len(ds['finetune'])} examples")
+        
+        # Process each split
+        for split_name, split_data in ds.items():
+            print(f"\nProcessing {split_name} split...")
+            
+            # Process the data
+            tokenized = split_data.map(
+                self.process,
+                remove_columns=['text', 'prompt', 'text_token_length'],
+                desc=f"tokenizing {split_name} split",
+                num_proc=8,
+            )
+            
+            # Filter out empty sequences
+            tokenized = tokenized.filter(lambda x: x['len'] > 0)
+            print(f"After processing: {len(tokenized)} valid examples")
+            
+            # Save to binary file
+            filename = os.path.join(self.data_dir, f"{split_name}.bin")
+            print(f"Saving {split_name} split to: {filename}")
+            
+            # Calculate total length
+            arr_len = np.sum(tokenized['len'], dtype=np.uint64)
+            dtype = np.uint16
+            arr = np.memmap(filename, dtype=dtype, mode='w+', shape=(arr_len,))
+            total_batches = 1024
+
+            idx = 0
+            for batch_idx in tqdm(range(total_batches), desc=f'writing {filename}'):
+                batch = tokenized.shard(num_shards=total_batches, index=batch_idx, contiguous=True).with_format('numpy')
+                arr_batch = np.concatenate(batch['ids'])
+                arr[idx : idx + len(arr_batch)] = arr_batch
+                idx += len(arr_batch)
+            arr.flush()
+            
+            # Verify file was created
+            if os.path.exists(filename):
+                print(f"Successfully created {filename}")
+                print(f"File size: {os.path.getsize(filename) / (1024*1024):.2f} MB")
+            else:
+                raise RuntimeError(f"Failed to create {filename}")
+        
+        return {
+            "train": train_bin_path,
+            "validation": val_bin_path,
+            "finetune": finetune_bin_path
+        }
+    
+    def load_binary_data(self, filepath: str) -> torch.Tensor:
+        """Load binary data file as tensor"""
+        try:
+            data = np.memmap(filepath, dtype=np.uint16, mode='r')
+            return torch.from_numpy(data.copy())
+        except Exception as e:
+            print(f"Error loading data from {filepath}: {e}")
+            raise
+    
+    def get_batch(self, data: torch.Tensor, batch_size: int, block_size: int) -> tuple:
+        """Get a batch of data for training"""
+        # Generate random indices
+        ix = torch.randint(len(data) - block_size, (batch_size,))
+        
+        # Get input sequences
+        x = torch.stack([data[i:i+block_size].long() for i in ix])
+        # Get target sequences (shifted by 1)
+        y = torch.stack([data[i+1:i+1+block_size].long() for i in ix])
+        
+        return x, y
+    
+    def decode_tokens(self, token_ids: List[int]) -> str:
+        """Decode token IDs back to text"""
+        try:
+            return self.enc.decode(token_ids)
+        except Exception as e:
+            print(f"Error decoding tokens: {e}")
+            return ""
+    
+    def encode_text(self, text: str) -> List[int]:
+        """Encode text to token IDs"""
+        try:
+            return self.enc.encode_ordinary(text)
+        except Exception as e:
+            print(f"Error encoding text: {e}")
+            return []
+
+
+def main():
+    """Main function to process the dataset"""
+    print("DeepSeek Children's Stories Data Processor")
+    print("=" * 50)
+    
+    processor = DeepSeekDataProcessor()
+    processor.prepare_dataset()
+    
+    print("\nData processing completed successfully!")
+    print("Files created:")
+    print("- src/data/train.bin")
+    print("- src/data/validation.bin") 
+    print("- src/data/finetune.bin")
+
+
+if __name__ == "__main__":
+    main() 

fineweb_processor.py

@@ -0,0 +1,303 @@
+"""
+FineWeb Educational Data Processor for DeepSeek Model
+Handles dataset loading, preprocessing, and tokenization for educational web content
+"""
+
+import tiktoken
+import os
+import numpy as np
+from datasets import load_dataset
+from tqdm.auto import tqdm
+import torch
+from typing import Dict, List, Optional
+
+def load_encoder_decoder():
+    """Load the encoder and decoder for text processing"""
+    enc = tiktoken.get_encoding("gpt2")
+    return enc, enc
+
+class FineWebDataProcessor:
+    def __init__(self, config=None):
+        # Initialize tokenizer with GPT-2 encoding
+        self.enc, self.dec = load_encoder_decoder()
+        
+        # Special tokens for educational content structure
+        self.special_tokens = {
+            "content_start": "<|content|>",
+            "content_end": "</|content|>",
+            "metadata_start": "<|metadata|>",
+            "metadata_end": "</|metadata|>",
+            "url_start": "<|url|>",
+            "url_end": "</|url|>",
+            "date_start": "<|date|>",
+            "date_end": "</|date|>"
+        }
+        
+        # Ensure data directory exists
+        self.data_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "data")
+        os.makedirs(self.data_dir, exist_ok=True)
+        print(f"Data directory: {self.data_dir}")
+        
+        # Configuration for processing
+        self.max_length = 1024  # DeepSeek context window
+        self.min_length = 100   # Minimum content length for educational content
+        
+    def preprocess_text(self, text: str) -> str:
+        """Preprocess text for educational content"""
+        if not text or not isinstance(text, str):
+            return ""
+        
+        # Basic text cleaning
+        text = text.strip()
+        text = text.replace('\n', ' ')  # Replace newlines with spaces
+        text = ' '.join(text.split())  # Normalize whitespace
+        
+        # Remove any inappropriate content markers
+        inappropriate_phrases = ['adult content', 'mature', 'explicit', 'nsfw']
+        for phrase in inappropriate_phrases:
+            if phrase.lower() in text.lower():
+                return ""
+        
+        # Ensure the text is educational and appropriate
+        if len(text) < self.min_length:
+            return ""
+            
+        return text
+        
+    def extract_content_elements(self, example: Dict) -> Dict:
+        """Extract content elements for better structure"""
+        # Main content
+        content = self.preprocess_text(example.get('text', ''))
+        
+        # Metadata
+        url = example.get('url', '')
+        date = example.get('date', '')
+        language = example.get('language', '')
+        score = example.get('score', 0.0)
+        
+        # Only process if we have valid content
+        if not content:
+            return {'content': '', 'url': '', 'date': '', 'language': '', 'score': 0.0}
+        
+        return {
+            'content': content,
+            'url': url,
+            'date': date,
+            'language': language,
+            'score': score
+        }
+        
+    def process(self, example: Dict) -> Dict:
+        """Process a single example for DeepSeek model"""
+        # Extract content elements
+        elements = self.extract_content_elements(example)
+        
+        # Skip if no valid content
+        if not elements['content']:
+            return {'ids': [], 'len': 0}
+        
+        # Create structured text with special tokens
+        full_text = f"{self.special_tokens['content_start']} {elements['content']} {self.special_tokens['content_end']}"
+        
+        # Add metadata if available
+        if elements['url']:
+            full_text += f" {self.special_tokens['url_start']} {elements['url']} {self.special_tokens['url_end']}"
+        
+        if elements['date']:
+            full_text += f" {self.special_tokens['date_start']} {elements['date']} {self.special_tokens['date_end']}"
+        
+        # Add language and score information
+        if elements['language'] and elements['score'] > 0.5:  # Only include if language is detected with confidence
+            full_text += f" {self.special_tokens['metadata_start']} Language: {elements['language']}, Quality: {elements['score']:.2f} {self.special_tokens['metadata_end']}"
+        
+        # Tokenize with error handling
+        try:
+            ids = self.enc.encode_ordinary(full_text)
+            
+            # Ensure the sequence isn't too long
+            if len(ids) > self.max_length:
+                ids = ids[:self.max_length]
+            
+            # Skip if too short
+            if len(ids) < 50:  # Higher minimum for educational content
+                return {'ids': [], 'len': 0}
+                
+            out = {'ids': ids, 'len': len(ids)}
+            return out
+            
+        except Exception as e:
+            print(f"Error tokenizing text: {e}")
+            return {'ids': [], 'len': 0}
+        
+    def prepare_dataset(self) -> Dict:
+        """Prepare the FineWeb Educational dataset for DeepSeek training"""
+        # Clear any existing dataset cache first
+        print("Clearing existing dataset cache...")
+        try:
+            from datasets import clear_cache
+            clear_cache()
+            print("Dataset cache cleared successfully!")
+            
+            # Also try to clear HuggingFace cache directory
+            cache_dir = os.path.expanduser("~/.cache/huggingface")
+            if os.path.exists(cache_dir):
+                print(f"Clearing HuggingFace cache at: {cache_dir}")
+                # Note: This is a safety measure - actual clearing happens via clear_cache()
+        except Exception as e:
+            print(f"Warning: Could not clear cache: {e}")
+        
+        # Strategy: Load multiple parquet files for ~10GB download
+        print("Loading multiple parquet files from FineWeb Educational dataset (~60GB)...")
+        try:
+            # Load 30 parquet files for a larger, more diverse dataset
+            # This should provide ~60GB of data and prevent overfitting
+            data_files = [f"data/CC-MAIN-2024-42/000_{i:05d}.parquet" for i in range(30)]
+            
+            print(f"Loading {len(data_files)} parquet files...")
+            ds = load_dataset("HuggingFaceFW/fineweb-edu", 
+                            data_files=data_files,
+                            split='train')
+            print(f"Successfully loaded {len(ds)} examples from {len(data_files)} parquet files")
+            
+        except Exception as e:
+            print(f"Failed to load multiple files, trying single file fallback: {e}")
+            # Fallback: Single file approach
+            ds = load_dataset("HuggingFaceFW/fineweb-edu", 
+                            data_files="data/CC-MAIN-2024-42/000_00000.parquet",
+                            split='train')
+            print(f"Successfully loaded {len(ds)} examples from single parquet file (fallback)")
+        
+        train_bin_path = os.path.join(self.data_dir, "fineweb_train.bin")
+        val_bin_path = os.path.join(self.data_dir, "fineweb_validation.bin")
+        
+        print(f"Checking for existing processed files...")
+        
+        # Check if both files exist
+        if (os.path.exists(train_bin_path) and 
+            os.path.exists(val_bin_path)):
+            
+            print("Found existing processed files!")
+            print(f"Train file: {os.path.getsize(train_bin_path) / (1024*1024):.2f} MB")
+            print(f"Validation file: {os.path.getsize(val_bin_path) / (1024*1024):.2f} MB")
+            
+            return {
+                "train": train_bin_path,
+                "validation": val_bin_path
+            }
+        
+        print("Processing dataset...")
+        
+        # Filter out examples that are too short or too long
+        def filter_by_length(example):
+            text_length = len(example.get('text', ''))
+            # More selective filtering for larger dataset
+            return (self.min_length <= text_length <= 3000 and  # Reasonable length for educational content
+                    example.get('score', 0) > 0.6)  # Higher quality threshold
+        
+        ds = ds.filter(filter_by_length)
+        print(f"After filtering: {len(ds)} examples")
+        
+        # Split the dataset into train and validation sets (80/20)
+        train_val = ds.train_test_split(test_size=0.2, seed=42)
+        
+        # Create a new dataset dictionary with both splits
+        ds = {
+            "train": train_val["train"],
+            "validation": train_val["test"]
+        }
+        
+        print(f"Dataset split sizes:")
+        print(f"Training set: {len(ds['train'])} examples (80%)")
+        print(f"Validation set: {len(ds['validation'])} examples (20%)")
+        
+        # Process each split
+        for split_name, split_data in ds.items():
+            print(f"\nProcessing {split_name} split...")
+            
+            # Process the data
+            tokenized = split_data.map(
+                self.process,
+                remove_columns=['text', 'id', 'dump', 'url', 'date', 'file_path', 'language', 'language_score', 'token_count', 'score', 'int_score'],
+                desc=f"tokenizing {split_name} split",
+                num_proc=8,
+            )
+            
+            # Filter out empty sequences
+            tokenized = tokenized.filter(lambda x: x['len'] > 0)
+            print(f"After processing: {len(tokenized)} valid examples")
+            
+            # Convert to numpy arrays
+            all_ids = []
+            for example in tokenized:
+                all_ids.extend(example['ids'])
+            
+            # Convert to numpy array
+            arr = np.array(all_ids, dtype=np.uint16)
+            
+            # Save to binary file
+            filename = os.path.join(self.data_dir, f"fineweb_{split_name}.bin")
+            arr.tofile(filename)
+            
+            print(f"Saved {split_name} split to {filename}")
+            print(f"File size: {os.path.getsize(filename) / (1024*1024):.2f} MB")
+            print(f"Number of tokens: {len(arr):,}")
+        
+        return {
+            "train": train_bin_path,
+            "validation": val_bin_path
+        }
+    
+    def load_binary_data(self, filepath: str) -> torch.Tensor:
+        """Load binary data file as tensor"""
+        try:
+            data = np.memmap(filepath, dtype=np.uint16, mode='r')
+            return torch.from_numpy(data.copy())
+        except Exception as e:
+            print(f"Error loading data from {filepath}: {e}")
+            raise
+    
+    def get_batch(self, data: torch.Tensor, batch_size: int, block_size: int) -> tuple:
+        """Get a batch of data for training"""
+        # Generate random indices
+        ix = torch.randint(len(data) - block_size, (batch_size,))
+        
+        # Get input sequences
+        x = torch.stack([data[i:i+block_size].long() for i in ix])
+        # Get target sequences (shifted by 1)
+        y = torch.stack([data[i+1:i+1+block_size].long() for i in ix])
+        
+        return x, y
+    
+    def decode_tokens(self, token_ids: List[int]) -> str:
+        """Decode token IDs back to text"""
+        try:
+            return self.enc.decode(token_ids)
+        except Exception as e:
+            print(f"Error decoding tokens: {e}")
+            return ""
+    
+    def encode_text(self, text: str) -> List[int]:
+        """Encode text to token IDs"""
+        try:
+            return self.enc.encode_ordinary(text)
+        except Exception as e:
+            print(f"Error encoding text: {e}")
+            return []
+
+
+def main():
+    """Main function to process the FineWeb Educational dataset"""
+    print("FineWeb Educational Data Processor")
+    print("=" * 50)
+    
+    processor = FineWebDataProcessor()
+    processor.prepare_dataset()
+    
+    print("\nData processing completed successfully!")
+    print("Files created:")
+    print("- src/data/fineweb_train.bin")
+    print("- src/data/fineweb_validation.bin")
+
+
+if __name__ == "__main__":
+    main()

fineweb_train.bin

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

fineweb_validation.bin

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