| import os
|
| import cv2
|
| import torch
|
| import numpy as np
|
| import pandas as pd
|
|
|
| from torch.utils.data import Dataset, DataLoader
|
| from torchvision import transforms
|
| from pytorchvideo.models.resnet import create_resnet
|
|
|
| import torch.nn as nn
|
| import torch.optim as optim
|
| from tqdm import tqdm
|
|
|
|
|
|
|
|
|
| NUM_FRAMES = 16
|
| IMG_SIZE = 112
|
| BATCH_SIZE = 8
|
| EPOCHS = 20
|
| LR = 5e-5
|
|
|
| DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
|
| print("🚀 Using device:", DEVICE)
|
|
|
|
|
|
|
|
|
| class AirLettersDataset(Dataset):
|
| def __init__(self, csv_path, video_dir):
|
| self.df = pd.read_csv(csv_path)
|
| self.df.columns = self.df.columns.str.strip()
|
| self.video_dir = video_dir
|
|
|
| self.transform = transforms.Compose([
|
| transforms.ToPILImage(),
|
| transforms.Resize((IMG_SIZE, IMG_SIZE)),
|
| transforms.RandomHorizontalFlip(p=0.3),
|
| transforms.RandomRotation(10),
|
| transforms.ToTensor(),
|
| transforms.Normalize([0.45]*3, [0.225]*3)
|
| ])
|
|
|
| def __len__(self):
|
| return len(self.df)
|
|
|
| def get_label(self, label):
|
| label = label.lower().strip()
|
|
|
| try:
|
| if "letter" in label:
|
| char = label.split("letter")[1].strip()[0]
|
| return ord(char.upper()) - ord('A')
|
|
|
| elif "digit" in label:
|
| digit = label.split("digit")[1].strip()[0]
|
| return 26 + int(digit)
|
|
|
| elif "doing nothing" in label:
|
| return 36
|
|
|
| else:
|
| return 37
|
| except:
|
| return 37
|
|
|
| def load_video(self, path):
|
| cap = cv2.VideoCapture(path)
|
|
|
| if not cap.isOpened():
|
| return None
|
|
|
| total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
|
| if total == 0:
|
| cap.release()
|
| return None
|
|
|
| indices = np.linspace(0, total - 1, NUM_FRAMES).astype(int)
|
| frames = []
|
|
|
| for idx in indices:
|
| cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
|
| ret, frame = cap.read()
|
|
|
| if ret and frame is not None:
|
| frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
|
| frames.append(self.transform(frame))
|
|
|
| cap.release()
|
|
|
| if len(frames) == 0:
|
| return None
|
|
|
| while len(frames) < NUM_FRAMES:
|
| frames.append(frames[-1])
|
|
|
| return torch.stack(frames).permute(1, 0, 2, 3)
|
|
|
| def __getitem__(self, idx):
|
| for _ in range(5):
|
| row = self.df.iloc[idx]
|
| video_path = os.path.join(self.video_dir, row['filename'])
|
|
|
| video = self.load_video(video_path)
|
|
|
| if video is not None:
|
| label = self.get_label(row['label'])
|
| return video, label
|
|
|
| idx = (idx + 1) % len(self.df)
|
|
|
| raise RuntimeError("Too many bad videos")
|
|
|
|
|
|
|
|
|
|
|
| def main():
|
|
|
| train_csv = "train.csv"
|
| val_csv = "val.csv"
|
| test_csv = "test.csv"
|
| video_dir = "videos"
|
|
|
| train_set = AirLettersDataset(train_csv, video_dir)
|
| val_set = AirLettersDataset(val_csv, video_dir)
|
| test_set = AirLettersDataset(test_csv, video_dir)
|
|
|
| train_loader = DataLoader(train_set, batch_size=BATCH_SIZE, shuffle=True, num_workers=4, pin_memory=True)
|
| val_loader = DataLoader(val_set, batch_size=BATCH_SIZE, shuffle=False, num_workers=4, pin_memory=True)
|
| test_loader = DataLoader(test_set, batch_size=BATCH_SIZE, shuffle=False, num_workers=4, pin_memory=True)
|
|
|
|
|
|
|
|
|
| model = create_resnet(
|
| input_channel=3,
|
| model_depth=101,
|
| model_num_class=38
|
| ).to(DEVICE)
|
|
|
|
|
|
|
|
|
| if os.path.exists("resnext200_airletters.pth"):
|
| print("📦 Loading pretrained weights...")
|
|
|
| state_dict = torch.load("resnext200_airletters.pth", map_location=DEVICE)
|
| model_dict = model.state_dict()
|
|
|
| filtered_dict = {k: v for k, v in state_dict.items()
|
| if k in model_dict and model_dict[k].shape == v.shape}
|
|
|
| model_dict.update(filtered_dict)
|
| model.load_state_dict(model_dict)
|
|
|
| print("✅ Pretrained loaded safely")
|
|
|
|
|
|
|
|
|
| criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
|
| optimizer = optim.Adam(model.parameters(), lr=LR)
|
|
|
| scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=EPOCHS)
|
| scaler = torch.cuda.amp.GradScaler()
|
|
|
| best_acc = 0
|
|
|
|
|
|
|
|
|
| for epoch in range(EPOCHS):
|
|
|
| model.train()
|
| correct, total, loss_sum = 0, 0, 0
|
|
|
| loop = tqdm(train_loader, desc=f"🔥 Epoch {epoch+1}/{EPOCHS}")
|
|
|
| for videos, labels in loop:
|
| videos, labels = videos.to(DEVICE), labels.to(DEVICE)
|
|
|
| optimizer.zero_grad()
|
|
|
|
|
| with torch.cuda.amp.autocast():
|
| outputs = model(videos)
|
| loss = criterion(outputs, labels)
|
|
|
| scaler.scale(loss).backward()
|
| scaler.step(optimizer)
|
| scaler.update()
|
|
|
| loss_sum += loss.item()
|
|
|
| _, preds = torch.max(outputs, 1)
|
| correct += (preds == labels).sum().item()
|
| total += labels.size(0)
|
|
|
| acc = 100 * correct / total
|
| loop.set_postfix(loss=f"{loss.item():.4f}", acc=f"{acc:.2f}%")
|
|
|
| scheduler.step()
|
|
|
| train_acc = 100 * correct / total
|
| print(f"\n📈 Train Acc: {train_acc:.2f}%")
|
|
|
|
|
|
|
|
|
| model.eval()
|
| val_correct, val_total = 0, 0
|
|
|
| with torch.no_grad():
|
| for videos, labels in val_loader:
|
| videos, labels = videos.to(DEVICE), labels.to(DEVICE)
|
|
|
| outputs = model(videos)
|
| _, preds = torch.max(outputs, 1)
|
|
|
| val_correct += (preds == labels).sum().item()
|
| val_total += labels.size(0)
|
|
|
| val_acc = 100 * val_correct / val_total
|
| print(f"🎯 Validation Acc: {val_acc:.2f}%")
|
|
|
|
|
| if val_acc > best_acc:
|
| best_acc = val_acc
|
| torch.save(model.state_dict(), "best_model.pth")
|
| print("🏆 Best model saved!")
|
|
|
|
|
|
|
|
|
| model.eval()
|
| test_correct, test_total = 0, 0
|
|
|
| with torch.no_grad():
|
| for videos, labels in test_loader:
|
| videos, labels = videos.to(DEVICE), labels.to(DEVICE)
|
|
|
| outputs = model(videos)
|
| _, preds = torch.max(outputs, 1)
|
|
|
| test_correct += (preds == labels).sum().item()
|
| test_total += labels.size(0)
|
|
|
| print(f"\n🏆 Final Test Accuracy: {100*test_correct/test_total:.2f}%")
|
|
|
| torch.save(model.state_dict(), "final_model.pth")
|
| print("✅ Final model saved as final_model.pth")
|
|
|
|
|
|
|
| if __name__ == "__main__":
|
| main() |
