update docs

AGENTS.md

@@ -32,8 +32,7 @@ python -m py_compile scripts/*.py
 
 ## 🎯 Code Style Guidelines
 
-### Python Version & Structure
-- **Python Version**: 3.12 (see `.python-version`)
+### Code Structure
 - **Code Layout**: All Python modules in `scripts/` directory
 - **Entry Points**: Each module can be run as `__main__`
 
@@ -127,13 +126,15 @@ def check_image_sizes(data_dir: str = "data", num_samples: int = 10) -> None:
 ### Dependencies
 - **Core**: torch, pandas, PIL (Pillow), pathlib
 - **Optional**: torchvision for transforms
+- **Future PT-only**: torch, PIL (Pillow), pathlib (pandas eliminated)
 - Keep dependencies minimal and well-justified
 
 ## 📁 Core Files
 - **`scripts/pytorch_dataloader.py`** - Main dataloader with type safety & error handling
-- **`scripts/utils.py`** - Data inspection utilities (debug, sizes, PyTorch memory analysis)
+- **`scripts/utils.py`** - Data inspection utilities (debug, sizes, memory analysis)
 - **`scripts/classes.py`** - ImageNet-100 class definitions
 - **`data/`** - Parquet files (train/validation splits)
+- **Future**: `data/train.pt`, `data/validation.pt` (planned PT conversion)
 
 ## 🔧 Development Workflow
 1. Test changes with `python scripts/pytorch_dataloader.py`
@@ -147,7 +148,35 @@ def check_image_sizes(data_dir: str = "data", num_samples: int = 10) -> None:
 - Dataset files are large and stored in Git LFS
 - Always validate parquet file operations
 - Image decoding can fail - handle exceptions
-- Memory usage is ~24MB total - efficient for most systems
+- Memory usage is efficient with lazy loading
 - Maintain compatibility with PyTorch training workflows
 - Preserve existing API contracts when modifying dataloader
-- Use type hints for better IDE support and debugging
+- Use type hints for better IDE support and debugging
+
+## 🔄 PT File Conversion (Planned)
+
+### Conversion Workflow
+```python
+# One-time conversion script (backlog)
+def convert_parquet_to_pt(data_dir, split):
+    dataset = ImageNet100Parquet(data_dir, split, transform)
+    all_images = torch.stack([dataset[i][0] for i in range(len(dataset))])
+    all_labels = torch.tensor([dataset[i][1] for i in range(len(dataset))])
+    torch.save({'images': all_images, 'labels': all_labels}, f'{data_dir}/{split}.pt')
+```
+
+### PT Dataset Class
+```python
+class ImageNet100PT(Dataset):
+    def __init__(self, data_dir: str, split: str = "train"):
+        data = torch.load(f"{data_dir}/{split}.pt")
+        self.images = data['images']
+        self.labels = data['labels']
+    
+    def __len__(self): return len(self.images)
+    def __getitem__(self, idx): return self.images[idx], self.labels[idx]
+```
+
+### File Patterns
+- **Current**: `data/train-*.parquet`, `data/validation-*.parquet`
+- **Future**: `data/train.pt`, `data/validation.pt`

README.md

@@ -1,202 +1,45 @@
----
-dataset_info:
-  features:
-  - name: image
-    dtype: image
-  - name: label
-    dtype:
-      class_label:
-        names:
-          '0': bonnet, poke bonnet
-          '1': green mamba
-          '2': langur
-          '3': Doberman, Doberman pinscher
-          '4': gyromitra
-          '5': Saluki, gazelle hound
-          '6': vacuum, vacuum cleaner
-          '7': window screen
-          '8': cocktail shaker
-          '9': garden spider, Aranea diademata
-          '10': garter snake, grass snake
-          '11': carbonara
-          '12': pineapple, ananas
-          '13': computer keyboard, keypad
-          '14': tripod
-          '15': komondor
-          '16': >-
-            American lobster, Northern lobster, Maine lobster, Homarus
-            americanus
-          '17': bannister, banister, balustrade, balusters, handrail
-          '18': honeycomb
-          '19': tile roof
-          '20': papillon
-          '21': boathouse
-          '22': stinkhorn, carrion fungus
-          '23': jean, blue jean, denim
-          '24': Chihuahua
-          '25': Chesapeake Bay retriever
-          '26': robin, American robin, Turdus migratorius
-          '27': tub, vat
-          '28': Great Dane
-          '29': rotisserie
-          '30': bottlecap
-          '31': throne
-          '32': little blue heron, Egretta caerulea
-          '33': rock crab, Cancer irroratus
-          '34': Rottweiler
-          '35': lorikeet
-          '36': Gila monster, Heloderma suspectum
-          '37': head cabbage
-          '38': car wheel
-          '39': coyote, prairie wolf, brush wolf, Canis latrans
-          '40': moped
-          '41': milk can
-          '42': mixing bowl
-          '43': toy terrier
-          '44': chocolate sauce, chocolate syrup
-          '45': rocking chair, rocker
-          '46': wing
-          '47': park bench
-          '48': ambulance
-          '49': football helmet
-          '50': leafhopper
-          '51': cauliflower
-          '52': pirate, pirate ship
-          '53': purse
-          '54': hare
-          '55': lampshade, lamp shade
-          '56': fiddler crab
-          '57': standard poodle
-          '58': Shih-Tzu
-          '59': pedestal, plinth, footstall
-          '60': gibbon, Hylobates lar
-          '61': safety pin
-          '62': English foxhound
-          '63': chime, bell, gong
-          '64': >-
-            American Staffordshire terrier, Staffordshire terrier, American pit
-            bull terrier, pit bull terrier
-          '65': bassinet
-          '66': wild boar, boar, Sus scrofa
-          '67': theater curtain, theatre curtain
-          '68': dung beetle
-          '69': hognose snake, puff adder, sand viper
-          '70': Mexican hairless
-          '71': mortarboard
-          '72': Walker hound, Walker foxhound
-          '73': red fox, Vulpes vulpes
-          '74': modem
-          '75': slide rule, slipstick
-          '76': walking stick, walkingstick, stick insect
-          '77': cinema, movie theater, movie theatre, movie house, picture palace
-          '78': meerkat, mierkat
-          '79': kuvasz
-          '80': obelisk
-          '81': harmonica, mouth organ, harp, mouth harp
-          '82': sarong
-          '83': mousetrap
-          '84': hard disc, hard disk, fixed disk
-          '85': American coot, marsh hen, mud hen, water hen, Fulica americana
-          '86': reel
-          '87': pickup, pickup truck
-          '88': iron, smoothing iron
-          '89': tabby, tabby cat
-          '90': ski mask
-          '91': vizsla, Hungarian pointer
-          '92': laptop, laptop computer
-          '93': stretcher
-          '94': Dutch oven
-          '95': African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
-          '96': boxer
-          '97': gasmask, respirator, gas helmet
-          '98': goose
-          '99': borzoi, Russian wolfhound
-  splits:
-  - name: train
-    num_bytes: 8091813320.875
-    num_examples: 126689
-  - name: validation
-    num_bytes: 314447246
-    num_examples: 5000
-  download_size: 8406986315
-  dataset_size: 8406260566.875
-configs:
-- config_name: default
-  data_files:
-  - split: train
-    path: data/train-*
-  - split: validation
-    path: data/validation-*
-task_categories:
-- image-classification
-size_categories:
-- 100K<n<1M
----
-
 # ImageNet-100 PyTorch Dataloader
 
-A streamlined PyTorch implementation for loading ImageNet-100 dataset from parquet files. This repository provides efficient dataloaders for both training and validation, perfect for computer vision tasks.
+Streamlined PyTorch implementation for ImageNet-100 from parquet files. Efficient dataloaders for training and validation.
 
 ## 🚀 Quick Start
 
-### Basic Usage
-
 ```python
 from scripts.pytorch_dataloader import ImageNet100Parquet
 from torch.utils.data import DataLoader
 from torchvision import transforms
 
-# Define transforms (resize to 224x224 for most models)
 transform = transforms.Compose([
     transforms.Resize((224, 224)),
     transforms.ToTensor(),
 ])
 
-# Create datasets
 train_dataset = ImageNet100Parquet("data", "train", transform)
-test_dataset = ImageNet100Parquet("data", "validation", transform)
+val_dataset = ImageNet100Parquet("data", "validation", transform)
 
-# Create dataloaders
 train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True)
-test_loader = DataLoader(test_dataset, batch_size=8, shuffle=False)
-
-# Use in your training loop
-for x, y_true in train_loader:
-    # x.shape: [batch_size, 3, 224, 224]
-    # y_true.shape: [batch_size]
-    pass
+val_loader = DataLoader(val_dataset, batch_size=8, shuffle=False)
 
-for x, y_true in test_loader:
-    # Same structure for validation
+for x, y in train_loader:  # x: [batch, 3, 224, 224], y: [batch]
     pass
 ```
 
 ## 📊 Dataset Details
 
 - **Classes**: 100 ImageNet classes (balanced)
-- **Training samples**: 126,689 images
-- **Validation samples**: 5,000 images
-- **Original image sizes**: Variable (mostly ~160px on shorter side)
-- **Standard output**: Resized to 224x224 (configurable)
+- **Training**: 126,689 images
+- **Validation**: 5,000 images  
+- **Image sizes**: Variable (standard output: 224×224)
 
 ## 🛠️ Utilities
 
 ### Data Inspection
 
-Use the built-in utilities to understand your data structure:
-
 ```bash
-# Run all utilities
-python scripts/utils.py
-
-# Debug data structure only
-python scripts/utils.py debug
-
-# Check image sizes only
-python scripts.utils.py sizes
-
-# Analyze memory usage (PyTorch tensor-based)
-python scripts.utils.py memory
+python scripts/utils.py                    # Run all utilities
+python scripts/utils.py debug              # Debug structure only
+python scripts/utils.py sizes              # Check image sizes only
+python scripts/utils.py memory             # Analyze memory usage
 ```
 
 ### Programmatic Usage
@@ -204,49 +47,50 @@ python scripts.utils.py memory
 ```python
 from scripts.utils import debug_structure, check_image_sizes, analyze_memory_usage
 
-# Inspect parquet file structure
-debug_structure()
-
-# Analyze image dimensions and PyTorch tensor memory usage
-check_image_sizes(num_samples=20)
-analyze_memory_usage(batch_size=32, num_batches=5)
+debug_structure()                          # Inspect parquet structure
+check_image_sizes(num_samples=20)          # Analyze image dimensions
+analyze_memory_usage(batch_size=32)        # Memory usage analysis
 ```
 
 ## 🎯 Key Features
 
 - **Efficient Loading**: Direct parquet file reading with proper image decoding
-- **Memory Optimized**: ~24MB total memory usage with lazy loading during iteration
+- **Memory Optimized**: Lazy loading with efficient tensor memory usage
 - **Robust Error Handling**: Comprehensive validation and error messages
 - **Type Safe**: Full type hints for better IDE support and debugging
 - **Flexible Transforms**: Easy to customize preprocessing pipeline
-- **Data Inspection**: Built-in utilities for understanding dataset structure and memory usage
+- **Data Inspection**: Built-in utilities for dataset structure analysis
 - **PyTorch Native**: Seamless integration with PyTorch training workflows
 
+## 🔄 Future PT File Support
+
+Planned conversion to eliminate pandas dependency:
+```python
+# Future usage (backlog item)
+train_dataset = ImageNet100PT("data", "train")  # Direct torch.load()
+val_dataset = ImageNet100PT("data", "validation")
+```
+
 ## 📝 Data Format
 
-Images are stored in parquet files with the following structure:
+Parquet structure:
 ```python
 {
-    'image': {
-        'bytes': b'\x89PNG...',  # Raw image bytes
-        'path': None
-    },
+    'image': {'bytes': b'\x89PNG...', 'path': None},
     'label': 0  # Integer class label (0-99)
 }
 ```
 
 ## 🔧 Configuration
 
-You can easily modify the dataloader for different needs:
-
 ```python
 # Different image sizes
 transform = transforms.Compose([
-    transforms.Resize((256, 256)),  # For models expecting 256x256
+    transforms.Resize((256, 256)),
     transforms.ToTensor(),
 ])
 
-# Custom preprocessing
+# Custom preprocessing  
 transform = transforms.Compose([
     transforms.Resize((224, 224)),
     transforms.RandomHorizontalFlip(),
@@ -259,16 +103,18 @@ transform = transforms.Compose([
 
 ## 📚 Dataset Information
 
+- **Classes**: 100 ImageNet classes (balanced)
+- **Training**: 126,689 images  
+- **Validation**: 5,000 images
 - **Homepage**: https://github.com/HobbitLong/CMC
 - **Paper**: [Contrastive multiview coding](https://arxiv.org/abs/1906.05849)
-- **Based on**: Original ImageNet-1k with 100 randomly selected classes
 
 ## 📄 License
 
-This dataset follows the original ImageNet license terms. Use only for non-commercial research and educational purposes.
+Original ImageNet license terms. Non-commercial research and educational use only.
 
 ## 🙏 Acknowledgments
 
-- Original ImageNet team for the dataset
-- 🤗 Transformers for the parquet format reference
-- [CMC paper](https://arxiv.org/abs/1906.05849) for the ImageNet-100 subset definition
+- Original ImageNet team
+- 🤗 Transformers (parquet format reference)  
+- [CMC paper](https://arxiv.org/abs/1906.05849) (ImageNet-100 subset)