diff --git a/.gitignore b/.gitignore index cef4d1919..7f84be7ad 100644 --- a/.gitignore +++ b/.gitignore @@ -307,7 +307,7 @@ MLEnv/ **/cifar-100-python/ **/cifar-100-python.tar.gz **/data/ -**/sample_images/ +# **/sample_images/ # PyTorch model checkpoints **/*.pth diff --git a/advanced/slides/rl.pdf b/advanced/slides/rl.pdf index 9929aae15..45498d99a 100644 Binary files a/advanced/slides/rl.pdf and b/advanced/slides/rl.pdf differ diff --git a/imagenet_samples/banana_1.jpg b/imagenet_samples/banana_1.jpg new file mode 100644 index 000000000..9f392ec49 Binary files /dev/null and b/imagenet_samples/banana_1.jpg differ diff --git a/imagenet_samples/beagle_1.jpg b/imagenet_samples/beagle_1.jpg new file mode 100644 index 000000000..3134d517c Binary files /dev/null and b/imagenet_samples/beagle_1.jpg differ diff --git a/imagenet_samples/bear_1.jpg b/imagenet_samples/bear_1.jpg new file mode 100644 index 000000000..6238b812a Binary files /dev/null and b/imagenet_samples/bear_1.jpg differ diff --git a/imagenet_samples/corgi_1.jpg b/imagenet_samples/corgi_1.jpg new file mode 100644 index 000000000..0f28a6077 Binary files /dev/null and b/imagenet_samples/corgi_1.jpg differ diff --git a/imagenet_samples/elephant_1.jpg b/imagenet_samples/elephant_1.jpg new file mode 100644 index 000000000..44a3b980a Binary files /dev/null and b/imagenet_samples/elephant_1.jpg differ diff --git a/imagenet_samples/german_shepherd_1.jpg b/imagenet_samples/german_shepherd_1.jpg new file mode 100644 index 000000000..eefe9c6fa Binary files /dev/null and b/imagenet_samples/german_shepherd_1.jpg differ diff --git a/imagenet_samples/golden_retriever_1.jpg b/imagenet_samples/golden_retriever_1.jpg new file mode 100644 index 000000000..f08d948b4 Binary files /dev/null and b/imagenet_samples/golden_retriever_1.jpg differ diff --git a/imagenet_samples/golden_retriever_2.jpg b/imagenet_samples/golden_retriever_2.jpg new file mode 100644 index 000000000..e79ce6e69 Binary files /dev/null and b/imagenet_samples/golden_retriever_2.jpg differ diff --git a/imagenet_samples/ice_cream_1.jpg b/imagenet_samples/ice_cream_1.jpg new file mode 100644 index 000000000..39ef60327 Binary files /dev/null and b/imagenet_samples/ice_cream_1.jpg differ diff --git a/imagenet_samples/metadata.json b/imagenet_samples/metadata.json new file mode 100644 index 000000000..428dab5e8 --- /dev/null +++ b/imagenet_samples/metadata.json @@ -0,0 +1,98 @@ +{ + "tabby_cat_1": { + "class_idx": 281, + "class_name": "tabby cat" + }, + "tabby_cat_2": { + "class_idx": 281, + "class_name": "tabby cat" + }, + "persian_cat_1": { + "class_idx": 283, + "class_name": "persian cat" + }, + "siamese_cat_1": { + "class_idx": 284, + "class_name": "siamese cat" + }, + "golden_retriever_1": { + "class_idx": 207, + "class_name": "golden retriever" + }, + "golden_retriever_2": { + "class_idx": 207, + "class_name": "golden retriever" + }, + "german_shepherd_1": { + "class_idx": 235, + "class_name": "german shepherd" + }, + "beagle_1": { + "class_idx": 162, + "class_name": "beagle" + }, + "corgi_1": { + "class_idx": 263, + "class_name": "pembroke corgi" + }, + "robin_1": { + "class_idx": 15, + "class_name": "robin" + }, + "pizza_1": { + "class_idx": 963, + "class_name": "pizza" + }, + "pizza_2": { + "class_idx": 963, + "class_name": "pizza" + }, + "strawberry_1": { + "class_idx": 949, + "class_name": "strawberry" + }, + "banana_1": { + "class_idx": 954, + "class_name": "banana" + }, + "ice_cream_1": { + "class_idx": 928, + "class_name": "ice cream" + }, + "elephant_1": { + "class_idx": 386, + "class_name": "african elephant" + }, + "zebra_1": { + "class_idx": 340, + "class_name": "zebra" + }, + "tiger_1": { + "class_idx": 292, + "class_name": "tiger" + }, + "panda_1": { + "class_idx": 388, + "class_name": "giant panda" + }, + "bear_1": { + "class_idx": 294, + "class_name": "brown bear" + }, + "spurious_husky_indoor": { + "class_idx": 250, + "class_name": "SPURIOUS: siberian husky" + }, + "spurious_horse_beach": { + "class_idx": 340, + "class_name": "SPURIOUS: sorrel horse" + }, + "spurious_cow_field": { + "class_idx": 345, + "class_name": "SPURIOUS: ox" + }, + "spurious_robin_ground": { + "class_idx": 15, + "class_name": "SPURIOUS: robin" + } +} \ No newline at end of file diff --git a/imagenet_samples/panda_1.jpg b/imagenet_samples/panda_1.jpg new file mode 100644 index 000000000..a972cebaa Binary files /dev/null and b/imagenet_samples/panda_1.jpg differ diff --git a/imagenet_samples/persian_cat_1.jpg b/imagenet_samples/persian_cat_1.jpg new file mode 100644 index 000000000..7c3392455 Binary files /dev/null and b/imagenet_samples/persian_cat_1.jpg differ diff --git a/imagenet_samples/pizza_1.jpg b/imagenet_samples/pizza_1.jpg new file mode 100644 index 000000000..405b7bb3f Binary files /dev/null and b/imagenet_samples/pizza_1.jpg differ diff --git a/imagenet_samples/pizza_2.jpg b/imagenet_samples/pizza_2.jpg new file mode 100644 index 000000000..fb872ad3b Binary files /dev/null and b/imagenet_samples/pizza_2.jpg differ diff --git a/imagenet_samples/robin_1.jpg b/imagenet_samples/robin_1.jpg new file mode 100644 index 000000000..0be4b1cde Binary files /dev/null and b/imagenet_samples/robin_1.jpg differ diff --git a/imagenet_samples/siamese_cat_1.jpg b/imagenet_samples/siamese_cat_1.jpg new file mode 100644 index 000000000..11c499891 Binary files /dev/null and b/imagenet_samples/siamese_cat_1.jpg differ diff --git a/imagenet_samples/spurious_cow_field.jpg b/imagenet_samples/spurious_cow_field.jpg new file mode 100644 index 000000000..f8234ca82 Binary files /dev/null and b/imagenet_samples/spurious_cow_field.jpg differ diff --git a/imagenet_samples/spurious_horse_beach.jpg b/imagenet_samples/spurious_horse_beach.jpg new file mode 100644 index 000000000..23c828392 Binary files /dev/null and b/imagenet_samples/spurious_horse_beach.jpg differ diff --git a/imagenet_samples/spurious_husky_indoor.jpg b/imagenet_samples/spurious_husky_indoor.jpg new file mode 100644 index 000000000..8b6326a34 Binary files /dev/null and b/imagenet_samples/spurious_husky_indoor.jpg differ diff --git a/imagenet_samples/spurious_robin_ground.jpg b/imagenet_samples/spurious_robin_ground.jpg new file mode 100644 index 000000000..0be4b1cde Binary files /dev/null and b/imagenet_samples/spurious_robin_ground.jpg differ diff --git a/imagenet_samples/strawberry_1.jpg b/imagenet_samples/strawberry_1.jpg new file mode 100644 index 000000000..de1f91cec Binary files /dev/null and b/imagenet_samples/strawberry_1.jpg differ diff --git a/imagenet_samples/tabby_cat_1.jpg b/imagenet_samples/tabby_cat_1.jpg new file mode 100644 index 000000000..dec2af243 Binary files /dev/null and b/imagenet_samples/tabby_cat_1.jpg differ diff --git a/imagenet_samples/tabby_cat_2.jpg b/imagenet_samples/tabby_cat_2.jpg new file mode 100644 index 000000000..37e1087dd Binary files /dev/null and b/imagenet_samples/tabby_cat_2.jpg differ diff --git a/imagenet_samples/tiger_1.jpg b/imagenet_samples/tiger_1.jpg new file mode 100644 index 000000000..4e03c024d Binary files /dev/null and b/imagenet_samples/tiger_1.jpg differ diff --git a/imagenet_samples/zebra_1.jpg b/imagenet_samples/zebra_1.jpg new file mode 100644 index 000000000..5aa1b347d Binary files /dev/null and b/imagenet_samples/zebra_1.jpg differ diff --git a/notebooks.qmd b/notebooks.qmd index 5d9e9068e..1e3d1cfab 100644 --- a/notebooks.qmd +++ b/notebooks.qmd @@ -118,6 +118,8 @@ Interactive notebooks provide practical coding examples and visualizations to co - [Feature Selection](notebooks/sfs-and-bfs.ipynb) - Forward/backward selection - [Sklearn on GPU](notebooks/sklearn-on-gpu.ipynb) - Performance optimization - [Zero/Few Shot Learning](notebooks/zeroshot-fewshot.ipynb) - Modern ML paradigms +- [DinoV3 Classification](notebooks/dinov3-classification.ipynb) - Foundation models for vision +- [DinoV3 Regression](notebooks/dinov3-regression.ipynb) - Foundation models for vision ### Special Applications diff --git a/notebooks/dinov3-classification.ipynb b/notebooks/dinov3-classification.ipynb new file mode 100644 index 000000000..66a9ea035 --- /dev/null +++ b/notebooks/dinov3-classification.ipynb @@ -0,0 +1,681 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Tutorial on **Image Classification Using Dino-v3**" + ], + "metadata": { + "id": "vPlz0gO26Hjb" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 1. Imports and Device" + ], + "metadata": { + "id": "B-sn8vz3SntT" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "065Tp5It6GaQ", + "outputId": "f135c49c-f30a-4f56-e6cb-0e1bc527692c" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: timm==1.0.20 in /usr/local/lib/python3.12/dist-packages (1.0.20)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.12/dist-packages (0.23.0+cu126)\n", + "Collecting torchvision\n", + " Downloading torchvision-0.24.0-cp312-cp312-manylinux_2_28_x86_64.whl.metadata (5.9 kB)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.12/dist-packages (3.10.0)\n", + "Collecting matplotlib\n", + " Downloading matplotlib-3.10.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (11 kB)\n", + "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.12/dist-packages (1.6.1)\n", + "Collecting scikit-learn\n", + " Downloading scikit_learn-1.7.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (11 kB)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.12/dist-packages (from timm==1.0.20) (2.8.0+cu126)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.12/dist-packages (from timm==1.0.20) (6.0.3)\n", + "Requirement already satisfied: huggingface_hub in /usr/local/lib/python3.12/dist-packages (from timm==1.0.20) (0.35.3)\n", + "Requirement already satisfied: safetensors in /usr/local/lib/python3.12/dist-packages (from timm==1.0.20) (0.6.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.12/dist-packages (from torchvision) (2.0.2)\n", + "Collecting torch (from timm==1.0.20)\n", + " Downloading torch-2.9.0-cp312-cp312-manylinux_2_28_x86_64.whl.metadata (30 kB)\n", + "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.12/dist-packages (from torchvision) (11.3.0)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.12/dist-packages (from torch->timm==1.0.20) (3.20.0)\n", + "Requirement already satisfied: typing-extensions>=4.10.0 in /usr/local/lib/python3.12/dist-packages (from torch->timm==1.0.20) (4.15.0)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.12/dist-packages (from torch->timm==1.0.20) (75.2.0)\n", + "Requirement already satisfied: sympy>=1.13.3 in /usr/local/lib/python3.12/dist-packages (from torch->timm==1.0.20) (1.13.3)\n", + "Requirement already satisfied: networkx>=2.5.1 in /usr/local/lib/python3.12/dist-packages (from torch->timm==1.0.20) (3.5)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.12/dist-packages (from torch->timm==1.0.20) (3.1.6)\n", + "Requirement already satisfied: fsspec>=0.8.5 in /usr/local/lib/python3.12/dist-packages (from torch->timm==1.0.20) (2025.3.0)\n", + "Collecting nvidia-cuda-nvrtc-cu12==12.8.93 (from torch->timm==1.0.20)\n", + " Downloading nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl.metadata (1.7 kB)\n", + "Collecting nvidia-cuda-runtime-cu12==12.8.90 (from torch->timm==1.0.20)\n", + " Downloading nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (1.7 kB)\n", + "Collecting nvidia-cuda-cupti-cu12==12.8.90 (from torch->timm==1.0.20)\n", + " Downloading nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (1.7 kB)\n", + "Requirement already satisfied: nvidia-cudnn-cu12==9.10.2.21 in /usr/local/lib/python3.12/dist-packages (from torch->timm==1.0.20) (9.10.2.21)\n", + "Collecting nvidia-cublas-cu12==12.8.4.1 (from torch->timm==1.0.20)\n", + " Downloading nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_x86_64.whl.metadata (1.7 kB)\n", + "Collecting nvidia-cufft-cu12==11.3.3.83 (from torch->timm==1.0.20)\n", + " Downloading nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (1.7 kB)\n", + "Collecting nvidia-curand-cu12==10.3.9.90 (from torch->timm==1.0.20)\n", + " Downloading nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_x86_64.whl.metadata (1.7 kB)\n", + "Collecting nvidia-cusolver-cu12==11.7.3.90 (from torch->timm==1.0.20)\n", + " Downloading nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_x86_64.whl.metadata (1.8 kB)\n", + "Collecting nvidia-cusparse-cu12==12.5.8.93 (from torch->timm==1.0.20)\n", + " Downloading nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (1.8 kB)\n", + "Requirement already satisfied: nvidia-cusparselt-cu12==0.7.1 in /usr/local/lib/python3.12/dist-packages (from torch->timm==1.0.20) (0.7.1)\n", + "Collecting nvidia-nccl-cu12==2.27.5 (from torch->timm==1.0.20)\n", + " Downloading nvidia_nccl_cu12-2.27.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (2.0 kB)\n", + "Collecting nvidia-nvshmem-cu12==3.3.20 (from torch->timm==1.0.20)\n", + " Downloading nvidia_nvshmem_cu12-3.3.20-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (2.1 kB)\n", + "Collecting nvidia-nvtx-cu12==12.8.90 (from torch->timm==1.0.20)\n", + " Downloading nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (1.8 kB)\n", + "Collecting nvidia-nvjitlink-cu12==12.8.93 (from torch->timm==1.0.20)\n", + " Downloading nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl.metadata (1.7 kB)\n", + "Collecting nvidia-cufile-cu12==1.13.1.3 (from torch->timm==1.0.20)\n", + " Downloading nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl.metadata (1.7 kB)\n", + "Collecting triton==3.5.0 (from torch->timm==1.0.20)\n", + " Downloading triton-3.5.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl.metadata (1.7 kB)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.3.3)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (4.60.1)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.4.9)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (25.0)\n", + "Requirement already satisfied: pyparsing>=3 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (3.2.5)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (2.9.0.post0)\n", + "Requirement already satisfied: scipy>=1.8.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (1.16.2)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (1.5.2)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn) (3.6.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.12/dist-packages (from huggingface_hub->timm==1.0.20) (2.32.4)\n", + "Requirement already satisfied: tqdm>=4.42.1 in /usr/local/lib/python3.12/dist-packages (from huggingface_hub->timm==1.0.20) (4.67.1)\n", + "Requirement already satisfied: hf-xet<2.0.0,>=1.1.3 in /usr/local/lib/python3.12/dist-packages (from huggingface_hub->timm==1.0.20) (1.1.10)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.12/dist-packages (from sympy>=1.13.3->torch->timm==1.0.20) (1.3.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.12/dist-packages (from jinja2->torch->timm==1.0.20) (3.0.3)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests->huggingface_hub->timm==1.0.20) (3.4.4)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests->huggingface_hub->timm==1.0.20) (3.11)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests->huggingface_hub->timm==1.0.20) (2.5.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/dist-packages (from requests->huggingface_hub->timm==1.0.20) (2025.10.5)\n", + "Downloading torchvision-0.24.0-cp312-cp312-manylinux_2_28_x86_64.whl (8.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m8.1/8.1 MB\u001b[0m \u001b[31m96.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading torch-2.9.0-cp312-cp312-manylinux_2_28_x86_64.whl (899.7 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m899.7/899.7 MB\u001b[0m \u001b[31m1.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_x86_64.whl (594.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m594.3/594.3 MB\u001b[0m \u001b[31m2.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (10.2 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.2/10.2 MB\u001b[0m \u001b[31m164.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl (88.0 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m88.0/88.0 MB\u001b[0m \u001b[31m9.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (954 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m954.8/954.8 kB\u001b[0m \u001b[31m72.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (193.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m193.1/193.1 MB\u001b[0m \u001b[31m6.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (1.2 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.2/1.2 MB\u001b[0m \u001b[31m89.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_x86_64.whl (63.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m63.6/63.6 MB\u001b[0m \u001b[31m13.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_x86_64.whl (267.5 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m267.5/267.5 MB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (288.2 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m288.2/288.2 MB\u001b[0m \u001b[31m3.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_nccl_cu12-2.27.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (322.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m322.3/322.3 MB\u001b[0m \u001b[31m2.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl (39.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m39.3/39.3 MB\u001b[0m \u001b[31m59.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_nvshmem_cu12-3.3.20-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (124.7 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m124.7/124.7 MB\u001b[0m \u001b[31m7.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (89 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m90.0/90.0 kB\u001b[0m \u001b[31m9.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading triton-3.5.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (170.5 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m170.5/170.5 MB\u001b[0m \u001b[31m6.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading matplotlib-3.10.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (8.7 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m8.7/8.7 MB\u001b[0m \u001b[31m164.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading scikit_learn-1.7.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (9.5 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m9.5/9.5 MB\u001b[0m \u001b[31m163.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: triton, nvidia-nvtx-cu12, nvidia-nvshmem-cu12, nvidia-nvjitlink-cu12, nvidia-nccl-cu12, nvidia-curand-cu12, nvidia-cufile-cu12, nvidia-cuda-runtime-cu12, nvidia-cuda-nvrtc-cu12, nvidia-cuda-cupti-cu12, nvidia-cublas-cu12, scikit-learn, nvidia-cusparse-cu12, nvidia-cufft-cu12, matplotlib, nvidia-cusolver-cu12, torch, torchvision\n", + " Attempting uninstall: triton\n", + " Found existing installation: triton 3.4.0\n", + " Uninstalling triton-3.4.0:\n", + " Successfully uninstalled triton-3.4.0\n", + " Attempting uninstall: nvidia-nvtx-cu12\n", + " Found existing installation: nvidia-nvtx-cu12 12.6.77\n", + " Uninstalling nvidia-nvtx-cu12-12.6.77:\n", + " Successfully uninstalled nvidia-nvtx-cu12-12.6.77\n", + " Attempting uninstall: nvidia-nvshmem-cu12\n", + " Found existing installation: nvidia-nvshmem-cu12 3.4.5\n", + " Uninstalling nvidia-nvshmem-cu12-3.4.5:\n", + " Successfully uninstalled nvidia-nvshmem-cu12-3.4.5\n", + " Attempting uninstall: nvidia-nvjitlink-cu12\n", + " Found existing installation: nvidia-nvjitlink-cu12 12.6.85\n", + " Uninstalling nvidia-nvjitlink-cu12-12.6.85:\n", + " Successfully uninstalled nvidia-nvjitlink-cu12-12.6.85\n", + " Attempting uninstall: nvidia-nccl-cu12\n", + " Found existing installation: nvidia-nccl-cu12 2.27.3\n", + " Uninstalling nvidia-nccl-cu12-2.27.3:\n", + " Successfully uninstalled nvidia-nccl-cu12-2.27.3\n", + " Attempting uninstall: nvidia-curand-cu12\n", + " Found existing installation: nvidia-curand-cu12 10.3.7.77\n", + " Uninstalling nvidia-curand-cu12-10.3.7.77:\n", + " Successfully uninstalled nvidia-curand-cu12-10.3.7.77\n", + " Attempting uninstall: nvidia-cufile-cu12\n", + " Found existing installation: nvidia-cufile-cu12 1.11.1.6\n", + " Uninstalling nvidia-cufile-cu12-1.11.1.6:\n", + " Successfully uninstalled nvidia-cufile-cu12-1.11.1.6\n", + " Attempting uninstall: nvidia-cuda-runtime-cu12\n", + " Found existing installation: nvidia-cuda-runtime-cu12 12.6.77\n", + " Uninstalling nvidia-cuda-runtime-cu12-12.6.77:\n", + " Successfully uninstalled nvidia-cuda-runtime-cu12-12.6.77\n", + " Attempting uninstall: nvidia-cuda-nvrtc-cu12\n", + " Found existing installation: nvidia-cuda-nvrtc-cu12 12.6.77\n", + " Uninstalling nvidia-cuda-nvrtc-cu12-12.6.77:\n", + " Successfully uninstalled nvidia-cuda-nvrtc-cu12-12.6.77\n", + " Attempting uninstall: nvidia-cuda-cupti-cu12\n", + " Found existing installation: nvidia-cuda-cupti-cu12 12.6.80\n", + " Uninstalling nvidia-cuda-cupti-cu12-12.6.80:\n", + " Successfully uninstalled nvidia-cuda-cupti-cu12-12.6.80\n", + " Attempting uninstall: nvidia-cublas-cu12\n", + " Found existing installation: nvidia-cublas-cu12 12.6.4.1\n", + " Uninstalling nvidia-cublas-cu12-12.6.4.1:\n", + " Successfully uninstalled nvidia-cublas-cu12-12.6.4.1\n", + " Attempting uninstall: scikit-learn\n", + " Found existing installation: scikit-learn 1.6.1\n", + " Uninstalling scikit-learn-1.6.1:\n", + " Successfully uninstalled scikit-learn-1.6.1\n", + " Attempting uninstall: nvidia-cusparse-cu12\n", + " Found existing installation: nvidia-cusparse-cu12 12.5.4.2\n", + " Uninstalling nvidia-cusparse-cu12-12.5.4.2:\n", + " Successfully uninstalled nvidia-cusparse-cu12-12.5.4.2\n", + " Attempting uninstall: nvidia-cufft-cu12\n", + " Found existing installation: nvidia-cufft-cu12 11.3.0.4\n", + " Uninstalling nvidia-cufft-cu12-11.3.0.4:\n", + " Successfully uninstalled nvidia-cufft-cu12-11.3.0.4\n", + " Attempting uninstall: matplotlib\n", + " Found existing installation: matplotlib 3.10.0\n", + " Uninstalling matplotlib-3.10.0:\n", + " Successfully uninstalled matplotlib-3.10.0\n", + " Attempting uninstall: nvidia-cusolver-cu12\n", + " Found existing installation: nvidia-cusolver-cu12 11.7.1.2\n", + " Uninstalling nvidia-cusolver-cu12-11.7.1.2:\n", + " Successfully uninstalled nvidia-cusolver-cu12-11.7.1.2\n", + " Attempting uninstall: torch\n", + " Found existing installation: torch 2.8.0+cu126\n", + " Uninstalling torch-2.8.0+cu126:\n", + " Successfully uninstalled torch-2.8.0+cu126\n", + " Attempting uninstall: torchvision\n", + " Found existing installation: torchvision 0.23.0+cu126\n", + " Uninstalling torchvision-0.23.0+cu126:\n", + " Successfully uninstalled torchvision-0.23.0+cu126\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "torchaudio 2.8.0+cu126 requires torch==2.8.0, but you have torch 2.9.0 which is incompatible.\n", + "fastai 2.8.4 requires torch<2.9,>=1.10, but you have torch 2.9.0 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed matplotlib-3.10.7 nvidia-cublas-cu12-12.8.4.1 nvidia-cuda-cupti-cu12-12.8.90 nvidia-cuda-nvrtc-cu12-12.8.93 nvidia-cuda-runtime-cu12-12.8.90 nvidia-cufft-cu12-11.3.3.83 nvidia-cufile-cu12-1.13.1.3 nvidia-curand-cu12-10.3.9.90 nvidia-cusolver-cu12-11.7.3.90 nvidia-cusparse-cu12-12.5.8.93 nvidia-nccl-cu12-2.27.5 nvidia-nvjitlink-cu12-12.8.93 nvidia-nvshmem-cu12-3.3.20 nvidia-nvtx-cu12-12.8.90 scikit-learn-1.7.2 torch-2.9.0 torchvision-0.24.0 triton-3.5.0\n" + ] + }, + { + "output_type": "display_data", + "data": { + "application/vnd.colab-display-data+json": { + "pip_warning": { + "packages": [ + "matplotlib", + "mpl_toolkits" + ] + }, + "id": "f774a09cff9f491ba062fa0e9a22f964" + } + }, + "metadata": {} + } + ], + "source": [ + "!pip install timm==1.0.20 torchvision matplotlib scikit-learn --upgrade" + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import timm\n", + "from torchvision import datasets, transforms\n", + "from torch.utils.data import DataLoader, Subset\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n", + "import torch.nn.functional as F" + ], + "metadata": { + "id": "ERQlVSAI6KhD" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 2 Data: CIFAR-10 setup" + ], + "metadata": { + "id": "12KksRJxSspk" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "transform_train = transforms.Compose([\n", + " transforms.Resize(224),\n", + " transforms.RandomHorizontalFlip(),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n", + "])\n", + "transform_test = transforms.Compose([\n", + " transforms.Resize(224),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "\n", + "train_ds = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)\n", + "val_ds = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)\n", + "subset_size = 500\n", + "subset_indices = np.random.choice(len(val_ds), subset_size, replace=False)\n", + "val_subset = Subset(val_ds, subset_indices)\n", + "\n", + "train_loader = DataLoader(train_ds, batch_size=64, shuffle=True, num_workers=4)\n", + "val_loader = DataLoader(val_ds, batch_size=128, shuffle=False, num_workers=4)\n", + "val_subset_loader = DataLoader(val_subset, batch_size=128, shuffle=False, num_workers=2)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "yDrgQ9wc6UUd", + "outputId": "a8f45b5c-a4d3-42e2-a648-efdb0c427329" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 170M/170M [00:05<00:00, 29.1MB/s]\n", + "/usr/local/lib/python3.12/dist-packages/torch/utils/data/dataloader.py:627: UserWarning: This DataLoader will create 4 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", + " warnings.warn(\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "classes = train_ds.classes\n", + "fig, axes = plt.subplots(1, 10, figsize=(12, 3))\n", + "for i in range(10):\n", + " img, label = train_ds[i]\n", + " img_show = img.permute(1, 2, 0).numpy()\n", + " img_show = np.clip((img_show * np.array([0.229, 0.224, 0.225])) + np.array([0.485, 0.456, 0.406]), 0, 1)\n", + " axes[i].imshow(img_show)\n", + " axes[i].set_title(classes[label])\n", + " axes[i].axis('off')\n", + "plt.suptitle('Sample CIFAR-10 Images')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 221 + }, + "id": "4X4X1Deg6Y0Q", + "outputId": "fa58878b-95b0-4060-ec3f-7ef20c183bca" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 3 Model: timm DINOv3 backbone" + ], + "metadata": { + "id": "R3N_a_PdS2XV" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "backbone_name = 'vit_base_patch16_dinov3'\n", + "backbone = timm.create_model(backbone_name, pretrained=True, num_classes=0, global_pool='avg')\n", + "\n", + "\n", + "class DinoClassifier(nn.Module):\n", + " def __init__(self, backbone, num_classes=10):\n", + " super().__init__()\n", + " self.backbone = backbone\n", + " feat_dim = backbone.num_features\n", + " self.head = nn.Linear(feat_dim, num_classes)\n", + "\n", + "\n", + " def forward(self, x):\n", + " x = self.backbone(x)\n", + " x = self.head(x)\n", + " return x\n", + "\n", + "\n", + "model = DinoClassifier(backbone, num_classes=10)\n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "model = model.to(device)" + ], + "metadata": { + "id": "sIE79DIh6eH4" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(model)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zW9Q5ep7HtaS", + "outputId": "fe9a8801-c21b-4f85-86a2-7ae8a2d72924" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "DinoClassifier(\n", + " (backbone): Eva(\n", + " (patch_embed): PatchEmbed(\n", + " (proj): Conv2d(3, 768, kernel_size=(16, 16), stride=(16, 16))\n", + " (norm): Identity()\n", + " )\n", + " (pos_drop): Dropout(p=0.0, inplace=False)\n", + " (rope): RotaryEmbeddingDinoV3()\n", + " (norm_pre): Identity()\n", + " (blocks): ModuleList(\n", + " (0-11): 12 x EvaBlock(\n", + " (norm1): LayerNorm((768,), eps=1e-05, elementwise_affine=True)\n", + " (attn): EvaAttention(\n", + " (qkv): Linear(in_features=768, out_features=2304, bias=False)\n", + " (q_norm): Identity()\n", + " (k_norm): Identity()\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (norm): Identity()\n", + " (proj): Linear(in_features=768, out_features=768, bias=True)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path1): Identity()\n", + " (norm2): LayerNorm((768,), eps=1e-05, elementwise_affine=True)\n", + " (mlp): Mlp(\n", + " (fc1): Linear(in_features=768, out_features=3072, bias=True)\n", + " (act): GELU(approximate='none')\n", + " (drop1): Dropout(p=0.0, inplace=False)\n", + " (norm): Identity()\n", + " (fc2): Linear(in_features=3072, out_features=768, bias=True)\n", + " (drop2): Dropout(p=0.0, inplace=False)\n", + " )\n", + " (drop_path2): Identity()\n", + " )\n", + " )\n", + " (norm): LayerNorm((768,), eps=1e-05, elementwise_affine=True)\n", + " (fc_norm): Identity()\n", + " (head_drop): Dropout(p=0.0, inplace=False)\n", + " (head): Identity()\n", + " )\n", + " (head): Linear(in_features=768, out_features=10, bias=True)\n", + ")\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "**Image → Split into (16x16) patches →\n", + " Patch Embedding (Conv2d, 768d)\n", + " → Positional Encoding (RoPE)\n", + " → 12 Transformer Layers (Feature Extraction)\n", + " → Normalization\n", + " → Classifier (Linear → 10 Classes)**" + ], + "metadata": { + "id": "Jg4RSUOjTJOm" + } + }, + { + "cell_type": "code", + "source": [ + "# Freeze backbone for faster linear probing\n", + "for param in model.backbone.parameters():\n", + " param.requires_grad = False" + ], + "metadata": { + "id": "dEP_FyRtMPMN" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "criterion = nn.CrossEntropyLoss()\n", + "optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-2)\n", + "\n", + "\n", + "def evaluate(model, loader, title):\n", + " model.eval()\n", + " all_preds, all_labels = [], []\n", + " with torch.no_grad():\n", + " for imgs, labels in loader:\n", + " imgs, labels = imgs.to(device), labels.to(device)\n", + " outputs = model(imgs)\n", + " preds = outputs.argmax(dim=1)\n", + " all_preds.extend(preds.cpu().numpy())\n", + " all_labels.extend(labels.cpu().numpy())\n", + " cm = confusion_matrix(all_labels, all_preds, labels=list(range(10)))\n", + " disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=classes)\n", + " disp.plot(xticks_rotation='vertical', cmap='Blues')\n", + " plt.title(title)\n", + " plt.show()\n", + " acc = (np.array(all_preds) == np.array(all_labels)).mean()\n", + " print(f\"Accuracy: {acc*100:.2f}%\\n\")" + ], + "metadata": { + "id": "fIXfgx3Q6fWZ" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Evaluate before fine-tuning\n", + "evaluate(model, val_subset_loader, title='Confusion Matrix Before Fine-Tuning')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 571 + }, + "id": "W1tKQZ4R7uuR", + "outputId": "b35929ca-f58a-4de4-9238-3036e41b9f2c" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Accuracy: 9.40%\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 4 Training" + ], + "metadata": { + "id": "Xp-EeAlBTiw-" + } + }, + { + "cell_type": "code", + "source": [ + "from tqdm import tqdm\n", + "EPOCHS = 2\n", + "for epoch in range(EPOCHS):\n", + " model.train()\n", + " running_loss = 0.0\n", + " progress_bar = tqdm(train_loader, desc=f\"Epoch [{epoch+1}/{EPOCHS}]\", leave=False, mininterval=3)\n", + " for images, labels in progress_bar:\n", + " images, labels = images.to(device), labels.to(device)\n", + " optimizer.zero_grad()\n", + " outputs = model(images)\n", + " loss = criterion(outputs, labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + " running_loss += loss.item()\n", + " progress_bar.set_postfix({'loss': f'{loss.item():.4f}'})\n", + "print(f\"Epoch [{epoch+1}/{EPOCHS}] - Avg Loss: {running_loss/len(train_loader):.4f}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XX_mHFgo70IQ", + "outputId": "fc6ca394-10d8-4685-e5b8-dc807b91e9ff" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEpoch [1/2]: 0%| | 0/782 [00:00" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Accuracy: 97.40%\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "llrY5GvFSLSk" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/notebooks/dinov3-regression.ipynb b/notebooks/dinov3-regression.ipynb new file mode 100644 index 000000000..82c95dbcb --- /dev/null +++ b/notebooks/dinov3-regression.ipynb @@ -0,0 +1,1062 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "e41cb78173d14b16a4e95f471bf95db4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_f307ca40f94645dab0f0305a829fc690", + "IPY_MODEL_811b957c596a42e397793b7077c25671", + "IPY_MODEL_498126cda54444c8b5f3564e2dbef3da" + ], + "layout": "IPY_MODEL_64137bd03970472db3e345edd2ffb6f8" + } + }, + "f307ca40f94645dab0f0305a829fc690": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ff3c672af02746f5bff07a179d96b8fb", + "placeholder": "​", + "style": "IPY_MODEL_e32859475b2d4a258ceb64a2c4cd02ba", + "value": "model.safetensors: 100%" + } + }, + "811b957c596a42e397793b7077c25671": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1436c38a8af04c178d0a2d3882ff2dcc", + "max": 342579728, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_28dd4ccce01f4c50ad46d2f285798b5c", + "value": 342579728 + } + }, + "498126cda54444c8b5f3564e2dbef3da": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_07365088e1674db3b2868dfa1b555d97", + "placeholder": "​", + "style": "IPY_MODEL_a07f74f1e6f34e5c8d7f36ca04932f9b", + "value": " 343M/343M [00:11<00:00, 22.3MB/s]" + } + }, + "64137bd03970472db3e345edd2ffb6f8": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ff3c672af02746f5bff07a179d96b8fb": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e32859475b2d4a258ceb64a2c4cd02ba": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1436c38a8af04c178d0a2d3882ff2dcc": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "28dd4ccce01f4c50ad46d2f285798b5c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "07365088e1674db3b2868dfa1b555d97": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a07f74f1e6f34e5c8d7f36ca04932f9b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Tutorial on **Image Regression Using Dino-v3**" + ], + "metadata": { + "id": "1vOb3alOeyUS" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Setup and Imports" + ], + "metadata": { + "id": "dFY_rY2Keti1" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "9-8YzvI6UORC" + }, + "outputs": [], + "source": [ + "import os\n", + "import random\n", + "import pandas as pd\n", + "import numpy as np\n", + "import torch\n", + "import torch.nn as nn\n", + "from torch.utils.data import Dataset, DataLoader, Subset\n", + "from torchvision import transforms\n", + "from PIL import Image\n", + "import timm\n", + "import matplotlib.pyplot as plt\n", + "from tqdm import tqdm" + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Qh6xqpG1UblC", + "outputId": "7244ccc0-ca08-4a38-c717-788bb2dc1632" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "BATCH_SIZE = 32\n", + "VAL_SUBSET_SIZE = 500 # subset size for quick evaluation\n", + "EPOCHS = 5\n", + "LEARNING_RATE = 1e-3\n", + "NUM_WORKERS = 2\n", + "RANDOM_SEED = 42\n", + "IMAGE_SIZE = 224 # 224 is typical for vit / dinov3\n", + "BACKBONE_NAME = 'vit_base_patch16_dinov3'" + ], + "metadata": { + "id": "vTgyffJ9U1rh" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Accessing Local Dataset" + ], + "metadata": { + "id": "rKIKlezLdsuL" + } + }, + { + "cell_type": "code", + "source": [ + "IMAGE_DIR = \"/content/drive/MyDrive/Dinov3Data/Images\"\n", + "CSV_PATH = \"/content/drive/MyDrive/Dinov3Data/human_count_rgb.csv\"\n", + "OUTPUT_DIR = \"/content/drive/MyDrive/DinoV3Data/Results\"\n", + "\n", + "os.makedirs(OUTPUT_DIR, exist_ok=True)" + ], + "metadata": { + "id": "6BuZVfgtUhmC" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def set_seed(seed=RANDOM_SEED):\n", + " random.seed(seed)\n", + " np.random.seed(seed)\n", + " torch.manual_seed(seed)\n", + " if torch.cuda.is_available():\n", + " torch.cuda.manual_seed_all(seed)\n", + "\n", + "set_seed()" + ], + "metadata": { + "id": "S_tJMB1HU5Nw" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Preprocessing Dataset" + ], + "metadata": { + "id": "UVrUVuIFec1_" + } + }, + { + "cell_type": "code", + "source": [ + "class ImageRegressionDataset(Dataset):\n", + " def __init__(self, csv_path, image_dir, transform=None):\n", + " self.df = pd.read_csv(csv_path)\n", + " assert 'filename' in self.df.columns and 'num_humans' in self.df.columns, \\\n", + " \"CSV must have 'filename' and 'num_humans' columns\"\n", + " self.image_dir = image_dir\n", + " self.transform = transform\n", + "\n", + "\n", + " def __len__(self):\n", + " return len(self.df)\n", + "\n", + "\n", + " def __getitem__(self, idx):\n", + " row = self.df.iloc[idx]\n", + " img_path = os.path.join(self.image_dir, str(row['filename']).strip())\n", + " if not os.path.exists(img_path):\n", + " # try with extension if missing\n", + " for ext in ('.jpg','.jpeg','.png'):\n", + " alt = img_path + ext\n", + " if os.path.exists(alt):\n", + " img_path = alt\n", + " break\n", + " img = Image.open(img_path).convert('RGB')\n", + " if self.transform:\n", + " img = self.transform(img)\n", + " target = torch.tensor(float(row['num_humans']), dtype=torch.float32)\n", + " return img, target" + ], + "metadata": { + "id": "ovP7Boi0VBKh" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "transform = transforms.Compose([\n", + " transforms.Resize(IMAGE_SIZE),\n", + " transforms.CenterCrop(IMAGE_SIZE),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize(mean=[0.485, 0.456, 0.406],\n", + " std=[0.229, 0.224, 0.225])\n", + "])\n", + "\n", + "\n", + "# load dataset\n", + "dataset = ImageRegressionDataset(CSV_PATH, IMAGE_DIR, transform=transform)\n", + "\n", + "\n", + "# Split into train and val (80/20)\n", + "n = len(dataset)\n", + "indices = list(range(n))\n", + "random.shuffle(indices)\n", + "split = int(0.8 * n)\n", + "train_indices, val_indices = indices[:split], indices[split:]\n", + "train_ds = Subset(dataset, train_indices)\n", + "val_ds = Subset(dataset, val_indices)\n", + "\n", + "\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)" + ], + "metadata": { + "id": "2Jv_Ul7lVgwy" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "val_subset_size = min(VAL_SUBSET_SIZE, len(val_ds))\n", + "val_subset_indices = np.random.choice(len(val_ds), val_subset_size, replace=False)\n", + "val_subset = Subset(val_ds, val_subset_indices)\n", + "val_subset_loader = DataLoader(val_subset, batch_size=BATCH_SIZE, shuffle=False, num_workers=NUM_WORKERS)" + ], + "metadata": { + "id": "nrCbNKj4WtI8" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def show_samples(dataset, num=5):\n", + " fig, axes = plt.subplots(1, num, figsize=(3*num, 3))\n", + " chosen = np.random.choice(len(dataset), num, replace=False)\n", + " for ax, i in zip(axes, chosen):\n", + " img, target = dataset[i]\n", + " # unnormalize for display\n", + " img_np = img.permute(1,2,0).numpy()\n", + " img_np = np.clip((img_np * np.array([0.229, 0.224, 0.225])) + np.array([0.485, 0.456, 0.406]), 0, 1)\n", + " ax.imshow(img_np)\n", + " ax.set_title(f\"{int(target.item()):}\")\n", + " ax.axis('off')\n", + " plt.show()\n", + "\n", + "\n", + "print('Showing sample images from training set:')\n", + "show_samples(train_ds, num=5)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 276 + }, + "id": "82R3gUbRWJxQ", + "outputId": "c405841c-217d-49c6-806f-9735ccd50b31" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Showing sample images from training set:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Fine-tuning & Evaluation" + ], + "metadata": { + "id": "kSwaY44hej5I" + } + }, + { + "cell_type": "code", + "source": [ + "class DinoRegressor(nn.Module):\n", + " def __init__(self, backbone_name=BACKBONE_NAME, pretrained=True, freeze_backbone=True):\n", + " super().__init__()\n", + " self.backbone = timm.create_model(backbone_name, pretrained=pretrained, num_classes=0, global_pool='avg')\n", + " feat_dim = self.backbone.num_features\n", + " self.head = nn.Sequential(\n", + " nn.Linear(feat_dim, 256),\n", + " nn.ReLU(inplace=True),\n", + " nn.Linear(256, 1)\n", + " )\n", + " if freeze_backbone:\n", + " for p in self.backbone.parameters():\n", + " p.requires_grad = False\n", + "\n", + "\n", + " def forward(self, x):\n", + " feats = self.backbone(x)\n", + " out = self.head(feats)\n", + " return out.squeeze(1)\n", + "\n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "model = DinoRegressor(freeze_backbone=True).to(device)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 49, + "referenced_widgets": [ + "e41cb78173d14b16a4e95f471bf95db4", + "f307ca40f94645dab0f0305a829fc690", + "811b957c596a42e397793b7077c25671", + "498126cda54444c8b5f3564e2dbef3da", + "64137bd03970472db3e345edd2ffb6f8", + "ff3c672af02746f5bff07a179d96b8fb", + "e32859475b2d4a258ceb64a2c4cd02ba", + "1436c38a8af04c178d0a2d3882ff2dcc", + "28dd4ccce01f4c50ad46d2f285798b5c", + "07365088e1674db3b2868dfa1b555d97", + "a07f74f1e6f34e5c8d7f36ca04932f9b" + ] + }, + "id": "BXORjXtHW2ny", + "outputId": "15e8cf26-11e5-4823-a0ab-4f64dc4403b9" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "model.safetensors: 0%| | 0.00/343M [00:00" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "def show_predictions(dataset_subset, model, num=5):\n", + " model.eval()\n", + " chosen = np.random.choice(len(dataset_subset), num, replace=False)\n", + " fig, axes = plt.subplots(1, num, figsize=(3*num, 3))\n", + " with torch.no_grad():\n", + " for ax, idx in zip(axes, chosen):\n", + " img, t = dataset_subset[idx]\n", + " inp = img.unsqueeze(0).to(device)\n", + " pred = model(inp).cpu().item()\n", + " img_np = img.permute(1,2,0).numpy()\n", + " img_np = np.clip((img_np * np.array([0.229, 0.224, 0.225])) + np.array([0.485, 0.456, 0.406]), 0, 1)\n", + " ax.imshow(img_np)\n", + " ax.set_title(f\"GT: {t.item():.3f}\\nPred: {pred:.3f}\")\n", + " ax.axis('off')\n", + " plt.show()" + ], + "metadata": { + "id": "2jf9Z7Gub72b" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print('Sample predictions after training:')\n", + "show_predictions(val_subset, model, num=5)\n", + "\n", + "print('Regression demo complete.')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 315 + }, + "id": "O958wbFQcl1k", + "outputId": "d4e06daa-818b-472c-a47b-6444c5823665" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Sample predictions after training:\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Regression demo complete.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "fhEYLpmAcpJ0" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/sample_images/apple_1.jpg b/sample_images/apple_1.jpg new file mode 100644 index 000000000..84ee5c108 Binary files /dev/null and b/sample_images/apple_1.jpg differ diff --git a/sample_images/apple_2.jpg b/sample_images/apple_2.jpg new file mode 100644 index 000000000..0f20b7b71 Binary files /dev/null and b/sample_images/apple_2.jpg differ diff --git a/sample_images/apple_3.jpg b/sample_images/apple_3.jpg new file mode 100644 index 000000000..08d58f080 Binary files /dev/null and b/sample_images/apple_3.jpg differ diff --git a/sample_images/autumn_forest.jpg b/sample_images/autumn_forest.jpg new file mode 100644 index 000000000..48ecd8f84 Binary files /dev/null and b/sample_images/autumn_forest.jpg differ diff --git a/sample_images/banana_1.jpg b/sample_images/banana_1.jpg new file mode 100644 index 000000000..1bba863b9 Binary files /dev/null and b/sample_images/banana_1.jpg differ diff --git a/sample_images/banana_2.jpg b/sample_images/banana_2.jpg new file mode 100644 index 000000000..347960779 Binary files /dev/null and b/sample_images/banana_2.jpg differ diff --git a/sample_images/banana_3.jpg b/sample_images/banana_3.jpg new file mode 100644 index 000000000..196d95b1f Binary files /dev/null and b/sample_images/banana_3.jpg differ diff --git a/sample_images/beach_1.jpg b/sample_images/beach_1.jpg new file mode 100644 index 000000000..851a3caa6 Binary files /dev/null and b/sample_images/beach_1.jpg differ diff --git a/sample_images/beach_2.jpg b/sample_images/beach_2.jpg new file mode 100644 index 000000000..f7ab75dd4 Binary files /dev/null and b/sample_images/beach_2.jpg differ diff --git a/sample_images/bicycle_1.jpg b/sample_images/bicycle_1.jpg new file mode 100644 index 000000000..78b584d39 Binary files /dev/null and b/sample_images/bicycle_1.jpg differ diff --git a/sample_images/bicycle_2.jpg b/sample_images/bicycle_2.jpg new file mode 100644 index 000000000..68ccc4003 Binary files /dev/null and b/sample_images/bicycle_2.jpg differ diff --git a/sample_images/bird_1.jpg b/sample_images/bird_1.jpg new file mode 100644 index 000000000..d4227e2c8 Binary files /dev/null and b/sample_images/bird_1.jpg differ diff --git a/sample_images/bird_2.jpg b/sample_images/bird_2.jpg new file mode 100644 index 000000000..e20dc4d70 Binary files /dev/null and b/sample_images/bird_2.jpg differ diff --git a/sample_images/building_1.jpg b/sample_images/building_1.jpg new file mode 100644 index 000000000..fa495d26c Binary files /dev/null and b/sample_images/building_1.jpg differ diff --git a/sample_images/building_3.jpg b/sample_images/building_3.jpg new file mode 100644 index 000000000..59fd25dd8 Binary files /dev/null and b/sample_images/building_3.jpg differ diff --git a/sample_images/burger_1.jpg b/sample_images/burger_1.jpg new file mode 100644 index 000000000..c72016222 Binary files /dev/null and b/sample_images/burger_1.jpg differ diff --git a/sample_images/burger_2.jpg b/sample_images/burger_2.jpg new file mode 100644 index 000000000..26673e895 Binary files /dev/null and b/sample_images/burger_2.jpg differ diff --git a/sample_images/car_1.jpg b/sample_images/car_1.jpg new file mode 100644 index 000000000..fed6c1cb4 Binary files /dev/null and b/sample_images/car_1.jpg differ diff --git a/sample_images/car_2.jpg b/sample_images/car_2.jpg new file mode 100644 index 000000000..c38e817f1 Binary files /dev/null and b/sample_images/car_2.jpg differ diff --git a/sample_images/car_3.jpg b/sample_images/car_3.jpg new file mode 100644 index 000000000..045c387d3 Binary files /dev/null and b/sample_images/car_3.jpg differ diff --git a/sample_images/cat_1.jpg b/sample_images/cat_1.jpg new file mode 100644 index 000000000..0e47c0b11 Binary files /dev/null and b/sample_images/cat_1.jpg differ diff --git a/sample_images/cat_2.jpg b/sample_images/cat_2.jpg new file mode 100644 index 000000000..10834221c Binary files /dev/null and b/sample_images/cat_2.jpg differ diff --git a/sample_images/city_skyline.jpg b/sample_images/city_skyline.jpg new file mode 100644 index 000000000..d4cfa8c68 Binary files /dev/null and b/sample_images/city_skyline.jpg differ diff --git a/sample_images/colorful_birds.jpg b/sample_images/colorful_birds.jpg new file mode 100644 index 000000000..42b32c911 Binary files /dev/null and b/sample_images/colorful_birds.jpg differ diff --git a/sample_images/colorful_houses.jpg b/sample_images/colorful_houses.jpg new file mode 100644 index 000000000..ebb06c052 Binary files /dev/null and b/sample_images/colorful_houses.jpg differ diff --git a/sample_images/dog_1.jpg b/sample_images/dog_1.jpg new file mode 100644 index 000000000..f7512822b Binary files /dev/null and b/sample_images/dog_1.jpg differ diff --git a/sample_images/dog_2.jpg b/sample_images/dog_2.jpg new file mode 100644 index 000000000..9ae29be9b Binary files /dev/null and b/sample_images/dog_2.jpg differ diff --git a/sample_images/dog_3.jpg b/sample_images/dog_3.jpg new file mode 100644 index 000000000..1a4e1cbc6 Binary files /dev/null and b/sample_images/dog_3.jpg differ diff --git a/sample_images/flower_1.jpg b/sample_images/flower_1.jpg new file mode 100644 index 000000000..24899cb7d Binary files /dev/null and b/sample_images/flower_1.jpg differ diff --git a/sample_images/flower_2.jpg b/sample_images/flower_2.jpg new file mode 100644 index 000000000..52dce29c7 Binary files /dev/null and b/sample_images/flower_2.jpg differ diff --git a/sample_images/flower_3.jpg b/sample_images/flower_3.jpg new file mode 100644 index 000000000..5a2668b5d Binary files /dev/null and b/sample_images/flower_3.jpg differ diff --git a/sample_images/forest_1.jpg b/sample_images/forest_1.jpg new file mode 100644 index 000000000..254f6da1b Binary files /dev/null and b/sample_images/forest_1.jpg differ diff --git a/sample_images/forest_2.jpg b/sample_images/forest_2.jpg new file mode 100644 index 000000000..dc871b0ac Binary files /dev/null and b/sample_images/forest_2.jpg differ diff --git a/sample_images/grape_2.jpg b/sample_images/grape_2.jpg new file mode 100644 index 000000000..4f5364e76 Binary files /dev/null and b/sample_images/grape_2.jpg differ diff --git a/sample_images/mango_1.jpg b/sample_images/mango_1.jpg new file mode 100644 index 000000000..c6df5b9fb Binary files /dev/null and b/sample_images/mango_1.jpg differ diff --git a/sample_images/mango_2.jpg b/sample_images/mango_2.jpg new file mode 100644 index 000000000..b386ce8ed Binary files /dev/null and b/sample_images/mango_2.jpg differ diff --git a/sample_images/mountain_1.jpg b/sample_images/mountain_1.jpg new file mode 100644 index 000000000..3acdbc544 Binary files /dev/null and b/sample_images/mountain_1.jpg differ diff --git a/sample_images/mountain_2.jpg b/sample_images/mountain_2.jpg new file mode 100644 index 000000000..b442ea268 Binary files /dev/null and b/sample_images/mountain_2.jpg differ diff --git a/sample_images/mountain_lake.jpg b/sample_images/mountain_lake.jpg new file mode 100644 index 000000000..89435436d Binary files /dev/null and b/sample_images/mountain_lake.jpg differ diff --git a/sample_images/orange_1.jpg b/sample_images/orange_1.jpg new file mode 100644 index 000000000..c60e22aa0 Binary files /dev/null and b/sample_images/orange_1.jpg differ diff --git a/sample_images/orange_2.jpg b/sample_images/orange_2.jpg new file mode 100644 index 000000000..ea4ca123e Binary files /dev/null and b/sample_images/orange_2.jpg differ diff --git a/sample_images/orange_3.jpg b/sample_images/orange_3.jpg new file mode 100644 index 000000000..bd0ab5b69 Binary files /dev/null and b/sample_images/orange_3.jpg differ diff --git a/sample_images/pineapple_1.jpg b/sample_images/pineapple_1.jpg new file mode 100644 index 000000000..2d57bd8c7 Binary files /dev/null and b/sample_images/pineapple_1.jpg differ diff --git a/sample_images/pizza_1.jpg b/sample_images/pizza_1.jpg new file mode 100644 index 000000000..8f7df06b8 Binary files /dev/null and b/sample_images/pizza_1.jpg differ diff --git a/sample_images/pizza_2.jpg b/sample_images/pizza_2.jpg new file mode 100644 index 000000000..def08aaca Binary files /dev/null and b/sample_images/pizza_2.jpg differ diff --git a/sample_images/strawberry_1.jpg b/sample_images/strawberry_1.jpg new file mode 100644 index 000000000..a7780afc8 Binary files /dev/null and b/sample_images/strawberry_1.jpg differ diff --git a/sample_images/strawberry_2.jpg b/sample_images/strawberry_2.jpg new file mode 100644 index 000000000..43925acf1 Binary files /dev/null and b/sample_images/strawberry_2.jpg differ diff --git a/sample_images/strawberry_3.jpg b/sample_images/strawberry_3.jpg new file mode 100644 index 000000000..83b4472a8 Binary files /dev/null and b/sample_images/strawberry_3.jpg differ diff --git a/sample_images/sunset_beach.jpg b/sample_images/sunset_beach.jpg new file mode 100644 index 000000000..f5ddb1978 Binary files /dev/null and b/sample_images/sunset_beach.jpg differ diff --git a/sample_images/sushi_1.jpg b/sample_images/sushi_1.jpg new file mode 100644 index 000000000..dc92200b7 Binary files /dev/null and b/sample_images/sushi_1.jpg differ diff --git a/sample_images/sushi_2.jpg b/sample_images/sushi_2.jpg new file mode 100644 index 000000000..a23bf75d3 Binary files /dev/null and b/sample_images/sushi_2.jpg differ diff --git a/sample_images/tulip_field.jpg b/sample_images/tulip_field.jpg new file mode 100644 index 000000000..b87d326b9 Binary files /dev/null and b/sample_images/tulip_field.jpg differ diff --git a/slides.qmd b/slides.qmd index 04ec27425..de3be423b 100644 --- a/slides.qmd +++ b/slides.qmd @@ -84,6 +84,8 @@ Specialized techniques and cutting-edge approaches. Algorithms that find patterns in unlabeled data. - [Clustering & Dimensionality Reduction](unsupervised/slides/unsupervised.pdf) +- [Clustering](unsupervised/slides/clustering-lecture.pdf) +- [Principal Component Analysis](unsupervised/slides/pca.pdf) --- diff --git a/unsupervised/slides/pca.pdf b/unsupervised/slides/pca.pdf new file mode 100644 index 000000000..8f779b371 Binary files /dev/null and b/unsupervised/slides/pca.pdf differ