Data & Augmentation — Programuoki

Code

Run it and measure — honestly

All 11 tests pass. Now we connect data.py to train.py.

What changes in `train.py`

The training loop does not change. Only where the data comes from and how many outputs the model has:

from data import class_counts, make_loaders
...
def build_model(name, hidden, dropout, num_classes: int = 10):
    ...
    parser.add_argument("--data", default=None, help="folder of class folders")
    parser.add_argument("--augment", action="store_true")
    parser.add_argument("--balance", action="store_true")
    parser.add_argument("--batch-size", type=int, default=64)
...
    if args.data:
        print("class counts:", class_counts(args.data))
        loader, val_loader, classes = make_loaders(
            args.data, args.batch_size, augment=args.augment, balance=args.balance
        )
    else:
        ...
    model = build_model(args.model, tuple(args.hidden), args.dropout, len(classes))

In the panel you see two files in our versions: data.py with the holes filled and the augmentation / balancing code written, and train.py. If yours pass the tests, keep yours.

build_model(..., num_classes) matters. Before, the model always had 10 outputs. With a folder of 4 classes, 10 outputs raise no error — the model quietly has 6 unused outputs. len(classes) comes from the folder.

Run it — two commands

python train.py --model cnn --data standin_data --epochs 30 --batch-size 32 --dropout 0.3
python train.py --model cnn --data standin_data --epochs 30 --batch-size 32 --dropout 0.3 --augment

For your own photographs replace standin_data with data (or your folder's name).

Our runs on the stand-in dataset (4 classes × 200; 640 for training, 160 for validation; seed 42):

class counts: {'coat': 200, 'pullover': 200, 'sneaker': 200, 'tshirt': 200}
cnn: 11,076 parameters, 4 classes
epoch  1  loss 0.5417  train acc 74.8%  |  val loss 0.5127  val acc 76.9%
   ...
epoch 30  loss 0.1059  train acc 95.9%  |  val loss 0.2072  val acc 92.5%
final: train 95.9%  val 92.5%  gap +3.4%

class counts: {'coat': 200, 'pullover': 200, 'sneaker': 200, 'tshirt': 200}
cnn: 11,076 parameters, 4 classes
epoch  1  loss 0.7723  train acc 64.2%  |  val loss 0.6535  val acc 69.4%
   ...
epoch 30  loss 0.2731  train acc 90.0%  |  val loss 0.2438  val acc 91.9%
final: train 91.1%  val 91.9%  gap -0.8%

Your numbers will differ by roughly 1–2 points.

What it means — carefully

	train	val	gap
without augmentation	95.9 %	92.5 %	+3.4
with augmentation	91.1 %	91.9 %	−0.8

The gap "vanished" (+3.4 → −0.8). But a negative gap is no miracle: "training accuracy" here is measured on augmented pictures, which are harder than ordinary ones. It fell (95.9 → 91.1) while validation did not.
Validation accuracy did not go up. 92.5 % and 91.9 % — a difference of 0.6 points, i.e. one picture out of 160. A tie.
That is not just our seed's bad luck. For three seeds (0, 1, 2): 91.7 % without and 91.5 % with augmentation (30 epochs); 91.7 % and 92.3 % (60 epochs). The differences are a few pictures out of 160, with no direction.

What augmentation really did: it reduced the overlap with the training pictures. The network can no longer memorise them so easily. What it did not do: raise accuracy on our dataset, because that dataset is easy anyway — four well-separated classes at 28 × 28.

With less data — worse still?

We tried 60 pictures per class (48 for validation; 40 epochs; three seeds):

augment=False: val ['0.854', '0.938', '0.938']  mean 0.910
augment=True : val ['0.875', '0.854', '0.875']  mean 0.868

Here augmentation looks worse (86.8 % vs 91.0 %). But one validation picture = 2.1 points, and the spread across seeds is as large as the difference (from 85.4 % to 93.8 %), so we prove nothing. But one thing you should not expect: that augmentation "automatically rescues a small dataset".

If your data is harder (natural photographs, a lot of noise), augmentation may help more: in lesson 10 you will see an experiment on CIFAR-10 photographs where the same augmentation lifted a from-scratch CNN from 49.4 % to 56.2 % (one seed, 160 validation pictures). But check on your own data; do not take our word for it.

When it does not pass

mat1 and mat2 shapes cannot be multiplied (1792x28 and 784x256) — you ran --model mlp --data standin_data. An MLP wants flat [N, 784], while the folder gives [N, 1, 28, 28]. (1792 = 64 · 28 — the batch gets "merged".) --model cnn accepts both shapes.
No error, but the model has 10 outputs — you forgot to pass num_classes. Six outputs are never trained, yet the loss still computes. The opposite case (4 folders, 3 outputs) would give IndexError: Target 3 is out of bounds — at least a loud error.
FileNotFoundError: Couldn't find any class folder in data. — --data points at a folder with no class subfolders (too high up or too low down).
FileNotFoundError: Found no valid file for the classes ... — a class folder has no jpg/png/... files; check that prepare.py really wrote there.

data.py MODIFY 9 lines changed

Edit this file in ./

"""data.py — your own images, read from folders: data/<class>/*.png."""

from collections import Counter

import torch
from torch.utils.data import DataLoader, Subset, WeightedRandomSampler
from torchvision import datasets, transforms


def class_counts(root: str) -> dict[str, int]:
    """How many images each class folder holds."""
    ds = datasets.ImageFolder(root)
    counts = Counter(ds.targets)
    return {name: counts[i] for i, name in enumerate(ds.classes)}


def build_transform(
    augment: bool, mean: float | None = None, std: float | None = None
) -> transforms.Compose:
    steps: list = [transforms.Grayscale(num_output_channels=1)]
    if augment:  # random changes, applied freshly every time an image is loaded
        steps += [
            transforms.RandomHorizontalFlip(),
            transforms.RandomAffine(degrees=10, translate=(0.1, 0.1), scale=(0.9, 1.1)),
        ]
    steps.append(transforms.ToTensor())  # PIL image -> [1, H, W] floats in 0..1
    if mean is not None:
        steps.append(transforms.Normalize([mean], [std]))
    return transforms.Compose(steps)


def split_indices(
    targets: list[int], val_frac: float, seed: int
) -> tuple[list[int], list[int]]:
    """A stratified split: every class contributes val_frac of its images."""
    gen = torch.Generator().manual_seed(seed)
    train_idx: list[int] = []
    val_idx: list[int] = []
    for cls in sorted(set(targets)):
        idx = [i for i, t in enumerate(targets) if t == cls]
        order = torch.randperm(len(idx), generator=gen).tolist()
        n_val = max(1, round(len(idx) * val_frac))
        val_idx += [idx[j] for j in order[:n_val]]
        train_idx += [idx[j] for j in order[n_val:]]
    return train_idx, val_idx


def mean_std(ds: datasets.ImageFolder, idx: list[int]) -> tuple[float, float]:
    """Pixel mean and std over the TRAINING images only."""
    pixels = torch.cat([ds[i][0].flatten() for i in idx])
    return pixels.mean().item(), pixels.std().item()


def make_loaders(
    root: str,
    batch_size: int = 32,
    val_frac: float = 0.2,
    augment: bool = False,
    balance: bool = False,
    seed: int = 42,
) -> tuple[DataLoader, DataLoader, list[str]]:
    """Return (train_loader, val_loader, class_names)."""
    plain = datasets.ImageFolder(root, transform=build_transform(augment=False))
    train_idx, val_idx = split_indices(plain.targets, val_frac, seed)
    mean, std = mean_std(plain, train_idx)

    # Two views of the same files: augmented for training, untouched for validation.
    train_ds = datasets.ImageFolder(root, transform=build_transform(augment, mean, std))
    val_ds = datasets.ImageFolder(root, transform=build_transform(False, mean, std))

    sampler = None
    if balance:  # draw rare classes more often
        counts = Counter(plain.targets[i] for i in train_idx)
        weights = [1.0 / counts[plain.targets[i]] for i in train_idx]
        sampler = WeightedRandomSampler(weights, num_samples=len(train_idx))

    train_loader = DataLoader(
        Subset(train_ds, train_idx),
        batch_size=batch_size,
        shuffle=(sampler is None),
        sampler=sampler,
    )
    val_loader = DataLoader(Subset(val_ds, val_idx), batch_size=batch_size)
    return train_loader, val_loader, plain.classes

train.py MODIFY 25 lines changed