cnn0 / src /train.py
shyo2's picture
Devin
Add CNN/ResNet model builder and MNIST training pipeline
562abfe
Raw History Blame Contribute Delete
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
@torch.no_grad()
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()