diff --git a/README.md b/README.md index 67716a7..27a8a3c 100644 --- a/README.md +++ b/README.md @@ -70,7 +70,7 @@ Curious to learn more about GPT-4 Vision? [Check out our GPT-4V experiments πŸ§ͺ WARNING: DO NOT EDIT THIS TABLE MANUALLY. IT IS AUTOMATICALLY GENERATED. HEAD OVER TO CONTRIBUTING.MD FOR MORE DETAILS ON HOW TO MAKE CHANGES PROPERLY. --> -## πŸš€ model tutorials (32 notebooks) +## πŸš€ model tutorials (34 notebooks) | **notebook** | **open in colab / kaggle / sagemaker studio lab** | **complementary materials** | **repository / paper** | |:------------:|:-------------------------------------------------:|:---------------------------:|:----------------------:| | [Zero-Shot Object Detection with YOLO-World](https://github.com/roboflow-ai/notebooks/blob/main/notebooks/zero-shot-object-detection-with-yolo-world.ipynb) | [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/zero-shot-object-detection-with-yolo-world.ipynb) [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/roboflow-ai/notebooks/blob/main/notebooks/zero-shot-object-detection-with-yolo-world.ipynb) [![SageMaker](https://raw.githubusercontent.com/roboflow-ai/notebooks/main/assets/badges/sage-maker.svg)](https://studiolab.sagemaker.aws/import/github/roboflow-ai/notebooks/blob/main/notebooks/zero-shot-object-detection-with-yolo-world.ipynb) | [![Roboflow](https://raw.githubusercontent.com/roboflow-ai/notebooks/main/assets/badges/roboflow-blogpost.svg)](https://blog.roboflow.com/what-is-yolo-world/) [![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://www.youtube.com/watch?v=X7gKBGVz4vs) | [![GitHub](https://badges.aleen42.com/src/github.svg)](https://github.com/AILab-CVC/YOLO-World) [![arXiv](https://img.shields.io/badge/arXiv-2401.17270-b31b1b.svg)](https://arxiv.org/abs/2401.17270)| @@ -105,6 +105,8 @@ Curious to learn more about GPT-4 Vision? [Check out our GPT-4V experiments πŸ§ͺ | [OpenAI Clip Classification](https://github.com/roboflow-ai/notebooks/blob/main/notebooks/how-to-use-openai-clip-classification.ipynb) | [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/how-to-use-openai-clip-classification.ipynb) [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/roboflow-ai/notebooks/blob/main/notebooks/how-to-use-openai-clip-classification.ipynb) | [![Roboflow](https://raw.githubusercontent.com/roboflow-ai/notebooks/main/assets/badges/roboflow-blogpost.svg)](https://blog.roboflow.com/how-to-use-openai-clip) [![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://www.youtube.com/watch?v=8o701AEoZ8I) | [![GitHub](https://badges.aleen42.com/src/github.svg)](https://github.com/openai/CLIP) [![arXiv](https://img.shields.io/badge/arXiv-2103.00020-b31b1b.svg)](https://arxiv.org/abs/2103.00020)| | [YOLOv4-tiny Darknet Object Detection](https://github.com/roboflow-ai/notebooks/blob/main/notebooks/train-yolov4-tiny-object-detection-on-custom-data.ipynb) | [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/train-yolov4-tiny-object-detection-on-custom-data.ipynb) [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/roboflow-ai/notebooks/blob/main/notebooks/train-yolov4-tiny-object-detection-on-custom-data.ipynb) | [![Roboflow](https://raw.githubusercontent.com/roboflow-ai/notebooks/main/assets/badges/roboflow-blogpost.svg)](https://blog.roboflow.ai/train-yolov4-tiny-on-custom-data-lighting-fast-detection) [![YouTube](https://badges.aleen42.com/src/youtube.svg)](https://www.youtube.com/watch?v=NTnZgLsk_DA) | [![GitHub](https://badges.aleen42.com/src/github.svg)](https://github.com/roboflow-ai/darknet) [![arXiv](https://img.shields.io/badge/arXiv-2011.04244-b31b1b.svg)](https://arxiv.org/abs/2011.04244)| | [Train a YOLOv8 Classification Model with No Labeling](https://github.com/roboflow-ai/notebooks/blob/main/notebooks/how-to-train-yolov8-classification-no-labeling.ipynb) | [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/how-to-train-yolov8-classification-no-labeling.ipynb) [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/roboflow-ai/notebooks/blob/main/notebooks/how-to-train-yolov8-classification-no-labeling.ipynb) [![SageMaker](https://raw.githubusercontent.com/roboflow-ai/notebooks/main/assets/badges/sage-maker.svg)](https://studiolab.sagemaker.aws/import/github/roboflow-ai/notebooks/blob/main/notebooks/how-to-train-yolov8-classification-no-labeling.ipynb) | [![Roboflow](https://raw.githubusercontent.com/roboflow-ai/notebooks/main/assets/badges/roboflow-blogpost.svg)](https://blog.roboflow.com/train-classification-model-no-labeling/) | [![GitHub](https://badges.aleen42.com/src/github.svg)](https://github.com/ultralytics/ultralytics) | +| [Image classification using DeiT](https://github.com/roboflow-ai/notebooks/blob/main/notebooks/train-DeiT-image-classifier-on-custom-data.ipynb) | [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/train-DeiT-image-classifier-on-custom-data.ipynb) [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/roboflow-ai/notebooks/blob/main/notebooks/train-DeiT-image-classifier-on-custom-data.ipynb) | | [![GitHub](https://badges.aleen42.com/src/github.svg)](https://github.com/facebookresearch/deit?tab=readme-ov-file) [![arXiv](https://img.shields.io/badge/arXiv-2012.12877-b31b1b.svg)](https://arxiv.org/abs/2012.12877)| +| [Image generation using DCGAN](https://github.com/roboflow-ai/notebooks/blob/main/notebooks/train-dcgan-on-custom-data.ipynb) | [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/train-dcgan-on-custom-data.ipynb) [![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/roboflow-ai/notebooks/blob/main/notebooks/train-dcgan-on-custom-data.ipynb) | | [![GitHub](https://badges.aleen42.com/src/github.svg)](https://github.com/pytorch/tutorials/blob/main/beginner_source/dcgan_faces_tutorial.py) [![arXiv](https://img.shields.io/badge/arXiv-1511.06434-b31b1b.svg)](https://arxiv.org/abs/1511.06434)| ## πŸ“Έ computer vision skills (18 notebooks) | **notebook** | **open in colab / kaggle / sagemaker studio lab** | **complementary materials** | **repository / paper** | |:------------:|:-------------------------------------------------:|:---------------------------:|:----------------------:| diff --git a/automation/notebooks-table-data.csv b/automation/notebooks-table-data.csv index 85d1a4b..f15f64b 100644 --- a/automation/notebooks-table-data.csv +++ b/automation/notebooks-table-data.csv @@ -49,3 +49,5 @@ Create Segmentation Masks with Roboflow, how-to-generate-segmentation-mask-with- How to Use PolygonZone and Roboflow Supervision, how-to-use-polygonzone-annotate-and-supervision.ipynb, https://blog.roboflow.com/polygonzone/, , , , False, skills Train a Package Detector With Two Labeled Images, train-package-detector-two-labeled-images.ipynb, https://blog.roboflow.com/package-detector/, , https://github.com/autodistill/autodistill-seggpt, , False, skills Image-to-Image Search with CLIP and faiss, image-to-image-search-clip-faiss.ipynb, https://blog.roboflow.com/clip-image-search-faiss/, , , , False, skills +Image classification using DeiT, train-DeiT-image-classifier-on-custom-data.ipynb, , ,https://github.com/facebookresearch/deit?tab=readme-ov-file, 2012.12877, False, models +Image generation using DCGAN, train-dcgan-on-custom-data.ipynb, , ,https://github.com/pytorch/tutorials/blob/main/beginner_source/dcgan_faces_tutorial.py, 1511.06434, False, models \ No newline at end of file diff --git a/notebooks/train-DeiT-image-classifier-on-custom-data.ipynb b/notebooks/train-DeiT-image-classifier-on-custom-data.ipynb new file mode 100644 index 0000000..21e15e5 --- /dev/null +++ b/notebooks/train-DeiT-image-classifier-on-custom-data.ipynb @@ -0,0 +1,396 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "Ahfft7Mc2Mea" + }, + "source": [ + "### Image Classification Using DeiT\n", + "Image classification is the canonical computer vision task of determining if an image contains a specific object, feature, or activity.\n", + "\n", + "This notebook demonstrates training an image classifi using Vision Transformers. This demonstration uses Data-efficient Image Transformers DeiT pretrained on ImageNet for image classification.\n", + "\n", + "\n", + "The DeiT model was proposed in [Training data-efficient image transformers & distillation through attention](https://arxiv.org/abs/2012.12877) by Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, HervΓ© JΓ©gou. The Vision Transformer (ViT) introduced in Dosovitskiy et al., 2020 has shown that one can match or even outperform existing convolutional neural networks using a Transformer encoder (BERT-like). However, the ViT models introduced in that paper required training on expensive infrastructure for multiple weeks, using external data. DeiT (data-efficient image transformers) are more efficiently trained transformers for image classification, requiring far less data and far less computing resources compared to the original ViT models.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "neyZKhsj6cqF" + }, + "source": [ + "We install roboflow first.\n", + "Also, we will be saving the checkpoints in the /content/checkpoints. So let's create that folder as well." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "v0P0TpdAtFrq" + }, + "outputs": [], + "source": [ + "import os\n", + "!pip3 install roboflow\n", + "os.mkdir('/content/checkpoints')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NAqe4Ux56phE" + }, + "source": [ + "## Import section" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "TRqrePOs319g" + }, + "outputs": [], + "source": [ + "import sys\n", + "import torch\n", + "import torch.nn as nn\n", + "import requests\n", + "from PIL import Image\n", + "from tqdm import tqdm\n", + "import torchvision.transforms as transforms\n", + "import torchvision.datasets as datasets\n", + "\n", + "from roboflow import Roboflow\n", + "from transformers import AutoImageProcessor, DeiTForImageClassification" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oC3hoJF86thi" + }, + "source": [ + "## Load the model\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "pIgyQi0q4Jke", + "outputId": "418a38b5-3811-4d83-ecb5-d250fbcc6d1e" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Could not find image processor class in the image processor config or the model config. Loading based on pattern matching with the model's feature extractor configuration. Please open a PR/issue to update `preprocessor_config.json` to use `image_processor_type` instead of `feature_extractor_type`. This warning will be removed in v4.40.\n", + "Some weights of DeiTForImageClassification were not initialized from the model checkpoint at facebook/deit-base-distilled-patch16-224 and are newly initialized: ['classifier.bias', 'classifier.weight']\n", + "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n" + ] + } + ], + "source": [ + "image_processor = AutoImageProcessor.from_pretrained(\"facebook/deit-base-distilled-patch16-224\")\n", + "model = DeiTForImageClassification.from_pretrained(\"facebook/deit-base-distilled-patch16-224\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LXczPIvt60ow" + }, + "source": [ + "## Vanilla inference\n", + "We will do the inference on the downloaded model on a test image." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "F2JRJcZa4SeC", + "outputId": "96a443ec-68bd-43c7-d29f-ae8819fde807" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting inference on pretrained model...\n", + "Predicted class: bucket, pail\n", + "Completed inference on pretrained model!\n", + "\n" + ] + } + ], + "source": [ + "print(\"Starting inference on pretrained model...\")\n", + "url = \"http://images.cocodataset.org/val2017/000000039769.jpg\"\n", + "image = Image.open(requests.get(url, stream=True).raw)\n", + "\n", + "inputs = image_processor(images=image, return_tensors=\"pt\")\n", + "outputs = model(**inputs)\n", + "logits = outputs.logits\n", + "# model predicts one of the 1000 ImageNet classes\n", + "predicted_class_idx = logits.argmax(-1).item()\n", + "print(\"Predicted class:\", model.config.id2label[predicted_class_idx])\n", + "print(\"Completed inference on pretrained model!\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ItaN4Eof7tZb" + }, + "source": [ + "## Load Data\n", + "We will be using a roboflow dataset. I am demonstrating this training pipeline using Tumour-Classification-1 dataset but you can use any dataset that you like.\n", + "\n", + "We will also prepare train and val dataloaders in this section." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MEUC3Sgd7UHI", + "outputId": "9b1b1333-9cf3-49a4-d009-8d31ebb53fed" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Commencing data download from roboflow...\n", + "loading Roboflow workspace...\n", + "loading Roboflow project...\n", + "Data download complete!\n", + "\n", + "Preparing dataloaders...\n", + "classes: ['glioma', 'meningioma', 'notumor', 'pituitary']\n", + "Dataloaders prepared!\n" + ] + } + ], + "source": [ + "print(\"Commencing data download from roboflow...\")\n", + "rf = Roboflow(api_key=\"\")\n", + "project = rf.workspace(\"brain-tumor-c6lzv\").project(\"tumor-classification-ufzoh\")\n", + "dataset = project.version(1).download(\"folder\")\n", + "print(\"Data download complete!\\n\")\n", + "\n", + "print(\"Preparing dataloaders...\")\n", + "\n", + "train_dir = './Tumor-Classification-1/train'\n", + "val_dir = './Tumor-Classification-1/valid'\n", + "\n", + "train_dataset = datasets.ImageFolder(train_dir, transforms.Compose([\n", + " transforms.Resize(224),\n", + " transforms.ToTensor()\n", + "]))\n", + "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=16, shuffle=True)\n", + "counter = 0\n", + "\n", + "val_dataset = datasets.ImageFolder(val_dir, transforms.Compose([\n", + " transforms.Resize(224),\n", + " transforms.ToTensor()\n", + "]))\n", + "val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=16, shuffle=True)\n", + "\n", + "print(\"classes: \", train_dataset.classes)\n", + "print(\"Dataloaders prepared!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WQrLoHrF7JVf" + }, + "source": [ + "## Training\n", + "Note: I have set the epochs to only 5 for demonstration purpose. You may use the appropriate number of epochs to get the desired finetuning." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "YIxh_dJrsdUl" + }, + "outputs": [], + "source": [ + "\n", + "class DeiT():\n", + "\n", + " def train(self, train_loader, model, criterion, optimizer, epoch):\n", + " model.train()\n", + " losses = []\n", + " running_loss = 0.0\n", + " running_corrects = 0\n", + "\n", + " print(\"training:\")\n", + " for input, target in tqdm(train_loader):\n", + " target = target.cuda()\n", + " input_var = torch.autograd.Variable(input).cuda()\n", + " target_var = torch.autograd.Variable(target).cuda()\n", + "\n", + " output = model(input_var)\n", + " _, preds = torch.max(output.logits, 1)\n", + " loss = criterion(output.logits.cuda(), target_var)\n", + "\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + " losses.append(loss.detach().cpu().numpy())\n", + "\n", + " running_loss += loss.detach().cpu().numpy() * input.size(0)\n", + " running_corrects += torch.sum(preds == target.data)\n", + "\n", + " return running_loss, running_corrects\n", + "\n", + " def validate(self, val_loader, model, criterion):\n", + "\n", + " model.eval()\n", + " running_loss = 0.0\n", + " running_corrects = 0\n", + " print(\"validation:\")\n", + " for input, target in tqdm(val_loader):\n", + " target = target.cuda()\n", + " input_var = torch.autograd.Variable(input, volatile=True).cuda()\n", + " target_var = torch.autograd.Variable(target, volatile=True).cuda()\n", + "\n", + " output = model(input_var)\n", + " _, preds = torch.max(output.logits, 1)\n", + " loss = criterion(output.logits.cuda(), target_var)\n", + "\n", + " running_loss += loss.detach().cpu().numpy() * input.size(0)\n", + " # print(running_loss)\n", + " running_corrects += torch.sum(preds == target.data)\n", + "\n", + " return running_loss, running_corrects\n", + "\n", + " def run(self):\n", + "\n", + " model.classifier = nn.Linear(model.classifier.in_features, 4)\n", + " criterion = nn.CrossEntropyLoss()\n", + " optimizer = torch.optim.SGD(model.parameters(), lr=0.005)\n", + " epochs = 5\n", + " model.cuda()\n", + "\n", + " print(\"Commencing training epochs...\")\n", + " for epoch in range(epochs):\n", + " print(\"\\nEpoch: \", epoch)\n", + "\n", + " # train for one epoch\n", + " train_loss, train_acc = self.train(train_loader, model, criterion, optimizer, epoch)\n", + " epoch_train_loss = train_loss / len(train_loader)\n", + " epoch_train_acc = train_acc.double() / len(train_loader)\n", + "\n", + " # evaluate on validation set\n", + " val_loss, val_acc = self.validate(val_loader, model, criterion)\n", + " epoch_val_loss = val_loss / len(val_loader)\n", + " epoch_val_acc = val_acc.double() / len(val_loader)\n", + "\n", + " print(f'train_acc: {epoch_train_acc:.4f} train_loss: {epoch_train_loss:.4f} val_acc: {epoch_val_acc:.4f} val_loss: {epoch_val_loss:.4f}')\n", + " PATH = '/content/checkpoints/epoch{epoch}_{loss:.2f}.pth'.format(epoch=epoch, loss=epoch_train_loss)\n", + " torch.save(model, PATH)\n", + "\n", + "\n", + "if __name__ == \"__main__\":\n", + " deit = DeiT()\n", + " deit.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-hfsRq1L8XNI" + }, + "source": [ + "## Testing\n", + "We will use the test data from the downloaded roboflow dataset.\n", + "Note: For the sake of demonstration, I have used the 4th checkpoint. You can use the best model for testing." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "7MvJsBYyTa_o" + }, + "outputs": [], + "source": [ + "# inference\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "EVAL_BATCH = 1\n", + "\n", + "test_dir = '/content/Tumor-Classification-1/test'\n", + "test_dataset = datasets.ImageFolder(test_dir, transforms.Compose([\n", + " transforms.Resize(224),\n", + " transforms.ToTensor()\n", + " ]))\n", + "test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=EVAL_BATCH, shuffle=True, num_workers=4)\n", + "\n", + "model = torch.load('/content/checkpoints/epoch4_0.37.pth')\n", + "model.eval()\n", + "\n", + "running_loss = 0.0\n", + "running_corrects = 0\n", + "classes = test_dataset.classes\n", + "print(\"classes: \", classes)\n", + "print(\"validation:\")\n", + "with torch.no_grad():\n", + " for input, target in test_loader:\n", + " target = target.cuda()\n", + " input_var = torch.autograd.Variable(input, volatile=True).cuda()\n", + " target_var = torch.autograd.Variable(target, volatile=True).cuda()\n", + "\n", + " output = model(input_var)\n", + " probabilities = torch.softmax(output.logits,dim=1)\n", + " pred = classes[torch.argmax(probabilities).detach().cpu().numpy()]\n", + " running_corrects += torch.sum(torch.tensor(pred == classes[target.detach().cpu().numpy()[0]]))\n", + "\n", + " print(\"PREDICTED: \", pred)\n", + " print(\"TARGET: \", classes[target.detach().cpu().numpy()[0]])\n", + " print(\"\\n\\n\")\n", + "\n", + "\n", + " test_acc = running_corrects.double() / len(test_loader)\n", + " print(\"test accuracy: \", test_acc.detach().cpu().numpy())\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/notebooks/train-dcgan-on-custom-data.ipynb b/notebooks/train-dcgan-on-custom-data.ipynb new file mode 100644 index 0000000..ae2d511 --- /dev/null +++ b/notebooks/train-dcgan-on-custom-data.ipynb @@ -0,0 +1,861 @@ +{ + "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": [ + "###DCGAN Image Generation\n", + "\n", + "GANs are a framework for teaching a deep learning model to capture the training data distribution so we can generate new data from that same distribution.\n", + "\n", + "The job of the discriminator is to look at an image and output whether or not it is a real training image or a fake image from the generator. During training, the generator is constantly trying to outsmart the discriminator by generating better and better fakes, while the discriminator is working to become a better detective and correctly classify the real and fake images. The equilibrium of this game is when the generator is generating perfect fakes that look as if they came directly from the training data, and the discriminator is left to always guess at 50% confidence that the generator output is real or fake.\n", + "\n", + "A DCGAN is a direct extension of the GAN described above, except that it explicitly uses convolutional and convolutional-transpose layers in the discriminator and generator, respectively." + ], + "metadata": { + "id": "FUDhSnXoec97" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Imports" + ], + "metadata": { + "id": "yQCIaDIqey9t" + } + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-sfi8NhtNw4z", + "outputId": "d36dd85b-175b-4818-cc13-0455e9d267ba" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Random Seed: 999\n" + ] + } + ], + "source": [ + "#%matplotlib inline\n", + "import argparse\n", + "import os\n", + "import random\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.parallel\n", + "import torch.optim as optim\n", + "import torch.utils.data\n", + "import torchvision.datasets as dset\n", + "import torchvision.transforms as transforms\n", + "import torchvision.utils as vutils\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.animation as animation\n", + "from IPython.display import HTML\n", + "from roboflow import Roboflow\n", + "\n", + "# Set random seed for reproducibility\n", + "manualSeed = 999\n", + "#manualSeed = random.randint(1, 10000) # use if you want new results\n", + "print(\"Random Seed: \", manualSeed)\n", + "random.seed(manualSeed)\n", + "torch.manual_seed(manualSeed)\n", + "torch.use_deterministic_algorithms(True) # Needed for reproducible results" + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Config" + ], + "metadata": { + "id": "poJBpl23e25l" + } + }, + { + "cell_type": "code", + "source": [ + "# Root directory for dataset\n", + "dataroot = \"/content/Tumor-Classification-1\"\n", + "\n", + "# Number of workers for dataloader\n", + "workers = 2\n", + "\n", + "# Batch size during training\n", + "batch_size = 128\n", + "\n", + "# Spatial size of training images. All images will be resized to this\n", + "# size using a transformer.\n", + "image_size = 64\n", + "\n", + "# Number of channels in the training images. For color images this is 3\n", + "nc = 3\n", + "\n", + "# Size of z latent vector (i.e. size of generator input)\n", + "nz = 100\n", + "\n", + "# Size of feature maps in generator\n", + "ngf = 64\n", + "\n", + "# Size of feature maps in discriminator\n", + "ndf = 64\n", + "\n", + "# Number of training epochs\n", + "num_epochs = 10\n", + "\n", + "# Learning rate for optimizers\n", + "lr = 0.0002\n", + "\n", + "# Beta1 hyperparameter for Adam optimizers\n", + "beta1 = 0.5\n", + "\n", + "# Number of GPUs available. Use 0 for CPU mode.\n", + "ngpu = 1" + ], + "metadata": { + "id": "eceQhuM8N4rb" + }, + "execution_count": 8, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Load the data\n", + "\n", + "We will be using a roboflow dataset. I am demonstrating this training pipeline using Tumour-Classification-1 dataset but you can use any dataset that you like.\n" + ], + "metadata": { + "id": "S0nEcClse8s4" + } + }, + { + "cell_type": "code", + "source": [ + "print(\"Commencing data download from roboflow...\")\n", + "rf = Roboflow(api_key=\" 0) else \"cpu\")\n", + "\n", + "# Plot some training images\n", + "real_batch = next(iter(dataloader))\n", + "plt.figure(figsize=(8,8))\n", + "plt.axis(\"off\")\n", + "plt.title(\"Training Images\")\n", + "plt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:64], padding=2, normalize=True).cpu(),(1,2,0)))\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 675 + }, + "id": "IZagwkUbOC-n", + "outputId": "50417b14-f036-435c-e9f5-0eb9f3ced98e" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Weight initialization\n", + "custom weights initialization called on netG and netD" + ], + "metadata": { + "id": "ooYNB_18fq6v" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "def weights_init(m):\n", + " classname = m.__class__.__name__\n", + " if classname.find('Conv') != -1:\n", + " nn.init.normal_(m.weight.data, 0.0, 0.02)\n", + " elif classname.find('BatchNorm') != -1:\n", + " nn.init.normal_(m.weight.data, 1.0, 0.02)\n", + " nn.init.constant_(m.bias.data, 0)" + ], + "metadata": { + "id": "4HWbCfD_OXmV" + }, + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Generator build\n", + "\n", + "Build the generator" + ], + "metadata": { + "id": "vu_vd97xf2Vd" + } + }, + { + "cell_type": "code", + "source": [ + "# Generator Code\n", + "\n", + "class Generator(nn.Module):\n", + " def __init__(self, ngpu):\n", + " super(Generator, self).__init__()\n", + " self.ngpu = ngpu\n", + " self.main = nn.Sequential(\n", + " # input is Z, going into a convolution\n", + " nn.ConvTranspose2d( nz, ngf * 8, 4, 1, 0, bias=False),\n", + " nn.BatchNorm2d(ngf * 8),\n", + " nn.ReLU(True),\n", + " # state size. ``(ngf*8) x 4 x 4``\n", + " nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),\n", + " nn.BatchNorm2d(ngf * 4),\n", + " nn.ReLU(True),\n", + " # state size. ``(ngf*4) x 8 x 8``\n", + " nn.ConvTranspose2d( ngf * 4, ngf * 2, 4, 2, 1, bias=False),\n", + " nn.BatchNorm2d(ngf * 2),\n", + " nn.ReLU(True),\n", + " # state size. ``(ngf*2) x 16 x 16``\n", + " nn.ConvTranspose2d( ngf * 2, ngf, 4, 2, 1, bias=False),\n", + " nn.BatchNorm2d(ngf),\n", + " nn.ReLU(True),\n", + " # state size. ``(ngf) x 32 x 32``\n", + " nn.ConvTranspose2d( ngf, nc, 4, 2, 1, bias=False),\n", + " nn.Tanh()\n", + " # state size. ``(nc) x 64 x 64``\n", + " )\n", + "\n", + " def forward(self, input):\n", + " return self.main(input)" + ], + "metadata": { + "id": "E22Co-DkOjT_" + }, + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Create the generator\n", + "netG = Generator(ngpu).to(device)\n", + "\n", + "# Handle multi-GPU if desired\n", + "if (device.type == 'cuda') and (ngpu > 1):\n", + " netG = nn.DataParallel(netG, list(range(ngpu)))\n", + "\n", + "# Apply the ``weights_init`` function to randomly initialize all weights\n", + "# to ``mean=0``, ``stdev=0.02``.\n", + "netG.apply(weights_init)\n", + "\n", + "# Print the model\n", + "print(netG)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uZOxPCreO_Jo", + "outputId": "8087275f-a121-4131-affd-0d4176459bef" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Generator(\n", + " (main): Sequential(\n", + " (0): ConvTranspose2d(100, 512, kernel_size=(4, 4), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): ConvTranspose2d(512, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (5): ReLU(inplace=True)\n", + " (6): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (7): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (8): ReLU(inplace=True)\n", + " (9): ConvTranspose2d(128, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (10): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (11): ReLU(inplace=True)\n", + " (12): ConvTranspose2d(64, 3, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (13): Tanh()\n", + " )\n", + ")\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Discriminator\n", + "Build the discriminator" + ], + "metadata": { + "id": "sj-ugag7f7wV" + } + }, + { + "cell_type": "code", + "source": [ + "class Discriminator(nn.Module):\n", + " def __init__(self, ngpu):\n", + " super(Discriminator, self).__init__()\n", + " self.ngpu = ngpu\n", + " self.main = nn.Sequential(\n", + " # input is ``(nc) x 64 x 64``\n", + " nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " # state size. ``(ndf) x 32 x 32``\n", + " nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),\n", + " nn.BatchNorm2d(ndf * 2),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " # state size. ``(ndf*2) x 16 x 16``\n", + " nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),\n", + " nn.BatchNorm2d(ndf * 4),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " # state size. ``(ndf*4) x 8 x 8``\n", + " nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),\n", + " nn.BatchNorm2d(ndf * 8),\n", + " nn.LeakyReLU(0.2, inplace=True),\n", + " # state size. ``(ndf*8) x 4 x 4``\n", + " nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),\n", + " nn.Sigmoid()\n", + " )\n", + "\n", + " def forward(self, input):\n", + " return self.main(input)" + ], + "metadata": { + "id": "wlL6jSCNPApJ" + }, + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Create the Discriminator\n", + "netD = Discriminator(ngpu).to(device)\n", + "\n", + "# Handle multi-GPU if desired\n", + "if (device.type == 'cuda') and (ngpu > 1):\n", + " netD = nn.DataParallel(netD, list(range(ngpu)))\n", + "\n", + "# Apply the ``weights_init`` function to randomly initialize all weights\n", + "# like this: ``to mean=0, stdev=0.2``.\n", + "netD.apply(weights_init)\n", + "\n", + "# Print the model\n", + "print(netD)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "iuud8mrLPCrc", + "outputId": "9dd615fa-8d6d-4db0-d9bb-915a5cb6e7a0" + }, + "execution_count": 12, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Discriminator(\n", + " (main): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): LeakyReLU(negative_slope=0.2, inplace=True)\n", + " (2): Conv2d(64, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (3): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (4): LeakyReLU(negative_slope=0.2, inplace=True)\n", + " (5): Conv2d(128, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (6): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (7): LeakyReLU(negative_slope=0.2, inplace=True)\n", + " (8): Conv2d(256, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (9): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (10): LeakyReLU(negative_slope=0.2, inplace=True)\n", + " (11): Conv2d(512, 1, kernel_size=(4, 4), stride=(1, 1), bias=False)\n", + " (12): Sigmoid()\n", + " )\n", + ")\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Loss function and optimizer setup" + ], + "metadata": { + "id": "ZTL3ll8cgAq6" + } + }, + { + "cell_type": "code", + "source": [ + "# Initialize the ``BCELoss`` function\n", + "criterion = nn.BCELoss()\n", + "\n", + "# Create batch of latent vectors that we will use to visualize\n", + "# the progression of the generator\n", + "fixed_noise = torch.randn(64, nz, 1, 1, device=device)\n", + "\n", + "# Establish convention for real and fake labels during training\n", + "real_label = 1.\n", + "fake_label = 0.\n", + "\n", + "# Setup Adam optimizers for both G and D\n", + "optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999))\n", + "optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))" + ], + "metadata": { + "id": "RnD6_jzhPD_F" + }, + "execution_count": 13, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Training" + ], + "metadata": { + "id": "M3XpTkJCgFiW" + } + }, + { + "cell_type": "code", + "source": [ + "# Training Loop\n", + "\n", + "# Lists to keep track of progress\n", + "img_list = []\n", + "G_losses = []\n", + "D_losses = []\n", + "fake_images = []\n", + "fake_images_1 = []\n", + "d_output = []\n", + "lr_list = []\n", + "fake_images_detached = []\n", + "iters = 0\n", + "\n", + "save_path = \"/content/results\"\n", + "checkpoint_path = \"/content/checkpoints\"\n", + "\n", + "if not os.path.exists('results'):\n", + " os.makedirs('results')\n", + "\n", + "if not os.path.exists('checkpoints'):\n", + " os.makedirs('checkpoints')\n", + "\n", + "img_num = 1\n", + "\n", + "def save_generated_image(generated_image, img_num):\n", + " file_name = str(img_num) + \".jpg\"\n", + " path = os.path.join(save_path, file_name)\n", + " # img_num += 1\n", + " vutils.save_image(generated_image, path)\n", + "\n", + "def save_checkpoint(epoch, loss, path):\n", + " torch.save({\n", + " 'epoch': epoch + 1,\n", + " 'model_state_dict': netG.state_dict(),\n", + " 'optimizer_state_dict': optimizerG.state_dict(),\n", + " 'loss': loss,\n", + " }, path)\n", + "\n", + "\n", + "print(\"Starting Training Loop...\")\n", + "# For each epoch\n", + "for epoch in range(num_epochs):\n", + " # For each batch in the dataloader\n", + " for i, data in enumerate(dataloader, 0):\n", + "\n", + " ############################\n", + " # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))\n", + " ###########################\n", + " ## Train with all-real batch\n", + " netD.zero_grad()\n", + " # Format batch\n", + " real_cpu = data[0].to(device)\n", + " b_size = real_cpu.size(0)\n", + " label = torch.full((b_size,), real_label, dtype=torch.float, device=device)\n", + "\n", + "\n", + " # Forward pass real batch through D\n", + " output = netD(real_cpu).view(-1)\n", + " # Calculate loss on all-real batch\n", + " errD_real = criterion(output, label)\n", + " # Calculate gradients for D in backward pass\n", + " errD_real.backward()\n", + " D_x = output.mean().item()\n", + "\n", + " ## Train with all-fake batch\n", + " # Generate batch of latent vectors\n", + " noise = torch.randn(b_size, nz, 1, 1, device=device)\n", + " # Generate fake image batch with G\n", + " fake = netG(noise)\n", + " label.fill_(fake_label)\n", + " # Classify all fake batch with D\n", + " output = netD(fake.detach()).view(-1)\n", + " # Calculate D's loss on the all-fake batch\n", + " errD_fake = criterion(output, label)\n", + " # Calculate the gradients for this batch, accumulated (summed) with previous gradients\n", + " errD_fake.backward()\n", + " D_G_z1 = output.mean().item()\n", + " # Compute error of D as sum over the fake and the real batches\n", + " errD = errD_real + errD_fake\n", + " # Update D\n", + " optimizerD.step()\n", + "\n", + " ############################\n", + " # (2) Update G network: maximize log(D(G(z)))\n", + " ###########################\n", + " netG.zero_grad()\n", + " label.fill_(real_label) # fake labels are real for generator cost\n", + " # Since we just updated D, perform another forward pass of all-fake batch through D\n", + " output = netD(fake).view(-1)\n", + " # Calculate G's loss based on this output\n", + " errG = criterion(output, label)\n", + " # Calculate gradients for G\n", + " errG.backward()\n", + " D_G_z2 = output.mean().item()\n", + " # Update G\n", + " optimizerG.step()\n", + "\n", + " # Output training stats\n", + " if i % 50 == 0:\n", + " print('[%d/%d][%d/%d]\\tLoss_D: %.4f\\tLoss_G: %.4f\\tD(x): %.4f\\tD(G(z)): %.4f / %.4f'\n", + " % (epoch, num_epochs, i, len(dataloader),\n", + " errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))\n", + "\n", + " # Save Losses for plotting later\n", + " G_losses.append(errG.item())\n", + " D_losses.append(errD.item())\n", + "\n", + " # Check how the generator is doing by saving G's output on fixed_noise\n", + " if (iters % 500 == 0) or ((epoch == num_epochs-1) and (i == len(dataloader)-1)):\n", + " with torch.no_grad():\n", + " fake = netG(fixed_noise).detach().cpu()\n", + "\n", + " save_generated_image(fake, img_num)\n", + " img_num += 1\n", + " fake_images.append(fake)\n", + " for image in fake:\n", + " fake_images_1.append(image)\n", + "\n", + " img_list.append(vutils.make_grid(fake, padding=2, normalize=True))\n", + " print(\"lr: \",lr)\n", + " lr_list.append(lr)\n", + "\n", + " iters += 1\n", + "\n", + " #saving checkpoints\n", + " path = \"./checkpoints/\" + str(epoch) + \"_\" + str(errG.item()) + \".pt\"\n", + " save_checkpoint(epoch, errG.item(), path)" + ], + "metadata": { + "id": "_j32WL_BPF2q" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Plot the Generator and Discriminator loss" + ], + "metadata": { + "id": "UXNb9E8qgJF-" + } + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(10,5))\n", + "plt.title(\"Generator and Discriminator Loss During Training\")\n", + "plt.plot(G_losses,label=\"G\")\n", + "plt.plot(D_losses,label=\"D\")\n", + "plt.xlabel(\"iterations\")\n", + "plt.ylabel(\"Loss\")\n", + "plt.legend()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "id": "LmPlVV_3d_Wl", + "outputId": "de56264c-26d2-420b-bec4-b71de96d2f06" + }, + "execution_count": 15, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Testing\n", + "Generate image using the last epoch weights" + ], + "metadata": { + "id": "Mk4JaJ-vgO3P" + } + }, + { + "cell_type": "code", + "source": [ + "# Grab a batch of real images from the dataloader\n", + "real_batch = next(iter(dataloader))\n", + "\n", + "# Plot the real images\n", + "plt.figure(figsize=(15,15))\n", + "plt.subplot(1,2,1)\n", + "plt.axis(\"off\")\n", + "plt.title(\"Real Images\")\n", + "plt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:64], padding=5, normalize=True).cpu(),(1,2,0)))\n", + "\n", + "# Plot the fake images from the last epoch\n", + "plt.subplot(1,2,2)\n", + "plt.axis(\"off\")\n", + "plt.title(\"Fake Images\")\n", + "plt.imshow(np.transpose(img_list[-1],(1,2,0)))\n", + "plt.show()" + ], + "metadata": { + "id": "YjnXiZd_eCkD" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Testing on checkpoints\n", + "Here i will demonstrate how to load any desired checkpoint and generate images." + ], + "metadata": { + "id": "OoIq-oAvgX6n" + } + }, + { + "cell_type": "code", + "source": [ + "import torchvision\n", + "checkpoint = torch.load('/path/to/checkpoint')\n", + "netG.load_state_dict(checkpoint['model_state_dict'])\n", + "\n", + "netG.eval()\n", + "\n", + "noise = torch.randn(batch_size, nz, 1, 1, device=device)\n", + "fake_images = netG(noise)\n", + "print(type(fake_images), len(fake_images))\n", + "grid = torchvision.utils.make_grid(fake_images, nrow=8, padding=2, normalize=True) # Adjust nrow for the number of images per row\n", + "\n", + "# Convert grid tensor to numpy array for plotting\n", + "grid_np = grid.permute(1, 2, 0).cpu().numpy() # Change the tensor layout from (C, H, W) to (H, W, C)\n", + "# Normalize pixel values to [0, 1] for matplotlib\n", + "grid_np = (grid_np - grid_np.min()) / (grid_np.max() - grid_np.min())\n", + "\n", + "# Display the grid of images using matplotlib\n", + "plt.figure(figsize=(10, 10))\n", + "plt.imshow(grid_np)\n", + "plt.axis('off')\n", + "plt.show()" + ], + "metadata": { + "id": "m0JEsRSWeD4r" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "QmS3wXgteD7g" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "aoOAnyCCeD-Y" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!rm /content/checkpoints/*.pt" + ], + "metadata": { + "id": "rr_m3XxuPJF3" + }, + "execution_count": 48, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!pip3 install roboflow" + ], + "metadata": { + "id": "fmagzoAMZxuw" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "p5pilyDMc7cF" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file