Files
light-petal-recognition/pc_training/train_tiny_cnn.py
T

212 lines
6.7 KiB
Python

"""
Train TinyCNN for the HLS accelerator path.
Default command:
python train_tiny_cnn.py --data_dir ../data/processed --input_size 64 --epochs 150 --batch_size 32 --save_path ../data/models/tiny_cnn.pth
"""
import argparse
import os
import random
import sys
import time
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from PIL import Image
from torch.utils.data import DataLoader, Dataset
from torchvision import transforms
from tqdm import tqdm
from tiny_cnn import create_tiny_cnn
def configure_stdio():
for stream in (sys.stdout, sys.stderr):
if hasattr(stream, "reconfigure"):
stream.reconfigure(encoding="utf-8", errors="replace")
configure_stdio()
def seed_everything(seed):
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(seed)
class TinyLightDataset(Dataset):
"""Loads class_N image folders as grayscale 64x64 tensors."""
def __init__(self, root_dir, input_size=64, augment=False):
self.root_dir = root_dir
self.images = []
self.labels = []
if os.path.isdir(root_dir):
for class_name in sorted(os.listdir(root_dir)):
class_dir = os.path.join(root_dir, class_name)
if not os.path.isdir(class_dir) or not class_name.startswith("class_"):
continue
label = int(class_name.split("_")[-1])
for image_name in sorted(os.listdir(class_dir)):
if image_name.lower().endswith((".jpg", ".jpeg", ".png")):
self.images.append(os.path.join(class_dir, image_name))
self.labels.append(label)
base = [
transforms.Grayscale(num_output_channels=1),
transforms.Resize((input_size, input_size)),
]
if augment:
base.extend([
transforms.RandomHorizontalFlip(),
transforms.RandomRotation(12),
])
base.extend([
transforms.ToTensor(),
])
self.transform = transforms.Compose(base)
def __len__(self):
return len(self.images)
def __getitem__(self, idx):
image = Image.open(self.images[idx]).convert("RGB")
return self.transform(image), self.labels[idx]
def evaluate(model, loader, criterion, device):
model.eval()
total_loss = 0.0
correct = 0
total = 0
with torch.no_grad():
for images, labels in loader:
images = images.to(device)
labels = labels.to(device)
logits = model(images)
loss = criterion(logits, labels)
total_loss += loss.item()
pred = logits.argmax(dim=1)
correct += (pred == labels).sum().item()
total += labels.numel()
avg_loss = total_loss / max(1, len(loader))
accuracy = 100.0 * correct / max(1, total)
return avg_loss, accuracy
def main():
parser = argparse.ArgumentParser(description="Train TinyCNN for HLS deployment")
parser.add_argument("--data_dir", default="../data/processed")
parser.add_argument("--input_size", type=int, default=64)
parser.add_argument("--epochs", type=int, default=150)
parser.add_argument("--batch_size", type=int, default=32)
parser.add_argument("--lr", type=float, default=1e-3)
parser.add_argument("--weight_decay", type=float, default=1e-4)
parser.add_argument("--num_workers", type=int, default=0)
parser.add_argument("--num_classes", type=int, default=10)
parser.add_argument("--save_path", default="../data/models/tiny_cnn.pth")
parser.add_argument("--seed", type=int, default=42)
args = parser.parse_args()
seed_everything(args.seed)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Device: {device}")
train_dataset = TinyLightDataset(
os.path.join(args.data_dir, "train"),
input_size=args.input_size,
augment=True,
)
val_dataset = TinyLightDataset(
os.path.join(args.data_dir, "val"),
input_size=args.input_size,
augment=False,
)
print(f"Train images: {len(train_dataset)}")
print(f"Val images: {len(val_dataset)}")
train_loader = DataLoader(
train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
)
val_loader = DataLoader(
val_dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.num_workers,
)
model = create_tiny_cnn(num_classes=args.num_classes).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=args.weight_decay)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.epochs)
best_acc = -1.0
best_state = None
start = time.time()
for epoch in range(1, args.epochs + 1):
model.train()
running_loss = 0.0
correct = 0
total = 0
pbar = tqdm(train_loader, desc=f"Epoch {epoch}/{args.epochs}")
for images, labels in pbar:
images = images.to(device)
labels = labels.to(device)
optimizer.zero_grad()
logits = model(images)
loss = criterion(logits, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
pred = logits.argmax(dim=1)
correct += (pred == labels).sum().item()
total += labels.numel()
pbar.set_postfix(
loss=f"{running_loss / max(1, pbar.n + 1):.4f}",
acc=f"{100.0 * correct / max(1, total):.2f}%",
)
scheduler.step()
train_acc = 100.0 * correct / max(1, total)
val_loss, val_acc = evaluate(model, val_loader, criterion, device)
print(
f"Epoch {epoch}: train_acc={train_acc:.2f}% "
f"val_loss={val_loss:.4f} val_acc={val_acc:.2f}%"
)
if val_acc > best_acc:
best_acc = val_acc
best_state = {
"epoch": epoch,
"model_state_dict": model.state_dict(),
"best_acc": best_acc,
"input_size": args.input_size,
"num_classes": args.num_classes,
}
os.makedirs(os.path.dirname(os.path.abspath(args.save_path)), exist_ok=True)
torch.save(best_state, args.save_path)
print(f"Saved best model to {args.save_path} ({best_acc:.2f}%)")
elapsed = time.time() - start
print(f"Training finished in {elapsed:.1f}s, best val acc={best_acc:.2f}%")
if best_state is None:
raise RuntimeError("Training produced no checkpoint")
if __name__ == "__main__":
main()