diff --git a/{{cookiecutter.project_slug}}/.gitignore b/{{cookiecutter.project_slug}}/.gitignore index b25b609..107b2d4 100644 --- a/{{cookiecutter.project_slug}}/.gitignore +++ b/{{cookiecutter.project_slug}}/.gitignore @@ -100,3 +100,9 @@ instance/ *.bak *.tmp # TODO: Add more patterns based on your specific needs + +*.png +lightning_logs/ + +.neptune/ +*.zip diff --git a/{{cookiecutter.project_slug}}/Tutorial.ipynb b/{{cookiecutter.project_slug}}/Tutorial.ipynb new file mode 100644 index 0000000..0baa4a9 --- /dev/null +++ b/{{cookiecutter.project_slug}}/Tutorial.ipynb @@ -0,0 +1,542 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## This is a showcase of the usage of ART - a package inspired by Andrej Karpathy's blog post.\n", + "\n", + "### In this tutorial, you will be presented with how to use ART to perform a very popular form of model training - the transfer learning, while following steps recommended by Andrej Karpathy." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's start with the dataset. Since ART is based on Pytorch-Lightning, we need to create LightningDataModule.\\\n", + "For this tutorial, I decided to use a very well known dataset called Cifar100 and I wrapped it into LightningDataModule creating [CifarDataModule](https://github.com/SebChw/ART-Templates/blob/cv_transfer_learning_tutorial/%7B%7Bcookiecutter.project_slug%7D%7D/dataset.py)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Okay, we have datamodule, but how do we use it?\\\n", + "Let us introduce you, to the core of ART, the ArtProject." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from dataset import CifarDataModule\n", + "from art.project import ArtProject\n", + "project_name = \"Cifar100\"\n", + "dataset = CifarDataModule(batch_size=32)\n", + "project = ArtProject(project_name, dataset)\n", + "force_rerun = False # whole process is saved in checkpoints, for fast rerun. \n", + " # If you want to use it set to False" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, that we have a Datamodule and ArtProject let's perform the first step: \\\n", + "**Become one with the data**\n", + "\n", + "\n", + "To achieve this, we'll perform some data analysis.\\\n", + "Firstly, create a new step for our project - Data analysis\\\n", + "Here is what it could look like: [Data analysis step](https://github.com/SebChw/ART-Templates/blob/4c10a65fa8f7356933105ce78b694cbcbed3b6d0/%7B%7Bcookiecutter.project_slug%7D%7D/steps.py#L9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this class, we check multiple characteristics of the data:\n", + "* The number of classes\n", + "* Names of classes\n", + "* Whether the dataset is balanced - number of examples in each class\n", + "* The dimensions of the images\n", + "* We get to know the actual visualizations of the images (10 visualizations per class)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's insert it into the ArtProject" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Summary: \n", + "Step: Data analysis, Model: , Passed: True. Results:\n", + "\n" + ] + } + ], + "source": [ + "from checks import CheckClassImagesExist, CheckLenClassNamesEqualToNumClasses\n", + "from steps import DataAnalysis\n", + "from art.checks import CheckResultExists\n", + "project.add_step(DataAnalysis(), [\n", + " CheckResultExists(\"number_of_classes\"),\n", + " CheckResultExists(\"class_names\"),\n", + " CheckResultExists(\"number_of_examples_in_each_class\"),\n", + " CheckResultExists(\"img_dimensions\"),\n", + " CheckClassImagesExist(),\n", + " CheckLenClassNamesEqualToNumClasses()])\n", + "project.run_all(force_rerun=force_rerun)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can see that there are some checks except for the data analysis step.\\\n", + "Those checks are run after the step so that we can be sure that everything went as planned.\\\n", + "**You**, as the user of ART, are responsible for creating checks that will suit your experiments.\\\n", + "We used only two **custom** [checks](https://github.com/SebChw/ART-Templates/blob/cv_transfer_learning_tutorial/%7B%7Bcookiecutter.project_slug%7D%7D/checks.py) and one universal check implemented into art: [CheckResultExists](https://github.com/SebChw/Actually-Robust-Training/blob/main/art/checks.py#L82).\n", + "\n", + "\n", + "Let's see the results:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of classes: 100\n", + "All classes names: ['apple', 'aquarium_fish', 'baby', 'bear', 'beaver', 'bed', 'bee', 'beetle', 'bicycle', 'bottle', 'bowl', 'boy', 'bridge', 'bus', 'butterfly', 'camel', 'can', 'castle', 'caterpillar', 'cattle', 'chair', 'chimpanzee', 'clock', 'cloud', 'cockroach', 'couch', 'cra', 'crocodile', 'cup', 'dinosaur', 'dolphin', 'elephant', 'flatfish', 'forest', 'fox', 'girl', 'hamster', 'house', 'kangaroo', 'keyboard', 'lamp', 'lawn_mower', 'leopard', 'lion', 'lizard', 'lobster', 'man', 'maple_tree', 'motorcycle', 'mountain', 'mouse', 'mushroom', 'oak_tree', 'orange', 'orchid', 'otter', 'palm_tree', 'pear', 'pickup_truck', 'pine_tree', 'plain', 'plate', 'poppy', 'porcupine', 'possum', 'rabbit', 'raccoon', 'ray', 'road', 'rocket', 'rose', 'sea', 'seal', 'shark', 'shrew', 'skunk', 'skyscraper', 'snail', 'snake', 'spider', 'squirrel', 'streetcar', 'sunflower', 'sweet_pepper', 'table', 'tank', 'telephone', 'television', 'tiger', 'tractor', 'train', 'trout', 'tulip', 'turtle', 'wardrobe', 'whale', 'willow_tree', 'wolf', 'woman', 'worm']\n", + "Number of examples in each class: [('cattle', 500), ('dinosaur', 500), ('apple', 500), ('boy', 500), ('aquarium_fish', 500)] ...\n", + "All classes have the same number of examples: True.\n", + "Dimentions of images: [32, 32, 3]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import random\n", + "import matplotlib.pyplot as plt\n", + "from PIL import Image\n", + "from os.path import normpath\n", + "results = project.get_step(0).get_latest_run()\n", + "print(\"Number of classes: \", results[\"number_of_classes\"])\n", + "print(\"All classes names: \", results[\"class_names\"])\n", + "print(\"Number of examples in each class: \", [(x, y) for x, y in results[\"number_of_examples_in_each_class\"].items()][:5], \"...\")\n", + "print(f\"All classes have the same number of examples: {all(i == [x for x in results['number_of_examples_in_each_class'].values()][0] for i in [x for x in results['number_of_examples_in_each_class'].values()])}.\")\n", + "print(\"Dimentions of images: \", results[\"img_dimensions\"])\n", + "for i in range(3):\n", + " img_class = results[\"class_names\"][random.randint(0, 100)]\n", + " img_path = normpath(f\"art_checkpoints/Data analysis/{project.get_step(0).get_class_image_path(img_class)}\")\n", + " image = Image.open(img_path)\n", + " plt.imshow(image)\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + " \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see, that the dataset is perfectly balanced, and indeed has 100 classes as its name suggests.\n", + "\n", + "Now that we know something about our dataset, we can proceed to the next steps. It is time to decide, what **metrics** will we use in our project." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from torchmetrics import Accuracy\n", + "import torch.nn as nn\n", + "from art.steps import EvaluateBaseline\n", + "\n", + "NUM_CLASSES = project.get_step(0).get_latest_run()[\"number_of_classes\"]\n", + "accuracy_metric, ce_loss = Accuracy(task=\"multiclass\", num_classes = NUM_CLASSES), nn.CrossEntropyLoss()\n", + "# Register metrics, that you want to be calculated for every model that you will be using\n", + "project.register_metrics([accuracy_metric, ce_loss])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Having registered the metrics, we can proceed to the next step which is to **Add baselines**. We want to make sure, that everything we have done until this moment, works as it should, and there are no bugs in our DataLoader.\\\n", + "For this purpose, we used three [baselines](https://github.com/SebChw/ART-Templates/blob/cv_transfer_learning_tutorial/%7B%7Bcookiecutter.project_slug%7D%7D/models/baselines.py).\\\n", + "Feel free to implement yours however you like, but remember to follow the structure of ArtModule." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from art.metrics import SkippedMetric\n", + "from models.baselines import MlBaseline, HeuristicBaseline, AlreadyExistingResNet20Baseline\n", + "from art.checks import CheckScoreExists\n", + "baselines = [HeuristicBaseline, MlBaseline, AlreadyExistingResNet20Baseline]\n", + "for baseline in baselines:\n", + " project.add_step(\n", + " step = EvaluateBaseline(baseline), \n", + " checks = [CheckScoreExists(metric=accuracy_metric)],\n", + " skipped_metrics=[SkippedMetric(metric=ce_loss)]\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Summary: \n", + "Step: Data analysis, Model: , Passed: True. Results:\n", + "\n", + "Step: Evaluate Baseline, Model: HeuristicBaseline, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.012299999594688416\n", + "Step: Evaluate Baseline, Model: MlBaseline, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.15649999678134918\n", + "Step: Evaluate Baseline, Model: AlreadyExistingResNet20Baseline, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.6883000135421753\n" + ] + } + ], + "source": [ + "project.run_all(force_rerun=force_rerun)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nice, we can see that MLBaseline is better than random selection, and that pretrained ResNet20 performs quite well." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, that we are sure, that our pipeline works as intended, we can start implementing our model.\\\n", + "We will start with yet another good pracitce which is **check loss on init** - we want to make sure, that our model, which didn't see any of the Cifar100 data, will give us **loss** equal to `-log(1/100)`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.605170185988091\n" + ] + } + ], + "source": [ + "# from models.ResNet import ResNet\n", + "from models.EfficientNet import EfficientNet\n", + "from art.steps import CheckLossOnInit\n", + "from art.checks import CheckScoreCloseTo\n", + "import math\n", + "\n", + "EXPECTED_LOSS = -math.log(1/NUM_CLASSES)\n", + "print(EXPECTED_LOSS)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We'll add new stop to the project `CheckLossOnInit`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Summary: \n", + "Step: Data analysis, Model: , Passed: True. Results:\n", + "\n", + "Step: Evaluate Baseline, Model: HeuristicBaseline, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.012299999594688416\n", + "Step: Evaluate Baseline, Model: MlBaseline, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.15649999678134918\n", + "Step: Evaluate Baseline, Model: AlreadyExistingResNet20Baseline, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.6883000135421753\n", + "Step: Check Loss On Init, Model: EfficientNet, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.00675999978557229\n", + "\tCrossEntropyLoss-validate: 4.893486022949219\n" + ] + } + ], + "source": [ + "project.add_step(\n", + " CheckLossOnInit(EfficientNet),\n", + " [CheckScoreCloseTo(metric=ce_loss,\n", + " value=EXPECTED_LOSS, rel_tol=0.1)]\n", + " )\n", + "\n", + "project.run_all(force_rerun=force_rerun)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Great, the loss looks good!\\\n", + "The next step we want to perform, is to **overfit one batch** of our data. Thanks to this, we can be sure that our model is properly implemented." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Summary: \n", + "Step: Data analysis, Model: , Passed: True. Results:\n", + "\n", + "Step: Evaluate Baseline, Model: HeuristicBaseline, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.012299999594688416\n", + "Step: Evaluate Baseline, Model: MlBaseline, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.15649999678134918\n", + "Step: Evaluate Baseline, Model: AlreadyExistingResNet20Baseline, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.6883000135421753\n", + "Step: Check Loss On Init, Model: EfficientNet, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.00675999978557229\n", + "\tCrossEntropyLoss-validate: 4.893486022949219\n", + "Step: Overfit One Batch, Model: EfficientNet, Passed: True. Results:\n", + "\tMulticlassAccuracy-train: 1.0\n", + "\tCrossEntropyLoss-train: 2.902682354033459e-05\n" + ] + } + ], + "source": [ + "from art.steps import OverfitOneBatch\n", + "from art.checks import CheckScoreLessThan\n", + "project.add_step(OverfitOneBatch(EfficientNet, number_of_steps=40),\n", + " [CheckScoreLessThan(metric=ce_loss, value=0.05)])\n", + "project.run_all(force_rerun=force_rerun)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And we will do the same, for the whole dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from art.steps import Overfit\n", + "from art.checks import CheckScoreGreaterThan\n", + "\n", + "project.add_step(Overfit(EfficientNet, max_epochs=10),\n", + " [CheckScoreGreaterThan(metric=accuracy_metric, value=0.8)])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Summary: \n", + "Step: Data analysis, Model: , Passed: True. Results:\n", + "\n", + "Step: Evaluate Baseline, Model: HeuristicBaseline, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.012299999594688416\n", + "Step: Evaluate Baseline, Model: MlBaseline, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.15649999678134918\n", + "Step: Evaluate Baseline, Model: AlreadyExistingResNet20Baseline, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.6883000135421753\n", + "Step: Check Loss On Init, Model: EfficientNet, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.00675999978557229\n", + "\tCrossEntropyLoss-validate: 4.893486022949219\n", + "Step: Overfit One Batch, Model: EfficientNet, Passed: True. Results:\n", + "\tMulticlassAccuracy-train: 1.0\n", + "\tCrossEntropyLoss-train: 2.902682354033459e-05\n", + "Step: Overfit, Model: EfficientNet, Passed: True. Results:\n", + "\tMulticlassAccuracy-train: 0.9455999732017517\n", + "\tCrossEntropyLoss-train: 0.16572201251983643\n", + "\tMulticlassAccuracy-validate: 0.7613999843597412\n", + "\tCrossEntropyLoss-validate: 1.1986972093582153\n" + ] + } + ], + "source": [ + "project.run_all(force_rerun=force_rerun)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, that the model passed all steps and checks we can finaly proceed with the **transfer learning**!" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from art.steps import TransferLearning\n", + "from art.loggers import NeptuneLoggerAdapter\n", + "from lightning.pytorch.callbacks import EarlyStopping\n", + "\n", + "early_stopping = EarlyStopping('CrossEntropyLoss-validate', patience=6)\n", + "project.add_step(TransferLearning(EfficientNet,\n", + " freezed_trainer_kwargs={\"max_epochs\": 4,\n", + " \"check_val_every_n_epoch\": 2,\n", + " \"callbacks\": [early_stopping]},\n", + " unfreezed_trainer_kwargs={\"max_epochs\": 50,\n", + " \"check_val_every_n_epoch\": 2,\n", + " \"callbacks\": [early_stopping]},\n", + " keep_unfrozen=1,\n", + " ),\n", + " [CheckScoreGreaterThan(metric=accuracy_metric, value=0.70)])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Summary: \n", + "Step: Data analysis, Model: , Passed: True. Results:\n", + "\n", + "Step: Evaluate Baseline, Model: HeuristicBaseline, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.012299999594688416\n", + "Step: Evaluate Baseline, Model: MlBaseline, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.15649999678134918\n", + "Step: Evaluate Baseline, Model: AlreadyExistingResNet20Baseline, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.6883000135421753\n", + "Step: Check Loss On Init, Model: EfficientNet, Passed: True. Results:\n", + "\tMulticlassAccuracy-validate: 0.00675999978557229\n", + "\tCrossEntropyLoss-validate: 4.893486022949219\n", + "Step: Overfit One Batch, Model: EfficientNet, Passed: True. Results:\n", + "\tMulticlassAccuracy-train: 1.0\n", + "\tCrossEntropyLoss-train: 2.902682354033459e-05\n", + "Step: Overfit, Model: EfficientNet, Passed: True. Results:\n", + "\tMulticlassAccuracy-train: 0.9455999732017517\n", + "\tCrossEntropyLoss-train: 0.16572201251983643\n", + "\tMulticlassAccuracy-validate: 0.7613999843597412\n", + "\tCrossEntropyLoss-validate: 1.1986972093582153\n", + "Step: TransferLearning, Model: EfficientNet, Passed: True. Results:\n", + "\tMulticlassAccuracy-train: 0.9606000185012817\n", + "\tCrossEntropyLoss-train: 0.12111776322126389\n", + "\tMulticlassAccuracy-validate: 0.7610999941825867\n", + "\tCrossEntropyLoss-validate: 1.254715085029602\n" + ] + } + ], + "source": [ + "project.run_all(force_rerun=force_rerun)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are all done! We achieved 76,1% of accuracy using a small [EfficientNet](https://huggingface.co/timm/efficientnet_b2.ra_in1k), running only couple of epochs!" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "art", + "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.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/{{cookiecutter.project_slug}}/__pycache__/__init__.cpython-310.pyc b/{{cookiecutter.project_slug}}/__pycache__/__init__.cpython-310.pyc deleted file mode 100644 index 3f3f25a..0000000 Binary files a/{{cookiecutter.project_slug}}/__pycache__/__init__.cpython-310.pyc and /dev/null differ diff --git a/{{cookiecutter.project_slug}}/art_checkpoints/AlreadyExistingResNet20Baseline_Evaluate Baseline/results.json b/{{cookiecutter.project_slug}}/art_checkpoints/AlreadyExistingResNet20Baseline_Evaluate Baseline/results.json new file mode 100644 index 0000000..0a7acf7 --- /dev/null +++ b/{{cookiecutter.project_slug}}/art_checkpoints/AlreadyExistingResNet20Baseline_Evaluate Baseline/results.json @@ -0,0 +1 @@ +{"name": "Evaluate Baseline", "model": "AlreadyExistingResNet20Baseline", "runs": [{"scores": {"MulticlassAccuracy-validate": 0.6883000135421753}, "parameters": {}, "timestamp": "2023-12-02 11:10:00.493226", "successful": true, "hash": "189162562416660209dae3454f16a2df", "commit_id": "1b740ecf84c50de0b79fb155ef306ef622d92f08", "log_file_name": "2023-12-02_11-10-00_e6aac212-98e4-4836-9884-ba7e210a7b2a.log"}]} \ No newline at end of file diff --git a/{{cookiecutter.project_slug}}/art_checkpoints/Data analysis/results.json b/{{cookiecutter.project_slug}}/art_checkpoints/Data analysis/results.json new file mode 100644 index 0000000..5e1984b --- /dev/null +++ b/{{cookiecutter.project_slug}}/art_checkpoints/Data analysis/results.json @@ -0,0 +1 @@ +{"name": "Data analysis", "model": "", "runs": [{"scores": {}, "parameters": {}, "timestamp": "2023-12-02 11:08:56.045512", "successful": true, "hash": "d95a750a53f15e554caf978981ca3494", "commit_id": "1b740ecf84c50de0b79fb155ef306ef622d92f08", "number_of_classes": 100, "class_names": ["apple", "aquarium_fish", "baby", "bear", "beaver", "bed", "bee", "beetle", "bicycle", "bottle", "bowl", "boy", "bridge", "bus", "butterfly", "camel", "can", "castle", "caterpillar", "cattle", "chair", "chimpanzee", "clock", "cloud", "cockroach", "couch", "cra", "crocodile", "cup", "dinosaur", "dolphin", "elephant", "flatfish", "forest", "fox", "girl", "hamster", "house", "kangaroo", "keyboard", "lamp", "lawn_mower", "leopard", "lion", "lizard", "lobster", "man", "maple_tree", "motorcycle", "mountain", "mouse", "mushroom", "oak_tree", "orange", "orchid", "otter", "palm_tree", "pear", "pickup_truck", "pine_tree", "plain", "plate", "poppy", "porcupine", "possum", "rabbit", "raccoon", "ray", "road", "rocket", "rose", "sea", "seal", "shark", "shrew", "skunk", "skyscraper", "snail", "snake", "spider", "squirrel", "streetcar", "sunflower", "sweet_pepper", "table", "tank", "telephone", "television", "tiger", "tractor", "train", "trout", "tulip", "turtle", "wardrobe", "whale", "willow_tree", "wolf", "woman", "worm"], "number_of_examples_in_each_class": {"cattle": 500, "dinosaur": 500, "apple": 500, "boy": 500, "aquarium_fish": 500, "telephone": 500, "train": 500, "cup": 500, "cloud": 500, "elephant": 500, "keyboard": 500, "willow_tree": 500, "sunflower": 500, "castle": 500, "sea": 500, "bicycle": 500, "wolf": 500, "squirrel": 500, "shrew": 500, "pine_tree": 500, "rose": 500, "television": 500, "table": 500, "possum": 500, "oak_tree": 500, "leopard": 500, "maple_tree": 500, "rabbit": 500, "chimpanzee": 500, "clock": 500, "streetcar": 500, "cockroach": 500, "snake": 500, "lobster": 500, "mountain": 500, "palm_tree": 500, "skyscraper": 500, "tractor": 500, "shark": 500, "butterfly": 500, "bottle": 500, "bee": 500, "chair": 500, "woman": 500, "hamster": 500, "otter": 500, "seal": 500, "lion": 500, "mushroom": 500, "girl": 500, "sweet_pepper": 500, "forest": 500, "crocodile": 500, "orange": 500, "tulip": 500, "mouse": 500, "camel": 500, "caterpillar": 500, "man": 500, "skunk": 500, "kangaroo": 500, "raccoon": 500, "snail": 500, "rocket": 500, "whale": 500, "worm": 500, "turtle": 500, "beaver": 500, "plate": 500, "wardrobe": 500, "road": 500, "fox": 500, "flatfish": 500, "tiger": 500, "ray": 500, "dolphin": 500, "poppy": 500, "porcupine": 500, "lamp": 500, "cra": 500, "motorcycle": 500, "spider": 500, "tank": 500, "orchid": 500, "lizard": 500, "beetle": 500, "bridge": 500, "baby": 500, "lawn_mower": 500, "house": 500, "bus": 500, "couch": 500, "bowl": 500, "pear": 500, "bed": 500, "plain": 500, "trout": 500, "bear": 500, "pickup_truck": 500, "can": 500}, "img_dimensions": [32, 32, 3], "log_file_name": "2023-12-02_11-08-56_119bbd34-9342-49f3-8fd2-7e744b5689b4.log"}]} \ No newline at end of file diff --git a/{{cookiecutter.project_slug}}/art_checkpoints/EfficientNet_Check Loss On Init/results.json b/{{cookiecutter.project_slug}}/art_checkpoints/EfficientNet_Check Loss On Init/results.json new file mode 100644 index 0000000..2984766 --- /dev/null +++ b/{{cookiecutter.project_slug}}/art_checkpoints/EfficientNet_Check Loss On Init/results.json @@ -0,0 +1 @@ +{"name": "Check Loss On Init", "model": "EfficientNet", "runs": [{"scores": {"MulticlassAccuracy-validate": 0.00675999978557229, "CrossEntropyLoss-validate": 4.893486022949219}, "parameters": {"lr": 0.001, "model_name": "EfficientNet", "n_parameters": 7841894, "batch_size": 32, "train_samples": 50000, "val_samples": 10000}, "timestamp": "2023-12-02 11:14:53.975501", "successful": true, "hash": "eef024742b33fd04192b7c9fdc0c1124", "commit_id": "1b740ecf84c50de0b79fb155ef306ef622d92f08", "log_file_name": "2023-12-02_11-14-53_43361818-6469-4547-8a82-02be2670bd52.log"}]} \ No newline at end of file diff --git a/{{cookiecutter.project_slug}}/art_checkpoints/EfficientNet_Overfit One Batch/results.json b/{{cookiecutter.project_slug}}/art_checkpoints/EfficientNet_Overfit One Batch/results.json new file mode 100644 index 0000000..56745b1 --- /dev/null +++ b/{{cookiecutter.project_slug}}/art_checkpoints/EfficientNet_Overfit One Batch/results.json @@ -0,0 +1 @@ +{"name": "Overfit One Batch", "model": "EfficientNet", "runs": [{"scores": {"MulticlassAccuracy-train": 1.0, "CrossEntropyLoss-train": 2.902682354033459e-05}, "parameters": {"number_of_steps": 40, "lr": 0.001, "model_name": "EfficientNet", "n_parameters": 7841894, "batch_size": 32, "train_samples": 50000, "val_samples": 10000}, "timestamp": "2023-12-02 11:16:49.769266", "successful": true, "hash": "eef024742b33fd04192b7c9fdc0c1124", "commit_id": "1b740ecf84c50de0b79fb155ef306ef622d92f08", "model_path": "/content/ART-Templates/{{cookiecutter.project_slug}}/lightning_logs/version_7/checkpoints/epoch=39-step=40.ckpt", "MulticlassAccuracy-train": 1.0, "CrossEntropyLoss-train": 2.902682354033459e-05, "log_file_name": "2023-12-02_11-16-49_0704e137-3c69-4515-a943-bffe0f645f44.log"}]} \ No newline at end of file diff --git a/{{cookiecutter.project_slug}}/art_checkpoints/EfficientNet_Overfit/results.json b/{{cookiecutter.project_slug}}/art_checkpoints/EfficientNet_Overfit/results.json new file mode 100644 index 0000000..9bbe549 --- /dev/null +++ b/{{cookiecutter.project_slug}}/art_checkpoints/EfficientNet_Overfit/results.json @@ -0,0 +1 @@ +{"name": "Overfit", "model": "EfficientNet", "runs": [{"scores": {"MulticlassAccuracy-train": 0.9455999732017517, "CrossEntropyLoss-train": 0.16572201251983643, "MulticlassAccuracy-validate": 0.7613999843597412, "CrossEntropyLoss-validate": 1.1986972093582153}, "parameters": {"max_epochs": 10, "lr": 0.001, "model_name": "EfficientNet", "n_parameters": 7841894, "batch_size": 32, "train_samples": 50000, "val_samples": 10000}, "timestamp": "2023-12-02 11:17:52.515484", "successful": true, "hash": "eef024742b33fd04192b7c9fdc0c1124", "commit_id": "1b740ecf84c50de0b79fb155ef306ef622d92f08", "model_path": "/content/ART-Templates/{{cookiecutter.project_slug}}/lightning_logs/version_8/checkpoints/epoch=9-step=15630.ckpt", "log_file_name": "2023-12-02_11-17-52_fb7fe9c4-02bb-4a5b-8d37-bd257c6d9f85.log"}]} \ No newline at end of file diff --git a/{{cookiecutter.project_slug}}/art_checkpoints/EfficientNet_TransferLearning/results.json b/{{cookiecutter.project_slug}}/art_checkpoints/EfficientNet_TransferLearning/results.json new file mode 100644 index 0000000..d0652e7 --- /dev/null +++ b/{{cookiecutter.project_slug}}/art_checkpoints/EfficientNet_TransferLearning/results.json @@ -0,0 +1 @@ +{"name": "TransferLearning", "model": "EfficientNet", "runs": [{"scores": {"MulticlassAccuracy-train": 0.9606000185012817, "CrossEntropyLoss-train": 0.12111776322126389, "MulticlassAccuracy-validate": 0.7610999941825867, "CrossEntropyLoss-validate": 1.254715085029602}, "parameters": {"max_epochs": 2, "check_val_every_n_epoch": 2, "lr": 0.001, "model_name": "EfficientNet", "n_parameters": 7841894, "batch_size": 32, "train_samples": 50000, "val_samples": 10000}, "timestamp": "2023-12-02 10:02:36.630585", "successful": true, "hash": "eef024742b33fd04192b7c9fdc0c1124", "commit_id": "1b740ecf84c50de0b79fb155ef306ef622d92f08", "model_path": "/content/ART-Templates/{{cookiecutter.project_slug}}/.neptune/Untitled/TRAN-21/checkpoints/epoch=13-step=21882.ckpt", "log_file_name": "2023-12-02_10-02-40_686443d1-130e-496b-ae10-7619cf9ea9dc.log"}]} \ No newline at end of file diff --git a/{{cookiecutter.project_slug}}/art_checkpoints/HeuristicBaseline_Evaluate Baseline/results.json b/{{cookiecutter.project_slug}}/art_checkpoints/HeuristicBaseline_Evaluate Baseline/results.json new file mode 100644 index 0000000..646ddac --- /dev/null +++ b/{{cookiecutter.project_slug}}/art_checkpoints/HeuristicBaseline_Evaluate Baseline/results.json @@ -0,0 +1 @@ +{"name": "Evaluate Baseline", "model": "HeuristicBaseline", "runs": [{"scores": {"MulticlassAccuracy-validate": 0.012299999594688416}, "parameters": {}, "timestamp": "2023-12-02 11:10:00.493179", "successful": true, "hash": "06dbb6cfec9272cc2e03dc1e9f8f1846", "commit_id": "1b740ecf84c50de0b79fb155ef306ef622d92f08", "log_file_name": "2023-12-02_11-10-00_e6aac212-98e4-4836-9884-ba7e210a7b2a.log"}]} \ No newline at end of file diff --git a/{{cookiecutter.project_slug}}/art_checkpoints/MlBaseline_Evaluate Baseline/results.json b/{{cookiecutter.project_slug}}/art_checkpoints/MlBaseline_Evaluate Baseline/results.json new file mode 100644 index 0000000..4420aa1 --- /dev/null +++ b/{{cookiecutter.project_slug}}/art_checkpoints/MlBaseline_Evaluate Baseline/results.json @@ -0,0 +1 @@ +{"name": "Evaluate Baseline", "model": "MlBaseline", "runs": [{"scores": {"MulticlassAccuracy-validate": 0.15649999678134918}, "parameters": {}, "timestamp": "2023-12-02 11:10:00.493217", "successful": true, "hash": "49b251eb0a6cbddbbd5b185281399fa3", "commit_id": "1b740ecf84c50de0b79fb155ef306ef622d92f08", "log_file_name": "2023-12-02_11-10-00_e6aac212-98e4-4836-9884-ba7e210a7b2a.log"}]} \ No newline at end of file diff --git a/{{cookiecutter.project_slug}}/checks.py b/{{cookiecutter.project_slug}}/checks.py index e69de29..b34f406 100644 --- a/{{cookiecutter.project_slug}}/checks.py +++ b/{{cookiecutter.project_slug}}/checks.py @@ -0,0 +1,25 @@ +from art.checks import Check, CheckResult, ResultOfCheck +from art.steps import Step +from art.utils.savers import MatplotLibSaver + + +class CheckClassImagesExist(Check): + def check(self, step: Step) -> ResultOfCheck: + for class_name in step.get_latest_run()["class_names"]: + image_path = step.get_class_image_path(class_name) + if not MatplotLibSaver().exists(step.get_full_step_name(), image_path): + return ResultOfCheck( + is_positive=False, + error=f"Image for class: {class_name} does not exist. it should have been here: {MatplotLibSaver().get_path(step.get_full_step_name(), image_path)}", + ) + return ResultOfCheck(is_positive=True) + + +class CheckLenClassNamesEqualToNumClasses(CheckResult): + def _check_method(self, result) -> ResultOfCheck: + if len(result["class_names"]) != result["number_of_classes"]: + return ResultOfCheck( + is_positive=False, + error="Number of class names is different than number of classes", + ) + return ResultOfCheck(is_positive=True) diff --git a/{{cookiecutter.project_slug}}/dataset.py b/{{cookiecutter.project_slug}}/dataset.py index c6575da..61fcf93 100644 --- a/{{cookiecutter.project_slug}}/dataset.py +++ b/{{cookiecutter.project_slug}}/dataset.py @@ -1,14 +1,40 @@ -from lightning import LightningDataModule +import lightning as pl +from datasets import load_dataset from torch.utils.data import DataLoader -class MyDataModule(LightningDataModule): - def __init__(self): - super().__init__(...) - self.dataset = ... +class CifarDataModule(pl.LightningDataModule): + def __init__(self, batch_size: int = 32, num_workers: int = 4): + super().__init__() + self.batch_size = batch_size + self.dataset = load_dataset("cifar100").with_format("torch") + self.dataset = self.dataset.rename_columns( + {"img": "input", "fine_label": "target"} + ) + self.dataset = self.dataset.remove_columns(["coarse_label"]) + self.num_workers = num_workers + + def setup(self, stage: str): + self.train = self.dataset["train"] + self.test = self.dataset["test"] def train_dataloader(self): - return DataLoader(...) + return DataLoader( + self.dataset["train"], + batch_size=self.batch_size, + num_workers=self.num_workers, + ) def val_dataloader(self): - return DataLoader(...) + return DataLoader( + self.dataset["test"], + batch_size=self.batch_size, + num_workers=self.num_workers, + ) + + def log_params(self): + return { + "batch_size": self.batch_size, + "train_samples": len(self.dataset["train"]), + "val_samples": len(self.dataset["test"]), + } diff --git a/{{cookiecutter.project_slug}}/models/EfficientNet.py b/{{cookiecutter.project_slug}}/models/EfficientNet.py new file mode 100644 index 0000000..de8d7a7 --- /dev/null +++ b/{{cookiecutter.project_slug}}/models/EfficientNet.py @@ -0,0 +1,78 @@ +from typing import Dict, Any +from art.core import ArtModule +import torch +import timm +from torchvision import transforms +from einops import rearrange +from art.utils.enums import ( + BATCH, + INPUT, + LOSS, + PREDICTION, + TARGET, +) + + +class EfficientNet(ArtModule): + def __init__(self, num_classes: int = 100, lr: float = 1e-3): + super().__init__() + self.model = timm.create_model( + "efficientnet_b2.ra_in1k", pretrained=True, num_classes=num_classes + ) + self.lr = lr + self.preprocess = transforms.Compose( + [ + transforms.Normalize( + mean=[0.485, 0.456, 0.406], + std=[0.229, 0.224, 0.225], # statistics of ImageNet dataset + ), + transforms.Resize(256), # Size desired by this particular model + ] + ) + + def parse_data(self, data: Dict[str, Any]) -> Dict[str, Any]: + """ + This is first step of your pipeline it always has batch keys inside + The result of this step is passed to the next step in the pipeline which is predict + """ + X = data[BATCH][INPUT] + X = X / 255 + X = rearrange(X, "b h w c -> b c h w") + X = self.preprocess(X) + target = data[BATCH][TARGET].long() + return {INPUT: X, TARGET: target} + + def predict(self, data: Dict[str, Any]) -> Dict[str, Any]: + """ + This is the second step of your pipeline. The input of this step is the output of the previous step. + You should return a dictionary with PREDICTION and TARGET keys. + """ + return {PREDICTION: self.model(data[INPUT]), TARGET: data[TARGET]} + + def compute_loss(self, data: Dict[str, Any]) -> Dict[str, Any]: + """ + This is the last step of your pipeline. The input of this step is the output of the previous step. + You should return a dictionary with LOSS key. + You only need to specify which loss (metric) we want to use. + """ + loss = data["CrossEntropyLoss"] + return {LOSS: loss} + + def configure_optimizers(self) -> torch.optim.Optimizer: + """ + Set up your optimizer. + """ + return torch.optim.Adam(self.parameters(), lr=self.lr) + + def log_params(self) -> Dict[str, Any]: + """ + This is a method for logging relevant parameters. + It has to be implemented, however, it can be empty. + """ + return { + "lr": self.lr, + "model_name": self.model.__class__.__name__, + "n_parameters": sum( + p.numel() for p in self.parameters() if p.requires_grad + ), + } diff --git a/{{cookiecutter.project_slug}}/models/base_model.py b/{{cookiecutter.project_slug}}/models/base_model.py deleted file mode 100644 index 169eaa9..0000000 --- a/{{cookiecutter.project_slug}}/models/base_model.py +++ /dev/null @@ -1,5 +0,0 @@ -from art.core.base_components import ArtModule - - -class Model(ArtModule): - ... diff --git a/{{cookiecutter.project_slug}}/models/baselines.py b/{{cookiecutter.project_slug}}/models/baselines.py new file mode 100644 index 0000000..2888fe5 --- /dev/null +++ b/{{cookiecutter.project_slug}}/models/baselines.py @@ -0,0 +1,106 @@ +from typing import Dict, Any + +import numpy as np +from einops import rearrange +from sklearn.linear_model import LogisticRegression + +from art.core import ArtModule +from art.utils.enums import BATCH, INPUT, PREDICTION, TARGET + + +class MlBaseline(ArtModule): + name = "ML Baseline" + + def __init__(self, model: Any = LogisticRegression()): + super().__init__() + self.model = model + + def ml_parse_data(self, data: Dict): + X = [] + y = [] + for batch in data["dataloader"]: + X.append(batch[INPUT].flatten(start_dim=1).numpy() / 255) + y.append(batch[TARGET].numpy()) + + return {INPUT: np.concatenate(X), TARGET: np.concatenate(y)} + + def baseline_train(self, data: Dict): + self.model = self.model.fit(data[INPUT], data[TARGET]) + return {"model": self.model} + + def parse_data(self, data: Dict): + """This is first step of your pipeline it always has batch keys inside""" + batch = data[BATCH] + return { + INPUT: batch[INPUT].flatten(start_dim=1).numpy(), + TARGET: batch[TARGET].numpy(), + } + + def predict(self, data: Dict): + return {PREDICTION: self.model.predict(data[INPUT]), TARGET: data[TARGET]} + + def log_params(self): + return {"model": self.model.__class__.__name__} + + +class HeuristicBaseline(ArtModule): + name = "Heuristic Baseline" + n_classes = 100 + img_shape = (32, 32, 3) + + def __init__(self): + super().__init__() + + def parse_data(self, data: Dict): + """This is first step of your pipeline it always has batch keys inside""" + batch = data[BATCH] + return { + INPUT: batch[INPUT].flatten(start_dim=1).numpy(), + TARGET: batch[TARGET].numpy(), + } + + def baseline_train(self, data: Dict): + self.prototypes = np.zeros( + (self.n_classes, self.img_shape[0] * self.img_shape[1] * self.img_shape[2]) + ) + self.counts = np.zeros(self.n_classes) + for batch in data["dataloader"]: + for img, label in zip(batch[INPUT], batch[TARGET]): + self.prototypes[label.item()] += img.flatten().numpy() / 255 + self.counts[label.item()] += 1 + + self.prototypes = self.prototypes / self.counts[:, None] + + def predict(self, data: Dict): + y_hat = np.argmax((data[INPUT] @ self.prototypes.T), axis=1) + return {PREDICTION: y_hat, TARGET: data[TARGET]} + + def log_params(self): + return {"model": "Heuristic"} + + +class AlreadyExistingResNet20Baseline(ArtModule): + name = "Already Existing ResNet20 Baseline" + + def __init__(self): + super().__init__() + import torch + + self.model = torch.hub.load( + "chenyaofo/pytorch-cifar-models", "cifar100_resnet20", pretrained=True + ) + + def parse_data(self, data: Dict): + mean = np.asarray([0.5071, 0.4867, 0.4408], dtype=np.float32) + std = np.asarray([0.2675, 0.2565, 0.2761], dtype=np.float32) + X = data[BATCH][INPUT] + X = (X / 255 - mean) / std + X = rearrange(X, "b h w c -> b c h w") + return {INPUT: X, TARGET: data[BATCH][TARGET]} + + def predict(self, data: Dict): + preds = self.model(data[INPUT]).detach().numpy() + return {PREDICTION: preds, TARGET: data[TARGET]} + + def log_params(self): + return {"model": self.model.__class__.__name__} diff --git a/{{cookiecutter.project_slug}}/run.py b/{{cookiecutter.project_slug}}/run.py deleted file mode 100644 index a3d9755..0000000 --- a/{{cookiecutter.project_slug}}/run.py +++ /dev/null @@ -1,16 +0,0 @@ -from .models.base_model import Model -from .dataset import MyDataModule - -from art.experiment.Experiment import ArtProject - - -def main(): - data_module = MyDataModule() - model = Model() - project = ArtProject("{{cookiecutter.project_slug}}", data_module) - project.add_step(...) - project.run_all() - - -if __name__ == "__main__": - main() diff --git a/{{cookiecutter.project_slug}}/steps.py b/{{cookiecutter.project_slug}}/steps.py index e69de29..4e49855 100644 --- a/{{cookiecutter.project_slug}}/steps.py +++ b/{{cookiecutter.project_slug}}/steps.py @@ -0,0 +1,57 @@ +from collections import Counter +import numpy as np +import matplotlib.pyplot as plt +from art.utils.savers import MatplotLibSaver +from art.steps import ExploreData +from art.utils.enums import INPUT, TARGET + + +class DataAnalysis(ExploreData): + def do(self, previous_states): + targets = [] + index2label = ( + lambda x: self.datamodule.dataset["train"].features[TARGET].int2str(x) + ) + # Loop through batches in the cifar_datamodule train dataloader + for batch in self.datamodule.train_dataloader(): + targets.extend(batch[TARGET]) + targets = [index2label(int(x)) for x in targets] + # Calculate the number of unique classes in the targets + number_of_classes = len(np.unique(targets)) + # Now tell me what are the names of these classes + class_names = list(self.datamodule.dataset["train"].features[TARGET].names) + + # Now calculate number of images in each class + class_counts = Counter(targets) + + # Now tell me dimensions of each image + img_dimensions = self.datamodule.train_dataloader().dataset[0][INPUT].shape + for cls in class_names: + class_indices = [i for i, label in enumerate(targets) if label == cls] + class_samples = np.random.choice(class_indices, 5, replace=False).tolist() + + fig, axes = plt.subplots(1, 5, figsize=(15, 5)) + for i, sample_idx in enumerate(class_samples): + img = self.datamodule.train_dataloader().dataset[sample_idx][INPUT] + axes[i].imshow(img, cmap="gray") + axes[i].set_title(f"Class: {cls}") + axes[i].axis("off") + + MatplotLibSaver().save( + fig, self.get_full_step_name(), self.get_class_image_path(cls) + ) + + self.results.update( + { + "number_of_classes": number_of_classes, + "class_names": class_names, + "number_of_examples_in_each_class": class_counts, + "img_dimensions": img_dimensions, + } + ) + + def log_params(self): + return {} + + def get_class_image_path(self, class_name: str): + return f"class_images/class_{class_name}.png"