Download src/train.py from shyo2/cnn0: direct link, hf CLI and curl.
- Browser
- Download file 3.7 kB
-
https://huggingface.co/shyo2/cnn0/resolve/main/src/train.py
- Command line
-
hf download hf://shyo2/cnn0/src/train.py
-
curl -L -o train.py https://huggingface.co/shyo2/cnn0/resolve/main/src/train.py
3.7 kB
| import argparse | |
| import json | |
| import time | |
| from pathlib import Path | |
| import torch | |
| import torch.nn as nn | |
| from torch.utils.data import DataLoader | |
| from torchvision import datasets, transforms | |
| from model import CNN, count_params | |
| def get_loaders(data_dir, batch_size): | |
| transform = transforms.Compose([ | |
| transforms.ToTensor(), | |
| transforms.Normalize((0.1307,), (0.3081,)), | |
| ]) | |
| train_set = datasets.MNIST(data_dir, train=True, download=True, transform=transform) | |
| val_set = datasets.MNIST(data_dir, train=False, download=True, transform=transform) | |
| train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True, num_workers=2) | |
| val_loader = DataLoader(val_set, batch_size=512, shuffle=False, num_workers=2) | |
| return train_loader, val_loader | |
| def evaluate(model, loader, device): | |
| model.eval() | |
| correct = total = 0 | |
| for x, y in loader: | |
| x, y = x.to(device), y.to(device) | |
| correct += (model(x).argmax(1) == y).sum().item() | |
| total += y.size(0) | |
| model.train() | |
| return correct / total | |
| def main(): | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument("--depth", type=int, required=True, help="number of blocks (each = 2 conv layers)") | |
| parser.add_argument("--residual", action="store_true") | |
| parser.add_argument("--no-bn", action="store_true") | |
| parser.add_argument("--channels", type=int, default=64) | |
| parser.add_argument("--epochs", type=int, default=15) | |
| parser.add_argument("--batch-size", type=int, default=128) | |
| parser.add_argument("--lr", type=float, default=1e-3) | |
| parser.add_argument("--data-dir", default="data") | |
| parser.add_argument("--out-dir", default=None) | |
| args = parser.parse_args() | |
| device = "cuda" if torch.cuda.is_available() else "cpu" | |
| suffix = ("_res" if args.residual else "") + ("_nobn" if args.no_bn else "") | |
| out_dir = Path(args.out_dir or f"runs/depth{args.depth}{suffix}") | |
| out_dir.mkdir(parents=True, exist_ok=True) | |
| model = CNN(args.depth, channels=args.channels, | |
| use_residual=args.residual, bn=not args.no_bn).to(device) | |
| train_loader, val_loader = get_loaders(args.data_dir, args.batch_size) | |
| opt = torch.optim.Adam(model.parameters(), lr=args.lr) | |
| sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=args.epochs) | |
| criterion = nn.CrossEntropyLoss() | |
| print(f"depth={args.depth} residual={args.residual} bn={not args.no_bn} params={count_params(model):,} device={device}") | |
| history = [] | |
| for epoch in range(1, args.epochs + 1): | |
| model.train() | |
| t0 = time.time() | |
| running_loss, running_correct, n = 0.0, 0, 0 | |
| for x, y in train_loader: | |
| x, y = x.to(device), y.to(device) | |
| opt.zero_grad(set_to_none=True) | |
| logits = model(x) | |
| loss = criterion(logits, y) | |
| loss.backward() | |
| opt.step() | |
| running_loss += loss.item() * y.size(0) | |
| running_correct += (logits.argmax(1) == y).sum().item() | |
| n += y.size(0) | |
| sched.step() | |
| train_acc = running_correct / n | |
| val_acc = evaluate(model, val_loader, device) | |
| train_loss = running_loss / n | |
| history.append({"epoch": epoch, "train_loss": train_loss, | |
| "train_acc": train_acc, "val_acc": val_acc}) | |
| print(f"epoch {epoch:2d}/{args.epochs} loss={train_loss:.4f} " | |
| f"train_acc={train_acc:.4f} val_acc={val_acc:.4f} ({time.time()-t0:.1f}s)") | |
| torch.save(model.state_dict(), out_dir / "model.pt") | |
| (out_dir / "history.json").write_text(json.dumps(history, indent=2)) | |
| print(f"saved to {out_dir}") | |
| if __name__ == "__main__": | |
| main() | |