Part 1: Can We Beat State-of-the-Art on CIFAR?

torch>=2.0.0 torchvision>=0.15.0 numpy>=1.24.0 matplotlib>=3.7.0 tqdm>=4.65.0 tensorboard>=2.12.0 albumentations>=1.3.0

cifar-challenge/ ├── data/ # Dataset will be downloaded here ├── models/ │ ├── __init__.py │ ├── baseline.py # Simple CNN │ ├── resnet.py # ResNet variants │ └── wideresnet.py # Wide ResNet ├── utils/ │ ├── __init__.py │ ├── data.py # Data loading & augmentation │ ├── training.py # Training loops │ └── evaluation.py # Metrics & visualization ├── configs/ │ └── default.yaml # Hyperparameters ├── train.py # Main training script ├── evaluate.py # Evaluation script └── README.md

import torch from torchvision import datasets, transforms from torch.utils.data import DataLoader def get_cifar10_loaders(batch_size=128, num_workers=4): """ Load CIFAR-10 dataset with basic normalization. Returns: train_loader, test_loader """ # CIFAR-10 mean and std (precomputed) CIFAR10_MEAN = (0.4914, 0.4822, 0.4465) CIFAR10_STD = (0.2470, 0.2435, 0.2616) # Basic transforms (no augmentation yet) train_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(CIFAR10_MEAN, CIFAR10_STD), ]) test_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(CIFAR10_MEAN, CIFAR10_STD), ]) # Download and load datasets train_dataset = datasets.CIFAR10( root='./data', train=True, download=True, transform=train_transform ) test_dataset = datasets.CIFAR10( root='./data', train=False, download=True, transform=test_transform ) # Create data loaders train_loader = DataLoader( train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers, pin_memory=True ) test_loader = DataLoader( test_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers, pin_memory=True ) return train_loader, test_loader

import torch import torch.nn as nn import torch.nn.functional as F class SimpleCNN(nn.Module): """ Simple CNN baseline for CIFAR-10. Architecture: Conv -> BN -> ReLU -> Pool (x3) -> FC Expected accuracy: ~82-85% """ def __init__(self, num_classes=10): super(SimpleCNN, self).__init__() # Block 1: 32x32 -> 16x16 self.conv1 = nn.Conv2d(3, 64, kernel_size=3, padding=1) self.bn1 = nn.BatchNorm2d(64) self.conv2 = nn.Conv2d(64, 64, kernel_size=3, padding=1) self.bn2 = nn.BatchNorm2d(64) self.pool1 = nn.MaxPool2d(2, 2) # Block 2: 16x16 -> 8x8 self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1) self.bn3 = nn.BatchNorm2d(128) self.conv4 = nn.Conv2d(128, 128, kernel_size=3, padding=1) self.bn4 = nn.BatchNorm2d(128) self.pool2 = nn.MaxPool2d(2, 2) # Block 3: 8x8 -> 4x4 self.conv5 = nn.Conv2d(128, 256, kernel_size=3, padding=1) self.bn5 = nn.BatchNorm2d(256) self.conv6 = nn.Conv2d(256, 256, kernel_size=3, padding=1) self.bn6 = nn.BatchNorm2d(256) self.pool3 = nn.MaxPool2d(2, 2) # Classifier self.fc1 = nn.Linear(256 * 4 * 4, 512) self.dropout = nn.Dropout(0.5) self.fc2 = nn.Linear(512, num_classes) def forward(self, x): # Block 1 x = F.relu(self.bn1(self.conv1(x))) x = F.relu(self.bn2(self.conv2(x))) x = self.pool1(x) # Block 2 x = F.relu(self.bn3(self.conv3(x))) x = F.relu(self.bn4(self.conv4(x))) x = self.pool2(x) # Block 3 x = F.relu(self.bn5(self.conv5(x))) x = F.relu(self.bn6(self.conv6(x))) x = self.pool3(x) # Classifier x = x.view(x.size(0), -1) x = F.relu(self.fc1(x)) x = self.dropout(x) x = self.fc2(x) return x # Count parameters def count_parameters(model): return sum(p.numel() for p in model.parameters() if p.requires_grad) # Test if __name__ == "__main__": model = SimpleCNN() print(f"Parameters: {count_parameters(model):,}") # Output: Parameters: 2,847,818

import torch import torch.nn as nn import torch.optim as optim from tqdm import tqdm import time from models.baseline import SimpleCNN from utils.data import get_cifar10_loaders def train_one_epoch(model, train_loader, criterion, optimizer, device): """Train for one epoch.""" model.train() running_loss = 0.0 correct = 0 total = 0 pbar = tqdm(train_loader, desc='Training') for inputs, targets in pbar: inputs, targets = inputs.to(device), targets.to(device) # Forward pass optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, targets) # Backward pass loss.backward() optimizer.step() # Statistics running_loss += loss.item() _, predicted = outputs.max(1) total += targets.size(0) correct += predicted.eq(targets).sum().item() pbar.set_postfix({ 'loss': f'{running_loss/total:.4f}', 'acc': f'{100.*correct/total:.2f}%' }) return running_loss / len(train_loader), 100. * correct / total def evaluate(model, test_loader, criterion, device): """Evaluate on test set.""" model.eval() running_loss = 0.0 correct = 0 total = 0 with torch.no_grad(): for inputs, targets in test_loader: inputs, targets = inputs.to(device), targets.to(device) outputs = model(inputs) loss = criterion(outputs, targets) running_loss += loss.item() _, predicted = outputs.max(1) total += targets.size(0) correct += predicted.eq(targets).sum().item() return running_loss / len(test_loader), 100. * correct / total def main(): # Config BATCH_SIZE = 128 EPOCHS = 100 LR = 0.1 MOMENTUM = 0.9 WEIGHT_DECAY = 5e-4 # Device device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print(f'Using device: {device}') # Data train_loader, test_loader = get_cifar10_loaders(BATCH_SIZE) print(f'Training samples: {len(train_loader.dataset)}') print(f'Test samples: {len(test_loader.dataset)}') # Model model = SimpleCNN(num_classes=10).to(device) # Loss and optimizer criterion = nn.CrossEntropyLoss() optimizer = optim.SGD( model.parameters(), lr=LR, momentum=MOMENTUM, weight_decay=WEIGHT_DECAY ) # Learning rate scheduler scheduler = optim.lr_scheduler.MultiStepLR( optimizer, milestones=[50, 75, 90], gamma=0.1 ) # Training loop best_acc = 0.0 for epoch in range(EPOCHS): print(f'\nEpoch {epoch+1}/{EPOCHS}') print(f'LR: {scheduler.get_last_lr()[0]:.6f}') train_loss, train_acc = train_one_epoch( model, train_loader, criterion, optimizer, device ) test_loss, test_acc = evaluate( model, test_loader, criterion, device ) print(f'Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.2f}%') print(f'Test Loss: {test_loss:.4f} | Test Acc: {test_acc:.2f}%') # Save best model if test_acc > best_acc: best_acc = test_acc torch.save(model.state_dict(), 'best_model.pth') print(f'New best accuracy: {best_acc:.2f}%') scheduler.step() print(f'\nBest Test Accuracy: {best_acc:.2f}%') if __name__ == '__main__': main()