{ "cells": [ { "metadata": {}, "cell_type": "markdown", "source": "# Age Classification Model", "id": "49bedebca98dc3f9" }, { "metadata": {}, "cell_type": "markdown", "source": "## 1. Investigating dataset", "id": "6e7f00ae6117ea4" }, { "metadata": { "ExecuteTime": { "end_time": "2025-08-31T10:19:03.326890Z", "start_time": "2025-08-31T10:18:59.681354Z" } }, "cell_type": "code", "source": [ "from datasets import load_dataset\n", "import matplotlib.pyplot as plt\n", "import random" ], "id": "7bc7f93118a4c9d3", "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "D:\\Documents\\Personal Projects\\Age_Predictor\\.venv\\lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n" ] } ], "execution_count": 1 }, { "metadata": { "ExecuteTime": { "end_time": "2025-08-31T10:19:05.980916Z", "start_time": "2025-08-31T10:19:03.339417Z" } }, "cell_type": "code", "source": "ds = load_dataset(\"prithivMLmods/Age-Classification-Set\")", "id": "fa7acd0711ab46f4", "outputs": [], "execution_count": 2 }, { "metadata": { "ExecuteTime": { "end_time": "2025-08-31T10:19:05.995917Z", "start_time": "2025-08-31T10:19:05.986918Z" } }, "cell_type": "code", "source": [ "labels = ds[\"train\"].features[\"label\"].names\n", "label_mapping = {i: v for i, v in enumerate(labels)}\n", "label_mapping" ], "id": "4798be5f4874f592", "outputs": [ { "data": { "text/plain": [ "{0: '0-12', 1: '13-20', 2: '21-44', 3: '45-64', 4: '65+'}" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "execution_count": 3 }, { "metadata": { "ExecuteTime": { "end_time": "2025-08-31T10:20:45.518375Z", "start_time": "2025-08-31T10:20:45.505373Z" } }, "cell_type": "code", "source": [ "ds = ds[\"train\"]\n", "print(ds)\n", "print(len(ds))" ], "id": "ce4dc513c7e221c0", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dataset({\n", " features: ['image', 'label'],\n", " num_rows: 19016\n", "})\n", "19016\n" ] } ], "execution_count": 4 }, { "metadata": {}, "cell_type": "code", "source": "ds[0][\"label\"], ds[0][\"image\"]", "id": "163aabcd20d50a5f", "outputs": [], "execution_count": null }, { "metadata": {}, "cell_type": "code", "source": [ "def print_samples():\n", " fig, axes = plt.subplots(nrows=2, ncols=3, figsize=(15, 7))\n", " axes = axes.flatten()\n", " ind = random.sample(range(len(ds)), 1)[0]\n", " for ax in axes:\n", " ax.imshow(ds[ind]['image'])\n", " ax.set_title(label_mapping[ds[ind]['label']])\n", " ind = random.sample(range(len(ds)), 1)[0]\n", " plt.tight_layout() # Adjust the layout to prevent titles and labels from overlapping\n", " plt.show()\n", "print_samples()" ], "id": "4d730d25dc440787", "outputs": [], "execution_count": null }, { "metadata": {}, "cell_type": "markdown", "source": "### Structure dataset folder for YOLO", "id": "29eecd7967fc11ab" }, { "metadata": {}, "cell_type": "markdown", "source": "Split data into \"train\", \"eval\", \"test\"", "id": "c29d47b3a35dcb5a" }, { "metadata": {}, "cell_type": "markdown", "source": "First we need to find indices of each age group", "id": "47f70337e70929b9" }, { "metadata": { "ExecuteTime": { "end_time": "2025-08-31T10:22:53.361925Z", "start_time": "2025-08-31T10:22:21.683967Z" } }, "cell_type": "code", "source": [ "from tqdm import tqdm\n", "\n", "indices_by_class = {}\n", "\n", "for ind, sample in tqdm(enumerate(ds), total=len(ds), desc=\"Detecting indices of each age group\"):\n", " cls = label_mapping[sample['label']]\n", " if cls not in indices_by_class:\n", " indices_by_class[cls] = []\n", " indices_by_class[cls].append(ind)" ], "id": "4dd7a79968fd8d6", "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Detecting indices of each age group: 100%|██████████| 19016/19016 [00:31<00:00, 600.61it/s]\n" ] } ], "execution_count": 5 }, { "metadata": { "ExecuteTime": { "end_time": "2025-08-31T10:22:53.376930Z", "start_time": "2025-08-31T10:22:53.368930Z" } }, "cell_type": "code", "source": [ "for cls, indices in indices_by_class.items():\n", " print(f\"{cls}: {len(indices)} samples\")" ], "id": "26e3e3c24295096e", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0-12: 2193 samples\n", "13-20: 1779 samples\n", "21-44: 9999 samples\n", "45-64: 3785 samples\n", "65+: 1260 samples\n" ] } ], "execution_count": 6 }, { "metadata": {}, "cell_type": "markdown", "source": "Because the number of `21-44` group is exceeded, we randomly reduce the number of these images to 4000 samples (comparable to the second most class in the dataset).", "id": "b97969f053af0c4b" }, { "metadata": {}, "cell_type": "code", "source": [ "import random\n", "random.seed(42)\n", "\n", "num_sample_remain = 4000\n", "\n", "indices_by_class[\"21-44\"] = random.sample(indices_by_class[\"21-44\"], k=num_sample_remain)" ], "id": "c68dd70cd81d1ff2", "outputs": [], "execution_count": null }, { "metadata": {}, "cell_type": "code", "source": "len(indices_by_class[\"21-44\"])", "id": "e769d2571e888bc", "outputs": [], "execution_count": null }, { "metadata": {}, "cell_type": "code", "source": [ "TRAIN_RATIO = 0.8\n", "VALIDATION_RATIO = 0.1\n", "\n", "ds_indices = {\n", " 'train': [],\n", " 'val': [],\n", " 'test': []\n", "}\n", "\n", "for age, indices in indices_by_class.items():\n", " print(f\"Splitting dataset for {age} group...\")\n", "\n", " num_train_samples = int(TRAIN_RATIO * len(indices))\n", " num_validation_samples = int(VALIDATION_RATIO * len(indices))\n", "\n", " random.shuffle(indices)\n", " train_indices = indices[:num_train_samples]\n", " validation_indices = indices[num_train_samples:num_train_samples + num_validation_samples]\n", " test_indices = indices[num_train_samples + num_validation_samples:]\n", "\n", " ds_indices[\"train\"] += train_indices\n", " ds_indices[\"val\"] += validation_indices\n", " ds_indices[\"test\"] += test_indices\n", "\n", "random.shuffle(ds_indices[\"train\"])\n", "random.shuffle(ds_indices[\"val\"])\n", "random.shuffle(ds_indices[\"test\"])" ], "id": "cd898f55f8fe2b00", "outputs": [], "execution_count": null }, { "metadata": {}, "cell_type": "code", "source": [ "import os\n", "from tqdm import tqdm\n", "ROOT = \"D:\\Documents\\Personal Projects\\Age_Predictor\"\n", "DATA_ROOT = os.path.join(ROOT, \"dataset\", \"age\")\n", "os.makedirs(DATA_ROOT, exist_ok=True)\n", "\n", "for split in ['train', 'val', 'test']:\n", " split_dir = os.path.join(DATA_ROOT, split)\n", " os.makedirs(split_dir, exist_ok=True)\n", "\n", " for idx in tqdm(ds_indices[split], total=len(ds_indices[split]), desc=f\"Processing {split} split...\"):\n", " example = ds[idx]\n", " pil_image = example['image']\n", " label = label_mapping[example['label']]\n", "\n", " # Create a directory for this class if it doesn't exist\n", " class_dir = os.path.join(split_dir, label)\n", " os.makedirs(class_dir, exist_ok=True)\n", "\n", " # Save this image to the class directory\n", " image_filename = f\"{idx}_{label}.png\"\n", " image_path = os.path.join(class_dir, image_filename)\n", " pil_image.save(image_path)" ], "id": "ab395962c474a497", "outputs": [], "execution_count": null }, { "metadata": {}, "cell_type": "markdown", "source": "# 2. Setup Model and Training Configurations", "id": "94822addb71826fb" }, { "metadata": {}, "cell_type": "code", "source": [ "from ultralytics import YOLO\n", "\n", "# Load a model\n", "model = YOLO(\"yolo11n-cls.pt\")" ], "id": "72fd12606ce90294", "outputs": [], "execution_count": null }, { "metadata": {}, "cell_type": "code", "source": [ "import os\n", "ROOT = \"./\"\n", "DATA_ROOT = os.path.join(ROOT, \"dataset\", \"age\")" ], "id": "ab0b5eb9695b3dc4", "outputs": [], "execution_count": null }, { "metadata": {}, "cell_type": "code", "source": [ "# Train the model\n", "results = model.train(\n", " data=DATA_ROOT,\n", " epochs=50,\n", " imgsz=64,\n", " device=0,\n", " save=True,\n", " save_period=1, # Save checkpoint every 10 epochs\n", " project=\"Age_Detection\", # Name of the project directory where training outputs are saved.\n", " name=\"v1_epochs_10_imgsz_64\", # Name of the training run.\n", " dropout=0.1,\n", " plots=True # Generates and saves plots of training, validation metrics, and prediction examples.\n", ")\n" ], "id": "58c0d660d6058344", "outputs": [], "execution_count": null }, { "metadata": {}, "cell_type": "markdown", "source": "### Test Performance", "id": "1dbb9edb4af0bd27" }, { "metadata": { "ExecuteTime": { "end_time": "2025-08-31T10:47:23.186541Z", "start_time": "2025-08-31T10:47:20.839587Z" } }, "cell_type": "code", "source": "# !pip install scikit-learn seaborn", "id": "24230875529662bf", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: scikit-learn in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (1.7.1)\n", "Collecting seaborn\n", " Using cached seaborn-0.13.2-py3-none-any.whl.metadata (5.4 kB)\n", "Requirement already satisfied: numpy>=1.22.0 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from scikit-learn) (2.2.6)\n", "Requirement already satisfied: scipy>=1.8.0 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from scikit-learn) (1.15.3)\n", "Requirement already satisfied: joblib>=1.2.0 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from scikit-learn) (1.5.2)\n", "Requirement already satisfied: threadpoolctl>=3.1.0 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from scikit-learn) (3.6.0)\n", "Requirement already satisfied: pandas>=1.2 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from seaborn) (2.3.2)\n", "Requirement already satisfied: matplotlib!=3.6.1,>=3.4 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from seaborn) (3.10.5)\n", "Requirement already satisfied: contourpy>=1.0.1 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (1.3.2)\n", "Requirement already satisfied: cycler>=0.10 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (0.12.1)\n", "Requirement already satisfied: fonttools>=4.22.0 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (4.59.1)\n", "Requirement already satisfied: kiwisolver>=1.3.1 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (1.4.9)\n", "Requirement already satisfied: packaging>=20.0 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (25.0)\n", "Requirement already satisfied: pillow>=8 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (11.3.0)\n", "Requirement already satisfied: pyparsing>=2.3.1 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (3.2.3)\n", "Requirement already satisfied: python-dateutil>=2.7 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from matplotlib!=3.6.1,>=3.4->seaborn) (2.9.0.post0)\n", "Requirement already satisfied: pytz>=2020.1 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from pandas>=1.2->seaborn) (2025.2)\n", "Requirement already satisfied: tzdata>=2022.7 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from pandas>=1.2->seaborn) (2025.2)\n", "Requirement already satisfied: six>=1.5 in d:\\documents\\personal projects\\age_predictor\\.venv\\lib\\site-packages (from python-dateutil>=2.7->matplotlib!=3.6.1,>=3.4->seaborn) (1.17.0)\n", "Using cached seaborn-0.13.2-py3-none-any.whl (294 kB)\n", "Installing collected packages: seaborn\n", "Successfully installed seaborn-0.13.2\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n", "[notice] A new release of pip is available: 25.0.1 -> 25.2\n", "[notice] To update, run: python.exe -m pip install --upgrade pip\n" ] } ], "execution_count": 7 }, { "metadata": { "ExecuteTime": { "end_time": "2025-08-31T10:48:42.432672Z", "start_time": "2025-08-31T10:48:40.471859Z" } }, "cell_type": "code", "source": [ "from ultralytics import YOLO\n", "\n", "model_path = r\"./Age_Detection/v1_epochs_10_imgsz_64/weights/best.pt\"\n", "model = YOLO(model_path) # load a custom model" ], "id": "83e459f62cea24f7", "outputs": [], "execution_count": 10 }, { "metadata": { "ExecuteTime": { "end_time": "2025-08-31T10:50:42.200470Z", "start_time": "2025-08-31T10:50:13.391276Z" } }, "cell_type": "code", "source": [ "import os\n", "from tqdm import tqdm\n", "\n", "test_dir = os.path.join(\"../dataset\", \"age\", \"test\")\n", "ages = list(os.listdir(test_dir))\n", "\n", "results = {}\n", "for age in tqdm(ages):\n", " image_path = os.path.join(test_dir, age)\n", " results[age] = model(image_path, verbose=False)" ], "id": "782205439db613df", "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 5/5 [00:28<00:00, 5.76s/it]\n" ] } ], "execution_count": 13 }, { "metadata": { "ExecuteTime": { "end_time": "2025-08-31T10:52:53.638348Z", "start_time": "2025-08-31T10:52:53.626345Z" } }, "cell_type": "code", "source": "results[\"0-12\"][0]", "id": "8a67918d4be6808f", "outputs": [ { "data": { "text/plain": [ "ultralytics.engine.results.Results object with attributes:\n", "\n", "boxes: None\n", "keypoints: None\n", "masks: None\n", "names: {0: '0-12', 1: '13-20', 2: '21-44', 3: '45-64', 4: '65+'}\n", "obb: None\n", "orig_img: array([[[0, 0, 0],\n", " [0, 0, 0],\n", " [0, 0, 0],\n", " ...,\n", " [0, 0, 0],\n", " [0, 0, 0],\n", " [0, 0, 0]],\n", "\n", " [[0, 0, 0],\n", " [0, 0, 0],\n", " [0, 0, 0],\n", " ...,\n", " [0, 0, 0],\n", " [0, 0, 0],\n", " [0, 0, 0]],\n", "\n", " [[0, 0, 0],\n", " [0, 0, 0],\n", " [0, 0, 0],\n", " ...,\n", " [0, 0, 0],\n", " [0, 0, 0],\n", " [0, 0, 0]],\n", "\n", " ...,\n", "\n", " [[0, 0, 0],\n", " [0, 0, 0],\n", " [0, 0, 0],\n", " ...,\n", " [0, 0, 0],\n", " [0, 0, 0],\n", " [0, 0, 0]],\n", "\n", " [[0, 0, 0],\n", " [0, 0, 0],\n", " [0, 0, 0],\n", " ...,\n", " [0, 0, 0],\n", " [0, 0, 0],\n", " [0, 0, 0]],\n", "\n", " [[0, 0, 0],\n", " [0, 0, 0],\n", " [0, 0, 0],\n", " ...,\n", " [0, 0, 0],\n", " [0, 0, 0],\n", " [0, 0, 0]]], shape=(640, 640, 3), dtype=uint8)\n", "orig_shape: (640, 640)\n", "path: 'D:\\\\Documents\\\\Personal Projects\\\\Age_Predictor\\\\notebooks\\\\..\\\\dataset\\\\age\\\\test\\\\0-12\\\\1001_0-12.png'\n", "probs: ultralytics.engine.results.Probs object\n", "save_dir: None\n", "speed: {'preprocess': 3.8295999984256923, 'inference': 7.545299973571673, 'postprocess': 0.0872999953571707}" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "execution_count": 17 }, { "metadata": { "ExecuteTime": { "end_time": "2025-08-31T10:56:16.496688Z", "start_time": "2025-08-31T10:56:16.215627Z" } }, "cell_type": "code", "source": [ "images = []\n", "true_labels = []\n", "predicted_labels = []\n", "\n", "mapping = results[\"0-12\"][0].names\n", "\n", "for age in ages:\n", " for result in results[age]:\n", " img_path = result.path\n", "\n", " img_name = os.path.basename(img_path)\n", " images.append(img_name)\n", "\n", " true_label = img_name.split(\"_\")[-1].split(\".\")[0]\n", " true_labels.append(true_label)\n", "\n", " label_index = result.probs.top1\n", " predicted_label = mapping[label_index]\n", " predicted_labels.append(predicted_label)" ], "id": "a0889abe317861c1", "outputs": [], "execution_count": 18 }, { "metadata": { "ExecuteTime": { "end_time": "2025-08-31T10:58:45.347150Z", "start_time": "2025-08-31T10:58:43.035241Z" } }, "cell_type": "code", "source": [ "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "%matplotlib inline\n", "\n", "class_names = list(mapping.values())\n", "\n", "# Accuracy is a great top-level metric to see overall correctness.\n", "accuracy = accuracy_score(true_labels, predicted_labels)\n", "print(f\"\\nOverall Model Accuracy: {accuracy:.4f}\")\n", "\n", "# A classification report provides a more detailed breakdown per class.\n", "# It shows precision, recall, and F1-score for each class.\n", "print(\"\\n--- Classification Report ---\")\n", "print(classification_report(true_labels, predicted_labels, target_names=class_names))\n", "\n", "# --- Step 3: Visualize with a Confusion Matrix ---\n", "# The confusion matrix provides a visual representation of the performance.\n", "# Each row represents the true class, and each column represents the predicted class.\n", "# This helps identify which classes the model is confusing with others.\n", "print(\"\\nGenerating Confusion Matrix...\")\n", "cm = confusion_matrix(true_labels, predicted_labels)\n", "\n", "plt.figure(figsize=(10, 8))\n", "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=class_names, yticklabels=class_names)\n", "plt.title('Confusion Matrix')\n", "plt.ylabel('True Label')\n", "plt.xlabel('Predicted Label')\n", "plt.show()\n", "\n", "print(\"\\n--- Evaluation Complete ---\")" ], "id": "fa6a27106dfd86c9", "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Overall Model Accuracy: 0.7914\n", "\n", "--- Classification Report ---\n", " precision recall f1-score support\n", "\n", " 0-12 0.89 0.95 0.92 220\n", " 13-20 0.69 0.61 0.65 179\n", " 21-44 0.77 0.75 0.76 400\n", " 45-64 0.79 0.82 0.80 379\n", " 65+ 0.78 0.83 0.80 126\n", "\n", " accuracy 0.79 1304\n", " macro avg 0.79 0.79 0.79 1304\n", "weighted avg 0.79 0.79 0.79 1304\n", "\n", "\n", "Generating Confusion Matrix...\n" ] }, { "data": { "text/plain": [ "
" ], "image/png": "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" }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "--- Evaluation Complete ---\n" ] } ], "execution_count": 19 }, { "metadata": {}, "cell_type": "code", "source": [ "from tqdm import tqdm\n", "\n", "corrects = {age: 0 for age in ages}\n", "total = {age: len(os.listdir(os.path.join(test_dir, age))) for age in ages}\n", "\n", "mapping = results[\"0-12\"][0].names\n", "\n", "for age in ages:\n", " for result in tqdm(results[age], total=total[age], desc=f\"Calculating accuracy for {age} group...\"):\n", " label_index = result.probs.top1\n", " label = mapping[label_index]\n", " if label == age:\n", " corrects[age] += 1\n", " print(f\"{age}: {corrects[age]}/{total[age]} - {corrects[age]/total[age] * 100:.2f}%\")\n" ], "id": "c3524a8dc5024372", "outputs": [], "execution_count": null } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.6" } }, "nbformat": 4, "nbformat_minor": 5 }