212 lines
6.7 KiB
Python
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()
|