{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "8851b4d5", "metadata": {}, "outputs": [], "source": [ "import os, math, random, argparse, itertools\n", "from pathlib import Path\n", "from collections import defaultdict\n", "from typing import List, Tuple\n", "\n", "import numpy as np\n", "from PIL import Image, ImageFile\n", "import torch\n", "import torch.nn as nn\n", "import torch.optim as optim\n", "from torch.utils.data import Dataset, DataLoader\n", "from torchvision import models, transforms\n", "from torchvision.transforms.functional import InterpolationMode\n", "import matplotlib.pyplot as plt\n", "from sklearn.metrics import classification_report, confusion_matrix" ] }, { "cell_type": "code", "execution_count": 55, "id": "351ceed7", "metadata": {}, "outputs": [], "source": [ "SEED = 42\n", "random.seed(SEED); np.random.seed(SEED); torch.manual_seed(SEED); torch.cuda.manual_seed_all(SEED)\n", "\n", "# Your Kaggle dataset root (class folders like \"bench press\", \"deadlift\", \"squat\")\n", "SOURCE = Path(r\"C:\\University\\Y2T1\\Computer Vision and Deep Learning\\Project\\Dataset\")\n", "\n", "# Classes (as they appear in SOURCE) and normalized labels for reporting/UI\n", "CLASSES_RAW = [\"bench press\", \"deadlift\", \"squat\", \"leg extension\", \"push up\", \"shoulder press\"]\n", "CLASSES = [\"bench_press\", \"deadlift\", \"squat\", \"leg_extension\", \"push_up\", \"shoulder_press\"] \n", "\n", "# Training / preprocessing knobs\n", "IMG_SIZE = 224\n", "BATCH_SIZE = 32\n", "EPOCHS = 20\n", "BASE_LR = 3e-4\n", "WEIGHT_DECAY = 1e-4\n", "PATIENCE = 5\n", "LABEL_SMOOTHING = 0.1\n", "USE_MIXUP = True\n", "MIXUP_ALPHA = 0.4\n", "MODEL_NAME = \"efficientnet_b0\" # choices: 'resnet18', 'efficientnet_b0', 'vgg16', 'alexnet', 'lenet'\n", "OUT_WEIGHTS = \"sbd_best.pt\"\n", "\n", "# Demo / deployment toggles (optional)\n", "EXPORT_ONNX = \"\" # e.g., \"sbd.onnx\" to export ONNX; \"\" to skip\n", "LAUNCH_GRADIO = False # True to launch a quick demo UI after training\n", "ImageFile.LOAD_TRUNCATED_IMAGES = True\n", "\n", "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")" ] }, { "cell_type": "code", "execution_count": 56, "id": "2b0ed01a", "metadata": {}, "outputs": [], "source": [ "# ============================================================\n", "# 1) PREPROCESSING — transforms\n", "# ============================================================\n", "train_tfms = transforms.Compose([\n", " transforms.Resize((IMG_SIZE, IMG_SIZE), interpolation=InterpolationMode.BICUBIC),\n", " transforms.RandomHorizontalFlip(0.5),\n", " transforms.RandomApply([transforms.ColorJitter(0.2,0.2,0.2,0.05)], p=0.5),\n", " transforms.RandomRotation(10, interpolation=InterpolationMode.BILINEAR),\n", " transforms.ToTensor(),\n", " transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225]),\n", "])\n", "eval_tfms = transforms.Compose([\n", " transforms.Resize((IMG_SIZE, IMG_SIZE), interpolation=InterpolationMode.BICUBIC),\n", " transforms.ToTensor(),\n", " transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225]),\n", "])" ] }, { "cell_type": "code", "execution_count": 57, "id": "bd1c7805", "metadata": {}, "outputs": [], "source": [ "# ============================================================\n", "# 2) DATA ANNOTATION / INGEST (OPTIONAL)\n", "# - If you add your own images (curation/annotation), copy them in.\n", "# ============================================================\n", "def list_images(dir_path: Path) -> List[Path]:\n", " exts = (\".jpg\",\".jpeg\",\".png\",\".webp\",\".bmp\")\n", " return [dir_path/f for f in os.listdir(dir_path) if f.lower().endswith(exts)]\n", "\n", "def ingest_own_data(own_root: Path, source_root: Path):\n", " \"\"\"Copy your own annotated images into the SOURCE class folders.\n", " Expected own_root has subfolders: bench_press, deadlift, squat.\"\"\"\n", " mapping = {\n", " \"bench_press\": \"bench press\",\n", " \"deadlift\": \"deadlift\",\n", " \"squat\": \"squat\",\n", " \"leg_extension\": \"leg extension\",\n", " \"push_up\": \"push up\",\n", " \"shoulder_press\": \"shoulder press\",\n", " }\n", " for norm, raw in mapping.items():\n", " src = own_root/norm\n", " dst = source_root/raw\n", " if not src.exists(): \n", " print(f\"[ingest] Skip: {src} not found\")\n", " continue\n", " dst.mkdir(parents=True, exist_ok=True)\n", " imgs = list_images(src)\n", " for p in imgs:\n", " shutil.copy2(p, dst / p.name)\n", " print(f\"[ingest] Copied {len(imgs)} from {src} -> {dst}\")\n", " print(\"[ingest] Done.\")\n", "\n" ] }, { "cell_type": "code", "execution_count": 58, "id": "b8f2fd8b", "metadata": {}, "outputs": [], "source": [ "# ============================================================\n", "# 3) DATASET SPLIT — random, stratified, non-overlapping (Option B)\n", "# No folder rewriting; we split indices in memory per class.\n", "# ============================================================\n", "def stratified_split(paths: List[Path], labels: List[int], splits=(0.70,0.15,0.15), seed=SEED):\n", " random.seed(seed)\n", " by_class = defaultdict(list)\n", " for p, y in zip(paths, labels): by_class[y].append(p)\n", " for k in by_class: random.shuffle(by_class[k])\n", "\n", " train_p, val_p, test_p = [], [], []\n", " train_y, val_y, test_y = [], [], []\n", " for y, arr in by_class.items():\n", " n = len(arr); n_train = int(n*splits[0]); n_val = int(n*splits[1])\n", " t, v, te = arr[:n_train], arr[n_train:n_train+n_val], arr[n_train+n_val:]\n", " train_p += t; val_p += v; test_p += te\n", " train_y += [y]*len(t); val_y += [y]*len(v); test_y += [y]*len(te)\n", " return (train_p, train_y), (val_p, val_y), (test_p, test_y)\n", "\n", "def gather_paths_and_labels(source: Path):\n", " class_to_idx = {name:i for i,name in enumerate(CLASSES_RAW)}\n", " all_paths, all_labels = [], []\n", " for raw_name in CLASSES_RAW:\n", " folder = source/raw_name\n", " assert folder.exists(), f\"Missing folder: {folder}\"\n", " files = list_images(folder)\n", " all_paths += files\n", " all_labels += [class_to_idx[raw_name]]*len(files)\n", " return all_paths, all_labels\n", "\n", "class SimpleImageDataset(Dataset):\n", " def __init__(self, paths: List[Path], labels: List[int], tfm):\n", " self.paths = paths; self.labels = labels; self.tfm = tfm\n", " def __len__(self): return len(self.paths)\n", " def __getitem__(self, i):\n", " img = Image.open(self.paths[i]).convert(\"RGB\")\n", " return self.tfm(img), self.labels[i]\n", "\n", "def count_per_class(labels: List[int]):\n", " from collections import Counter\n", " c = Counter(labels)\n", " return {CLASSES[i]: c.get(i,0) for i in range(len(CLASSES))}\n" ] }, { "cell_type": "code", "execution_count": 59, "id": "98339475", "metadata": {}, "outputs": [], "source": [ "# ============================================================\n", "# 4) MODEL — baseline → modern CNNs\n", "# ============================================================\n", "class LeNet5(nn.Module):\n", " def __init__(self, num_classes=3):\n", " super().__init__()\n", " self.net = nn.Sequential(\n", " nn.Conv2d(3, 6, 5, padding=2), nn.Sigmoid(), nn.AvgPool2d(2),\n", " nn.Conv2d(6,16,5), nn.Sigmoid(), nn.AvgPool2d(2),\n", " nn.Flatten(),\n", " nn.Linear(16*53*53,120), nn.Sigmoid(),\n", " nn.Linear(120,84), nn.Sigmoid(),\n", " nn.Linear(84, num_classes)\n", " )\n", " def forward(self,x): return self.net(x)\n", "\n", "def build_model(name: str, num_classes: int):\n", " n = name.lower()\n", " if n == \"lenet\":\n", " return LeNet5(num_classes)\n", " if n == \"alexnet\":\n", " m = models.alexnet(weights=models.AlexNet_Weights.IMAGENET1K_V1)\n", " m.classifier[6] = nn.Linear(m.classifier[6].in_features, num_classes); return m\n", " if n == \"vgg16\":\n", " m = models.vgg16_bn(weights=models.VGG16_BN_Weights.IMAGENET1K_V1)\n", " m.classifier[6] = nn.Linear(m.classifier[6].in_features, num_classes); return m\n", " if n == \"resnet18\":\n", " m = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1)\n", " m.fc = nn.Linear(m.fc.in_features, num_classes); return m\n", " if n == \"efficientnet_b0\":\n", " m = models.efficientnet_b0(weights=models.EfficientNet_B0_Weights.IMAGENET1K_V1)\n", " m.classifier[1] = nn.Linear(m.classifier[1].in_features, num_classes); return m\n", " raise ValueError(\"Unknown model name\")" ] }, { "cell_type": "code", "execution_count": 61, "id": "10e2f57d", "metadata": {}, "outputs": [], "source": [ "# ============================================================\n", "# 5) TRAINING — label smoothing, mixup, cosine LR (warmup), early stopping\n", "# ============================================================\n", "def mixup_data(x, y, alpha=0.4):\n", " if alpha <= 0: return x, (y,y), 1.0\n", " lam = np.random.beta(alpha, alpha)\n", " idx = torch.randperm(x.size(0), device=x.device)\n", " return lam*x + (1-lam)*x[idx], (y, y[idx]), lam\n", "\n", "def mixup_criterion(criterion, pred, targets, lam):\n", " y_a, y_b = targets\n", " return lam*criterion(pred, y_a) + (1-lam)*criterion(pred, y_b)\n", "\n", "@torch.no_grad()\n", "def evaluate(model, loader, criterion, device, split=\"Val\"):\n", " model.eval()\n", " total, correct, total_loss = 0, 0, 0.0\n", " all_preds, all_labels = [], []\n", " for imgs, labels in loader:\n", " imgs, labels = imgs.to(device), labels.to(device)\n", " with torch.cuda.amp.autocast(enabled=torch.cuda.is_available()):\n", " logits = model(imgs); loss = criterion(logits, labels)\n", " total_loss += loss.item()*imgs.size(0)\n", " preds = logits.argmax(1)\n", " correct += (preds==labels).sum().item()\n", " total += labels.numel()\n", " all_preds += preds.cpu().tolist(); all_labels += labels.cpu().tolist()\n", " acc = correct / max(1,total)\n", " print(f\"[{split}] loss={total_loss/max(1,total):.4f} acc={acc:.4f}\")\n", " return acc, all_labels, all_preds" ] }, { "cell_type": "code", "execution_count": 62, "id": "a3677dad", "metadata": {}, "outputs": [], "source": [ "# ============================================================\n", "# 6) EVALUATION — report + confusion matrix\n", "# ============================================================\n", "def plot_confusion(y_true, y_pred, filename=\"confusion_matrix_test.png\"):\n", " cm = confusion_matrix(y_true, y_pred)\n", " plt.figure(figsize=(5,4))\n", " plt.imshow(cm, interpolation='nearest')\n", " plt.title(\"Confusion Matrix (Test)\"); plt.colorbar()\n", " ticks = np.arange(len(CLASSES)); plt.xticks(ticks, CLASSES, rotation=45); plt.yticks(ticks, CLASSES)\n", " thr = cm.max()/2.0\n", " for i in range(cm.shape[0]):\n", " for j in range(cm.shape[1]):\n", " plt.text(j, i, str(cm[i,j]), ha=\"center\", va=\"center\",\n", " color=\"white\" if cm[i,j] > thr else \"black\")\n", " plt.tight_layout(); plt.ylabel(\"True\"); plt.xlabel(\"Predicted\")\n", " plt.savefig(filename, dpi=200)\n", " print(f\"Saved {filename}\")" ] }, { "cell_type": "code", "execution_count": 63, "id": "d9aac8c8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Device: cpu\n", "SOURCE: C:\\University\\Y2T1\\Computer Vision and Deep Learning\\Project\\Dataset\n", "Split sizes: {'train': 4067, 'val': 869, 'test': 879}\n", "Per-class counts:\n", " train: {'bench_press': 857, 'deadlift': 660, 'squat': 760, 'leg_extension': 611, 'push_up': 631, 'shoulder_press': 548}\n", " val : {'bench_press': 183, 'deadlift': 141, 'squat': 162, 'leg_extension': 131, 'push_up': 135, 'shoulder_press': 117}\n", " test : {'bench_press': 185, 'deadlift': 143, 'squat': 164, 'leg_extension': 132, 'push_up': 136, 'shoulder_press': 119}\n", "Downloading: \"https://download.pytorch.org/models/efficientnet_b0_rwightman-7f5810bc.pth\" to C:\\Users\\Derpi/.cache\\torch\\hub\\checkpoints\\efficientnet_b0_rwightman-7f5810bc.pth\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100.0%\n", "C:\\Users\\Derpi\\AppData\\Local\\Temp\\ipykernel_13708\\1830977947.py:46: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.\n", " scaler = torch.cuda.amp.GradScaler(enabled=torch.cuda.is_available())\n", "C:\\Users\\Derpi\\AppData\\Local\\Temp\\ipykernel_13708\\1830977947.py:56: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n", " with torch.cuda.amp.autocast(enabled=torch.cuda.is_available()):\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1 train_loss=1.0493\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\Derpi\\AppData\\Local\\Temp\\ipykernel_13708\\2923977339.py:21: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n", " with torch.cuda.amp.autocast(enabled=torch.cuda.is_available()):\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "[Val] loss=0.4874 acc=0.9908\n", " ✓ Saved sbd_best.pt (val_acc=0.9908)\n", "Epoch 2 train_loss=0.7843\n", "[Val] loss=0.4594 acc=1.0000\n", " ✓ Saved sbd_best.pt (val_acc=1.0000)\n", "Epoch 3 train_loss=0.7801\n", "[Val] loss=0.4553 acc=0.9988\n", "Epoch 4 train_loss=0.7427\n", "[Val] loss=0.4394 acc=1.0000\n", "Epoch 5 train_loss=0.7633\n", "[Val] loss=0.4472 acc=1.0000\n", "Epoch 6 train_loss=0.7335\n", "[Val] loss=0.4437 acc=1.0000\n", "Epoch 7 train_loss=0.7390\n", "[Val] loss=0.4460 acc=0.9988\n", " Early stopping.\n", "[Test] loss=0.4590 acc=0.9989\n", "\n", "Classification report (Test):\n", " precision recall f1-score support\n", "\n", " bench_press 1.0000 0.9946 0.9973 185\n", " deadlift 0.9931 1.0000 0.9965 143\n", " squat 1.0000 1.0000 1.0000 164\n", " leg_extension 1.0000 1.0000 1.0000 132\n", " push_up 1.0000 1.0000 1.0000 136\n", "shoulder_press 1.0000 1.0000 1.0000 119\n", "\n", " accuracy 0.9989 879\n", " macro avg 0.9988 0.9991 0.9990 879\n", " weighted avg 0.9989 0.9989 0.9989 879\n", "\n", "Saved confusion_matrix_test.png\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# ============================================================\n", "# MAIN — runs the flow in order\n", "# ============================================================\n", "if __name__ == \"__main__\":\n", " print(\"Device:\", DEVICE)\n", " print(\"SOURCE:\", SOURCE.resolve())\n", "\n", " # Gather all labeled images (only these 3 classes)\n", " all_paths, all_labels = gather_paths_and_labels(SOURCE)\n", "\n", " # Split (stratified, reproducible, NO overlap)\n", " (train_p, train_y), (val_p, val_y), (test_p, test_y) = stratified_split(all_paths, all_labels, (0.70,0.15,0.15))\n", " # Sanity checks\n", " def ids(xs): return set(map(lambda p: p.resolve(), xs))\n", " assert ids(train_p).isdisjoint(ids(val_p)) and ids(train_p).isdisjoint(ids(test_p)) and ids(val_p).isdisjoint(ids(test_p)), \\\n", " \"Split overlap detected!\"\n", "\n", " print(\"Split sizes:\", {\"train\": len(train_p), \"val\": len(val_p), \"test\": len(test_p)})\n", " print(\"Per-class counts:\")\n", " print(\" train:\", count_per_class(train_y))\n", " print(\" val :\", count_per_class(val_y))\n", " print(\" test :\", count_per_class(test_y))\n", "\n", " # Build datasets/loaders\n", " NUM_WORKERS = 0 \n", " PIN_MEMORY = False\n", " train_ds = SimpleImageDataset(train_p, train_y, train_tfms)\n", " val_ds = SimpleImageDataset(val_p, val_y, eval_tfms)\n", " test_ds = SimpleImageDataset(test_p, test_y, eval_tfms)\n", " train_loader = DataLoader(train_ds, batch_size=BATCH_SIZE, shuffle=True, num_workers=NUM_WORKERS)\n", " val_loader = DataLoader(val_ds, batch_size=BATCH_SIZE, shuffle=False, num_workers=NUM_WORKERS)\n", " test_loader = DataLoader(test_ds, batch_size=BATCH_SIZE, shuffle=False, num_workers=NUM_WORKERS)\n", "\n", " # Build model & training objects\n", " model = build_model(MODEL_NAME, num_classes=6).to(DEVICE)\n", " criterion = nn.CrossEntropyLoss(label_smoothing=LABEL_SMOOTHING)\n", " optimizer = optim.AdamW(model.parameters(), lr=BASE_LR, weight_decay=WEIGHT_DECAY)\n", " # cosine LR + 2-epoch warmup\n", " warmup_epochs = 2\n", " def lr_lambda(epoch):\n", " if epoch < warmup_epochs:\n", " return (epoch + 1) / warmup_epochs\n", " prog = (epoch - warmup_epochs) / max(1, (EPOCHS - warmup_epochs))\n", " return 0.1 + 0.9 * 0.5 * (1 + math.cos(math.pi * prog))\n", " scheduler = optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lr_lambda)\n", " scaler = torch.cuda.amp.GradScaler(enabled=torch.cuda.is_available())\n", "\n", " # Train with early stopping on Val Acc\n", " best_val, bad = -1, 0\n", " for epoch in range(1, EPOCHS+1):\n", " model.train()\n", " running = 0.0\n", " for imgs, labels in train_loader:\n", " imgs, labels = imgs.to(DEVICE), labels.to(DEVICE)\n", " optimizer.zero_grad(set_to_none=True)\n", " with torch.cuda.amp.autocast(enabled=torch.cuda.is_available()):\n", " if USE_MIXUP and MIXUP_ALPHA > 0:\n", " imgs, targets, lam = mixup_data(imgs, labels, MIXUP_ALPHA)\n", " logits = model(imgs)\n", " loss = mixup_criterion(criterion, logits, targets, lam)\n", " else:\n", " logits = model(imgs)\n", " loss = criterion(logits, labels)\n", " scaler.scale(loss).backward()\n", " scaler.step(optimizer); scaler.update()\n", " running += loss.item()*imgs.size(0)\n", "\n", " scheduler.step()\n", " print(f\"Epoch {epoch} train_loss={running/len(train_loader.dataset):.4f}\")\n", "\n", " val_acc, y_true, y_pred = evaluate(model, val_loader, criterion, DEVICE, \"Val\")\n", " if val_acc > best_val:\n", " best_val, bad = val_acc, 0\n", " torch.save({\"model\": model.state_dict(), \"classes\": CLASSES}, OUT_WEIGHTS)\n", " print(f\" ✓ Saved {OUT_WEIGHTS} (val_acc={best_val:.4f})\")\n", " else:\n", " bad += 1\n", " if bad >= PATIENCE:\n", " print(\" Early stopping.\")\n", " break\n", "\n", " # Final test\n", " ckpt = torch.load(OUT_WEIGHTS, map_location=DEVICE)\n", " model.load_state_dict(ckpt[\"model\"]); model.eval()\n", " test_acc, y_true, y_pred = evaluate(model, test_loader, criterion, DEVICE, \"Test\")\n", "\n", " print(\"\\nClassification report (Test):\")\n", " print(classification_report(y_true, y_pred, target_names=CLASSES, digits=4))\n", " plot_confusion(y_true, y_pred, \"confusion_matrix_test.png\")" ] }, { "cell_type": "code", "execution_count": 64, "id": "307eaa47", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Found 35 images in C:\\University\\Y2T1\\Computer Vision and Deep Learning\\Project\\test_set\n" ] } ], "source": [ "# ============================================================\n", "# TEST SINGLE IMAGE FROM TEST PATH\n", "# ============================================================\n", "import os\n", "import random\n", "from pathlib import Path\n", "import torch\n", "from PIL import Image\n", "import matplotlib.pyplot as plt\n", "\n", "# Set the test path\n", "test_path = Path(r\"C:\\University\\Y2T1\\Computer Vision and Deep Learning\\Project\\test_set\")\n", "\n", "def test_single_image(image_path, model, eval_tfms, classes, device):\n", " \"\"\"\n", " Test a single image and return prediction with confidence\n", " \"\"\"\n", " # Load and preprocess image\n", " image = Image.open(image_path).convert(\"RGB\")\n", " \n", " # Apply transforms\n", " input_tensor = eval_tfms(image).unsqueeze(0).to(device)\n", " \n", " # Make prediction\n", " model.eval()\n", " with torch.no_grad():\n", " with torch.cuda.amp.autocast(enabled=torch.cuda.is_available()):\n", " logits = model(input_tensor)\n", " probabilities = torch.softmax(logits, dim=1)\n", " confidence, predicted_class = torch.max(probabilities, 1)\n", " \n", " predicted_label = classes[predicted_class.item()]\n", " confidence_score = confidence.item()\n", " \n", " # Display results\n", " plt.figure(figsize=(8, 6))\n", " plt.imshow(image)\n", " plt.axis('off')\n", " plt.title(f'Predicted: {predicted_label} (Confidence: {confidence_score:.4f})')\n", " plt.tight_layout()\n", " plt.show()\n", " \n", " # Print all class probabilities\n", " print(f\"Image: {image_path.name}\")\n", " print(f\"Predicted Class: {predicted_label}\")\n", " print(f\"Confidence: {confidence_score:.4f}\")\n", " print(\"\\nAll class probabilities:\")\n", " for i, class_name in enumerate(classes):\n", " prob = probabilities[0][i].item()\n", " print(f\" {class_name}: {prob:.4f}\")\n", " \n", " return predicted_label, confidence_score\n", "\n", "# Load the trained model (assuming sbd_best.pt exists)\n", "if os.path.exists(OUT_WEIGHTS):\n", " # Load checkpoint\n", " ckpt = torch.load(OUT_WEIGHTS, map_location=DEVICE)\n", " \n", " # Build model with same architecture\n", " model = build_model(MODEL_NAME, num_classes=6).to(DEVICE)\n", " model.load_state_dict(ckpt[\"model\"])\n", " model.eval()\n", " \n", " # Get available image files from test path\n", " if test_path.exists():\n", " image_extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.webp']\n", " available_images = []\n", " \n", " # Search recursively for images\n", " for ext in image_extensions:\n", " available_images.extend(test_path.rglob(f'*{ext}'))\n", " #available_images.extend(test_path.rglob(f'*{ext.upper()}'))\n", " \n", " if available_images:\n", " print(f\"Found {len(available_images)} images in {test_path}\")\n", " \n", " # # Select a random image for testing\n", " # random_image = random.choice(available_images)\n", " # print(f\"Testing random image: {random_image}\")\n", " \n", " # # Test the image\n", " # predicted_label, confidence = test_single_image(\n", " # random_image, model, eval_tfms, CLASSES, DEVICE\n", " # )\n", " \n", " else:\n", " print(f\"No images found in {test_path}\")\n", " print(\"Please check if the path exists and contains image files\")\n", " \n", " else:\n", " print(f\"Test path does not exist: {test_path}\")\n", " print(\"Please verify the path is correct\")\n", " \n", "else:\n", " print(f\"Model weights file '{OUT_WEIGHTS}' not found.\")\n", " print(\"Please train the model first or ensure the weights file exists.\")\n", "\n", "# Alternative: Test specific image by name\n", "def test_specific_image(image_name):\n", " \"\"\"Test a specific image by name\"\"\"\n", " image_path = test_path / image_name\n", " if image_path.exists():\n", " predicted_label, confidence = test_single_image(\n", " image_path, model, eval_tfms, CLASSES, DEVICE\n", " )\n", " return predicted_label, confidence\n", " else:\n", " print(f\"Image {image_name} not found in {test_path}\")\n", " return None, None\n" ] }, { "cell_type": "code", "execution_count": 107, "id": "cab39a1e", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\Derpi\\AppData\\Local\\Temp\\ipykernel_13708\\3705110576.py:27: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n", " with torch.cuda.amp.autocast(enabled=torch.cuda.is_available()):\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Image: test_ohp_3.jpg\n", "Predicted Class: shoulder_press\n", "Confidence: 0.3085\n", "\n", "All class probabilities:\n", " bench_press: 0.0081\n", " deadlift: 0.0445\n", " squat: 0.2842\n", " leg_extension: 0.2620\n", " push_up: 0.0927\n", " shoulder_press: 0.3085\n" ] }, { "data": { "text/plain": [ "('shoulder_press', 0.308512806892395)" ] }, "execution_count": 107, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#test_specific_image(\"test_squat_7.jpg\")\n", "#test_specific_image(\"test_squat_8.webp\")\n", "test_specific_image(\"test_ohp_3.jpg\")" ] }, { "cell_type": "code", "execution_count": 37, "id": "58ed71b5", "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'train_losses_all_models' is not defined", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", "Cell \u001b[1;32mIn[37], line 5\u001b[0m\n\u001b[0;32m 3\u001b[0m colors \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mgreen\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[0;32m 4\u001b[0m \u001b[38;5;66;03m# Plot all the models' train and validation losses\u001b[39;00m\n\u001b[1;32m----> 5\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mtrain_losses_all_models\u001b[49m)\n\u001b[0;32m 6\u001b[0m plt\u001b[38;5;241m.\u001b[39mfigure(figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m10\u001b[39m, \u001b[38;5;241m6\u001b[39m))\n\u001b[0;32m 7\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i, model_name \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(models\u001b[38;5;241m.\u001b[39mkeys()):\n\u001b[0;32m 8\u001b[0m \u001b[38;5;66;03m# Convert train and validation losses to numpy arrays for plotting\u001b[39;00m\n\u001b[0;32m 9\u001b[0m \u001b[38;5;66;03m#print((train_losses_all_models[model_name][2][0]))\u001b[39;00m\n", "\u001b[1;31mNameError\u001b[0m: name 'train_losses_all_models' is not defined" ] } ], "source": [ "#Plot training and validation loss and accuracy\n", "\n", "colors = ['green']\n", " # Plot all the models' train and validation losses\n", "print(train_losses_all_models)\n", "plt.figure(figsize=(10, 6))\n", "for i, model_name in enumerate(models.keys()):\n", " # Convert train and validation losses to numpy arrays for plotting\n", " #print((train_losses_all_models[model_name][2][0]))\n", " flattened_train_losses=[]\n", " # Flatten the list of lists into a single list\n", " for sublist in train_losses_all_models[model_name]:\n", " flattened_train_losses.append(torch.mean(torch.tensor(sublist)).detach().cpu().numpy())\n", "\n", "\n", " flattened_val_losses = []\n", " print(val_losses_all_models)\n", " for sublist in val_losses_all_models[model_name]:\n", " flattened_val_losses.append(torch.mean(torch.tensor(sublist)).detach().cpu().numpy())\n", "\n", "# Now `flattened_train_losses` and `flattened_val_losses` are single lists that you can plot.\n", "\n", "\n", " # Ensure the losses are moved to CPU and converted to numpy arrays\n", " plt.plot(flattened_train_losses, '-', color=colors[i], label=f'{model_name} Train Loss')\n", " plt.plot(flattened_val_losses, '--', color=colors[i], label=f'{model_name} Val Loss')\n", "\n", "plt.title('Training and Validation Loss for All Models')\n", "plt.xlabel('Epoch')\n", "plt.ylabel('Loss')\n", "plt.legend()\n", "plt.grid(True)\n", "plt.show()\n", "\n" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.9" } }, "nbformat": 4, "nbformat_minor": 5 }