Add Model

Coding_Challenge_for_Fatima_Fellowship.ipynb

@@ -0,0 +1,1294 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "name": "Coding Challenge for Fatima Fellowship",
+      "provenance": [],
+      "collapsed_sections": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "accelerator": "GPU",
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "b6f3481b22fa43758c6273992d49f800": {
+          "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_163c4c11370d46e39fed08c38cc64965",
+              "IPY_MODEL_90467627aa984891907e43169ebf2c64",
+              "IPY_MODEL_c5bbd049370f4925a6ad3a548341512f"
+            ],
+            "layout": "IPY_MODEL_469c0688a66c4140b0c22402877bfc31"
+          }
+        },
+        "163c4c11370d46e39fed08c38cc64965": {
+          "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_e6b62974b70349caa135ad10e461c546",
+            "placeholder": "​",
+            "style": "IPY_MODEL_b6886b2850104e719ec862a29a977548",
+            "value": "100%"
+          }
+        },
+        "90467627aa984891907e43169ebf2c64": {
+          "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_2f72dc13ee934d0cb360b7b6fbfdbe1b",
+            "max": 2,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_1c011147729f4bbfba0b6ef1455144de",
+            "value": 2
+          }
+        },
+        "c5bbd049370f4925a6ad3a548341512f": {
+          "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_2b071dcb5f9a4291bef5d9ff9f7053c5",
+            "placeholder": "​",
+            "style": "IPY_MODEL_efba12ce4437427bb45b578709e85c32",
+            "value": " 2/2 [00:00<00:00, 46.22it/s]"
+          }
+        },
+        "469c0688a66c4140b0c22402877bfc31": {
+          "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
+          }
+        },
+        "e6b62974b70349caa135ad10e461c546": {
+          "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
+          }
+        },
+        "b6886b2850104e719ec862a29a977548": {
+          "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": ""
+          }
+        },
+        "2f72dc13ee934d0cb360b7b6fbfdbe1b": {
+          "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
+          }
+        },
+        "1c011147729f4bbfba0b6ef1455144de": {
+          "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": ""
+          }
+        },
+        "2b071dcb5f9a4291bef5d9ff9f7053c5": {
+          "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
+          }
+        },
+        "efba12ce4437427bb45b578709e85c32": {
+          "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",
+      "metadata": {
+        "id": "eBpjBBZc6IvA"
+      },
+      "source": [
+        "# Fatima Fellowship Quick Coding Challenge (Pick 1)\n",
+        "\n",
+        "Thank you for applying to the Fatima Fellowship. To help us select the Fellows and assess your ability to do machine learning research, we are asking that you complete a short coding challenge. Please pick **1 of these 5** coding challenges, whichever is most aligned with your interests. \n",
+        "\n",
+        "**Due date: 1 week**\n",
+        "\n",
+        "**How to submit**: Please make a copy of this colab notebook, add your code and results, and submit your colab notebook to the submission link below. If you have never used a colab notebook, [check out this video](https://www.youtube.com/watch?v=i-HnvsehuSw).\n",
+        "\n",
+        "**Submission link**: https://airtable.com/shrXy3QKSsO2yALd3"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "braBzmRpMe7_"
+      },
+      "source": [
+        "# 1. Deep Learning for Vision"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "1IWw-NZf5WfF"
+      },
+      "source": [
+        "**Upside down detector**: Train a model to detect if images are upside down\n",
+        "\n",
+        "* Pick a dataset of natural images (we suggest looking at datasets on the [Hugging Face Hub](https://huggingface.co/datasets?task_categories=task_categories:image-classification&sort=downloads))\n",
+        "* Synthetically turn some of images upside down. Create a training and test set.\n",
+        "* Build a neural network (using Tensorflow, PyTorch, or any framework you like)\n",
+        "* Train it to classify image orientation until a reasonable accuracy is reached\n",
+        "* [Upload the the model to the Hugging Face Hub](https://huggingface.co/docs/hub/adding-a-model), and add a link to your model below.\n",
+        "* Look at some of the images that were classified incorrectly. Please explain what you might do to improve your model's performance on these images in the future (you do not need to impelement these suggestions)\n",
+        "\n",
+        "**Submission instructions**: Please write your code below and include some examples of images that were classified"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Self-Supervised Learning for the rescue"
+      ],
+      "metadata": {
+        "id": "nI7wrS6ETRx1"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# !pip install opencv-python-headless==4.5.2.52\n",
+        "# !pip install -q fiftyone\n",
+        "\n",
+        "!pip install -q datasets"
+      ],
+      "metadata": {
+        "id": "98u1eeCDTz6K"
+      },
+      "execution_count": 1,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# import fiftyone\n",
+        "\n",
+        "# dataset = fiftyone.zoo.load_zoo_dataset(\"open-images-v6\", split=\"validation\", max_samples=50000)\n",
+        "# dataset\n",
+        "\n",
+        "from datasets import load_dataset\n",
+        "\n",
+        "dataset = load_dataset(\"cifar10\")\n",
+        "print(dataset.keys())\n",
+        "all_images = dataset[\"train\"][\"img\"] + dataset[\"test\"][\"img\"]\n",
+        "print(len(all_images))"
+      ],
+      "metadata": {
+        "id": "K2GJaYBpw91T",
+        "outputId": "9d6808f5-c63e-43d2-cb0d-ec3b2fae6628",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 104,
+          "referenced_widgets": [
+            "b6f3481b22fa43758c6273992d49f800",
+            "163c4c11370d46e39fed08c38cc64965",
+            "90467627aa984891907e43169ebf2c64",
+            "c5bbd049370f4925a6ad3a548341512f",
+            "469c0688a66c4140b0c22402877bfc31",
+            "e6b62974b70349caa135ad10e461c546",
+            "b6886b2850104e719ec862a29a977548",
+            "2f72dc13ee934d0cb360b7b6fbfdbe1b",
+            "1c011147729f4bbfba0b6ef1455144de",
+            "2b071dcb5f9a4291bef5d9ff9f7053c5",
+            "efba12ce4437427bb45b578709e85c32"
+          ]
+        }
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "Reusing dataset cifar10 (/root/.cache/huggingface/datasets/cifar10/plain_text/1.0.0/447d6ec4733dddd1ce3bb577c7166b986eaa4c538dcd9e805ba61f35674a9de4)\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "  0%|          | 0/2 [00:00<?, ?it/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "b6f3481b22fa43758c6273992d49f800"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "dict_keys(['train', 'test'])\n",
+            "60000\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from torchvision.transforms.functional import rotate\n",
+        "import torchvision.models as models\n",
+        "from torch import nn\n",
+        "from torchsummary import summary\n",
+        "\n",
+        "angles = [0, 45, 90, 135, 180, 225, 270, 315]\n",
+        "\n",
+        "class NeuralNetwork(nn.Module):\n",
+        "    def __init__(self, n_labels):\n",
+        "        super(NeuralNetwork, self).__init__()\n",
+        "        self.backbone = models.mobilenet_v3_large()\n",
+        "        self.flatten = nn.Flatten()\n",
+        "        self.linear_relu_stack = nn.Sequential(\n",
+        "            nn.Linear(1000, 512),\n",
+        "            nn.ReLU(),\n",
+        "            nn.Linear(512, 512),\n",
+        "            nn.ReLU(),\n",
+        "            nn.Linear(512, n_labels),\n",
+        "            nn.Softmax(),\n",
+        "        )\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        x = self.backbone(x)\n",
+        "        x = self.flatten(x)\n",
+        "        logits = self.linear_relu_stack(x)\n",
+        "        return logits\n",
+        "\n",
+        "model = NeuralNetwork(len(angles))\n",
+        "summary(model.cuda(), (3,224,224))\n"
+      ],
+      "metadata": {
+        "id": "N6qubMbsUI05",
+        "outputId": "f7c4f07f-3d55-41be-966d-2ae3e72d45d4",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "----------------------------------------------------------------\n",
+            "        Layer (type)               Output Shape         Param #\n",
+            "================================================================\n",
+            "            Conv2d-1         [-1, 16, 112, 112]             432\n",
+            "       BatchNorm2d-2         [-1, 16, 112, 112]              32\n",
+            "         Hardswish-3         [-1, 16, 112, 112]               0\n",
+            "            Conv2d-4         [-1, 16, 112, 112]             144\n",
+            "       BatchNorm2d-5         [-1, 16, 112, 112]              32\n",
+            "              ReLU-6         [-1, 16, 112, 112]               0\n",
+            "            Conv2d-7         [-1, 16, 112, 112]             256\n",
+            "       BatchNorm2d-8         [-1, 16, 112, 112]              32\n",
+            "  InvertedResidual-9         [-1, 16, 112, 112]               0\n",
+            "           Conv2d-10         [-1, 64, 112, 112]           1,024\n",
+            "      BatchNorm2d-11         [-1, 64, 112, 112]             128\n",
+            "             ReLU-12         [-1, 64, 112, 112]               0\n",
+            "           Conv2d-13           [-1, 64, 56, 56]             576\n",
+            "      BatchNorm2d-14           [-1, 64, 56, 56]             128\n",
+            "             ReLU-15           [-1, 64, 56, 56]               0\n",
+            "           Conv2d-16           [-1, 24, 56, 56]           1,536\n",
+            "      BatchNorm2d-17           [-1, 24, 56, 56]              48\n",
+            " InvertedResidual-18           [-1, 24, 56, 56]               0\n",
+            "           Conv2d-19           [-1, 72, 56, 56]           1,728\n",
+            "      BatchNorm2d-20           [-1, 72, 56, 56]             144\n",
+            "             ReLU-21           [-1, 72, 56, 56]               0\n",
+            "           Conv2d-22           [-1, 72, 56, 56]             648\n",
+            "      BatchNorm2d-23           [-1, 72, 56, 56]             144\n",
+            "             ReLU-24           [-1, 72, 56, 56]               0\n",
+            "           Conv2d-25           [-1, 24, 56, 56]           1,728\n",
+            "      BatchNorm2d-26           [-1, 24, 56, 56]              48\n",
+            " InvertedResidual-27           [-1, 24, 56, 56]               0\n",
+            "           Conv2d-28           [-1, 72, 56, 56]           1,728\n",
+            "      BatchNorm2d-29           [-1, 72, 56, 56]             144\n",
+            "             ReLU-30           [-1, 72, 56, 56]               0\n",
+            "           Conv2d-31           [-1, 72, 28, 28]           1,800\n",
+            "      BatchNorm2d-32           [-1, 72, 28, 28]             144\n",
+            "             ReLU-33           [-1, 72, 28, 28]               0\n",
+            "AdaptiveAvgPool2d-34             [-1, 72, 1, 1]               0\n",
+            "           Conv2d-35             [-1, 24, 1, 1]           1,752\n",
+            "             ReLU-36             [-1, 24, 1, 1]               0\n",
+            "           Conv2d-37             [-1, 72, 1, 1]           1,800\n",
+            "      Hardsigmoid-38             [-1, 72, 1, 1]               0\n",
+            "SqueezeExcitation-39           [-1, 72, 28, 28]               0\n",
+            "           Conv2d-40           [-1, 40, 28, 28]           2,880\n",
+            "      BatchNorm2d-41           [-1, 40, 28, 28]              80\n",
+            " InvertedResidual-42           [-1, 40, 28, 28]               0\n",
+            "           Conv2d-43          [-1, 120, 28, 28]           4,800\n",
+            "      BatchNorm2d-44          [-1, 120, 28, 28]             240\n",
+            "             ReLU-45          [-1, 120, 28, 28]               0\n",
+            "           Conv2d-46          [-1, 120, 28, 28]           3,000\n",
+            "      BatchNorm2d-47          [-1, 120, 28, 28]             240\n",
+            "             ReLU-48          [-1, 120, 28, 28]               0\n",
+            "AdaptiveAvgPool2d-49            [-1, 120, 1, 1]               0\n",
+            "           Conv2d-50             [-1, 32, 1, 1]           3,872\n",
+            "             ReLU-51             [-1, 32, 1, 1]               0\n",
+            "           Conv2d-52            [-1, 120, 1, 1]           3,960\n",
+            "      Hardsigmoid-53            [-1, 120, 1, 1]               0\n",
+            "SqueezeExcitation-54          [-1, 120, 28, 28]               0\n",
+            "           Conv2d-55           [-1, 40, 28, 28]           4,800\n",
+            "      BatchNorm2d-56           [-1, 40, 28, 28]              80\n",
+            " InvertedResidual-57           [-1, 40, 28, 28]               0\n",
+            "           Conv2d-58          [-1, 120, 28, 28]           4,800\n",
+            "      BatchNorm2d-59          [-1, 120, 28, 28]             240\n",
+            "             ReLU-60          [-1, 120, 28, 28]               0\n",
+            "           Conv2d-61          [-1, 120, 28, 28]           3,000\n",
+            "      BatchNorm2d-62          [-1, 120, 28, 28]             240\n",
+            "             ReLU-63          [-1, 120, 28, 28]               0\n",
+            "AdaptiveAvgPool2d-64            [-1, 120, 1, 1]               0\n",
+            "           Conv2d-65             [-1, 32, 1, 1]           3,872\n",
+            "             ReLU-66             [-1, 32, 1, 1]               0\n",
+            "           Conv2d-67            [-1, 120, 1, 1]           3,960\n",
+            "      Hardsigmoid-68            [-1, 120, 1, 1]               0\n",
+            "SqueezeExcitation-69          [-1, 120, 28, 28]               0\n",
+            "           Conv2d-70           [-1, 40, 28, 28]           4,800\n",
+            "      BatchNorm2d-71           [-1, 40, 28, 28]              80\n",
+            " InvertedResidual-72           [-1, 40, 28, 28]               0\n",
+            "           Conv2d-73          [-1, 240, 28, 28]           9,600\n",
+            "      BatchNorm2d-74          [-1, 240, 28, 28]             480\n",
+            "        Hardswish-75          [-1, 240, 28, 28]               0\n",
+            "           Conv2d-76          [-1, 240, 14, 14]           2,160\n",
+            "      BatchNorm2d-77          [-1, 240, 14, 14]             480\n",
+            "        Hardswish-78          [-1, 240, 14, 14]               0\n",
+            "           Conv2d-79           [-1, 80, 14, 14]          19,200\n",
+            "      BatchNorm2d-80           [-1, 80, 14, 14]             160\n",
+            " InvertedResidual-81           [-1, 80, 14, 14]               0\n",
+            "           Conv2d-82          [-1, 200, 14, 14]          16,000\n",
+            "      BatchNorm2d-83          [-1, 200, 14, 14]             400\n",
+            "        Hardswish-84          [-1, 200, 14, 14]               0\n",
+            "           Conv2d-85          [-1, 200, 14, 14]           1,800\n",
+            "      BatchNorm2d-86          [-1, 200, 14, 14]             400\n",
+            "        Hardswish-87          [-1, 200, 14, 14]               0\n",
+            "           Conv2d-88           [-1, 80, 14, 14]          16,000\n",
+            "      BatchNorm2d-89           [-1, 80, 14, 14]             160\n",
+            " InvertedResidual-90           [-1, 80, 14, 14]               0\n",
+            "           Conv2d-91          [-1, 184, 14, 14]          14,720\n",
+            "      BatchNorm2d-92          [-1, 184, 14, 14]             368\n",
+            "        Hardswish-93          [-1, 184, 14, 14]               0\n",
+            "           Conv2d-94          [-1, 184, 14, 14]           1,656\n",
+            "      BatchNorm2d-95          [-1, 184, 14, 14]             368\n",
+            "        Hardswish-96          [-1, 184, 14, 14]               0\n",
+            "           Conv2d-97           [-1, 80, 14, 14]          14,720\n",
+            "      BatchNorm2d-98           [-1, 80, 14, 14]             160\n",
+            " InvertedResidual-99           [-1, 80, 14, 14]               0\n",
+            "          Conv2d-100          [-1, 184, 14, 14]          14,720\n",
+            "     BatchNorm2d-101          [-1, 184, 14, 14]             368\n",
+            "       Hardswish-102          [-1, 184, 14, 14]               0\n",
+            "          Conv2d-103          [-1, 184, 14, 14]           1,656\n",
+            "     BatchNorm2d-104          [-1, 184, 14, 14]             368\n",
+            "       Hardswish-105          [-1, 184, 14, 14]               0\n",
+            "          Conv2d-106           [-1, 80, 14, 14]          14,720\n",
+            "     BatchNorm2d-107           [-1, 80, 14, 14]             160\n",
+            "InvertedResidual-108           [-1, 80, 14, 14]               0\n",
+            "          Conv2d-109          [-1, 480, 14, 14]          38,400\n",
+            "     BatchNorm2d-110          [-1, 480, 14, 14]             960\n",
+            "       Hardswish-111          [-1, 480, 14, 14]               0\n",
+            "          Conv2d-112          [-1, 480, 14, 14]           4,320\n",
+            "     BatchNorm2d-113          [-1, 480, 14, 14]             960\n",
+            "       Hardswish-114          [-1, 480, 14, 14]               0\n",
+            "AdaptiveAvgPool2d-115            [-1, 480, 1, 1]               0\n",
+            "          Conv2d-116            [-1, 120, 1, 1]          57,720\n",
+            "            ReLU-117            [-1, 120, 1, 1]               0\n",
+            "          Conv2d-118            [-1, 480, 1, 1]          58,080\n",
+            "     Hardsigmoid-119            [-1, 480, 1, 1]               0\n",
+            "SqueezeExcitation-120          [-1, 480, 14, 14]               0\n",
+            "          Conv2d-121          [-1, 112, 14, 14]          53,760\n",
+            "     BatchNorm2d-122          [-1, 112, 14, 14]             224\n",
+            "InvertedResidual-123          [-1, 112, 14, 14]               0\n",
+            "          Conv2d-124          [-1, 672, 14, 14]          75,264\n",
+            "     BatchNorm2d-125          [-1, 672, 14, 14]           1,344\n",
+            "       Hardswish-126          [-1, 672, 14, 14]               0\n",
+            "          Conv2d-127          [-1, 672, 14, 14]           6,048\n",
+            "     BatchNorm2d-128          [-1, 672, 14, 14]           1,344\n",
+            "       Hardswish-129          [-1, 672, 14, 14]               0\n",
+            "AdaptiveAvgPool2d-130            [-1, 672, 1, 1]               0\n",
+            "          Conv2d-131            [-1, 168, 1, 1]         113,064\n",
+            "            ReLU-132            [-1, 168, 1, 1]               0\n",
+            "          Conv2d-133            [-1, 672, 1, 1]         113,568\n",
+            "     Hardsigmoid-134            [-1, 672, 1, 1]               0\n",
+            "SqueezeExcitation-135          [-1, 672, 14, 14]               0\n",
+            "          Conv2d-136          [-1, 112, 14, 14]          75,264\n",
+            "     BatchNorm2d-137          [-1, 112, 14, 14]             224\n",
+            "InvertedResidual-138          [-1, 112, 14, 14]               0\n",
+            "          Conv2d-139          [-1, 672, 14, 14]          75,264\n",
+            "     BatchNorm2d-140          [-1, 672, 14, 14]           1,344\n",
+            "       Hardswish-141          [-1, 672, 14, 14]               0\n",
+            "          Conv2d-142            [-1, 672, 7, 7]          16,800\n",
+            "     BatchNorm2d-143            [-1, 672, 7, 7]           1,344\n",
+            "       Hardswish-144            [-1, 672, 7, 7]               0\n",
+            "AdaptiveAvgPool2d-145            [-1, 672, 1, 1]               0\n",
+            "          Conv2d-146            [-1, 168, 1, 1]         113,064\n",
+            "            ReLU-147            [-1, 168, 1, 1]               0\n",
+            "          Conv2d-148            [-1, 672, 1, 1]         113,568\n",
+            "     Hardsigmoid-149            [-1, 672, 1, 1]               0\n",
+            "SqueezeExcitation-150            [-1, 672, 7, 7]               0\n",
+            "          Conv2d-151            [-1, 160, 7, 7]         107,520\n",
+            "     BatchNorm2d-152            [-1, 160, 7, 7]             320\n",
+            "InvertedResidual-153            [-1, 160, 7, 7]               0\n",
+            "          Conv2d-154            [-1, 960, 7, 7]         153,600\n",
+            "     BatchNorm2d-155            [-1, 960, 7, 7]           1,920\n",
+            "       Hardswish-156            [-1, 960, 7, 7]               0\n",
+            "          Conv2d-157            [-1, 960, 7, 7]          24,000\n",
+            "     BatchNorm2d-158            [-1, 960, 7, 7]           1,920\n",
+            "       Hardswish-159            [-1, 960, 7, 7]               0\n",
+            "AdaptiveAvgPool2d-160            [-1, 960, 1, 1]               0\n",
+            "          Conv2d-161            [-1, 240, 1, 1]         230,640\n",
+            "            ReLU-162            [-1, 240, 1, 1]               0\n",
+            "          Conv2d-163            [-1, 960, 1, 1]         231,360\n",
+            "     Hardsigmoid-164            [-1, 960, 1, 1]               0\n",
+            "SqueezeExcitation-165            [-1, 960, 7, 7]               0\n",
+            "          Conv2d-166            [-1, 160, 7, 7]         153,600\n",
+            "     BatchNorm2d-167            [-1, 160, 7, 7]             320\n",
+            "InvertedResidual-168            [-1, 160, 7, 7]               0\n",
+            "          Conv2d-169            [-1, 960, 7, 7]         153,600\n",
+            "     BatchNorm2d-170            [-1, 960, 7, 7]           1,920\n",
+            "       Hardswish-171            [-1, 960, 7, 7]               0\n",
+            "          Conv2d-172            [-1, 960, 7, 7]          24,000\n",
+            "     BatchNorm2d-173            [-1, 960, 7, 7]           1,920\n",
+            "       Hardswish-174            [-1, 960, 7, 7]               0\n",
+            "AdaptiveAvgPool2d-175            [-1, 960, 1, 1]               0\n",
+            "          Conv2d-176            [-1, 240, 1, 1]         230,640\n",
+            "            ReLU-177            [-1, 240, 1, 1]               0\n",
+            "          Conv2d-178            [-1, 960, 1, 1]         231,360\n",
+            "     Hardsigmoid-179            [-1, 960, 1, 1]               0\n",
+            "SqueezeExcitation-180            [-1, 960, 7, 7]               0\n",
+            "          Conv2d-181            [-1, 160, 7, 7]         153,600\n",
+            "     BatchNorm2d-182            [-1, 160, 7, 7]             320\n",
+            "InvertedResidual-183            [-1, 160, 7, 7]               0\n",
+            "          Conv2d-184            [-1, 960, 7, 7]         153,600\n",
+            "     BatchNorm2d-185            [-1, 960, 7, 7]           1,920\n",
+            "       Hardswish-186            [-1, 960, 7, 7]               0\n",
+            "AdaptiveAvgPool2d-187            [-1, 960, 1, 1]               0\n",
+            "          Linear-188                 [-1, 1280]       1,230,080\n",
+            "       Hardswish-189                 [-1, 1280]               0\n",
+            "         Dropout-190                 [-1, 1280]               0\n",
+            "          Linear-191                 [-1, 1000]       1,281,000\n",
+            "     MobileNetV3-192                 [-1, 1000]               0\n",
+            "         Flatten-193                 [-1, 1000]               0\n",
+            "          Linear-194                  [-1, 512]         512,512\n",
+            "            ReLU-195                  [-1, 512]               0\n",
+            "          Linear-196                  [-1, 512]         262,656\n",
+            "            ReLU-197                  [-1, 512]               0\n",
+            "          Linear-198                    [-1, 8]           4,104\n",
+            "         Softmax-199                    [-1, 8]               0\n",
+            "================================================================\n",
+            "Total params: 6,262,304\n",
+            "Trainable params: 6,262,304\n",
+            "Non-trainable params: 0\n",
+            "----------------------------------------------------------------\n",
+            "Input size (MB): 0.57\n",
+            "Forward/backward pass size (MB): 105.45\n",
+            "Params size (MB): 23.89\n",
+            "Estimated Total Size (MB): 129.91\n",
+            "----------------------------------------------------------------\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.7/dist-packages/torch/nn/modules/container.py:141: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
+            "  input = module(input)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from torch.utils.data import Dataset\n",
+        "import torchvision.transforms.functional as TF\n",
+        "import torchvision.transforms as transforms\n",
+        "import torch.nn.functional as F\n",
+        "import numpy as np\n",
+        "import random\n",
+        "import torch\n",
+        "\n",
+        "class UpsideDownDataset(Dataset):\n",
+        "    \"\"\"Face Landmarks dataset.\"\"\"\n",
+        "\n",
+        "    def __init__(self, images_list, angles_list, factor=3):\n",
+        "        \"\"\"\n",
+        "        Args:\n",
+        "            csv_file (string): Path to the csv file with annotations.\n",
+        "            root_dir (string): Directory with all the images.\n",
+        "            transform (callable, optional): Optional transform to be applied\n",
+        "                on a sample.\n",
+        "        \"\"\"\n",
+        "        self.images = random.sample(images_list * factor, len(images_list * factor))\n",
+        "        self.angles = np.random.choice(angles_list, factor*len(images_list))\n",
+        "        assert len(self.images) == len(self.angles)\n",
+        "        self.transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), transforms.Resize((224,224))])\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        return len(self.angles)\n",
+        "\n",
+        "    def __getitem__(self, idx):\n",
+        "        if torch.is_tensor(idx):\n",
+        "            idx = idx.tolist()\n",
+        "        rotation_angle = int(self.angles[idx])\n",
+        "        image = self.transform(self.images[idx])\n",
+        "\n",
+        "        augmented_image = TF.rotate(image, rotation_angle)\n",
+        "        # print(np.unique(self.angles), rotation_angle)\n",
+        "        label = torch.zeros(len(np.unique(self.angles)))\n",
+        "        label[np.where(np.unique(self.angles) == rotation_angle)] = 1\n",
+        "        # F.one_hot(, num_classes=len(self.angles.unique()))\n",
+        "        sample = (augmented_image, label)\n",
+        "\n",
+        "        return sample\n",
+        "\n",
+        "dataset = UpsideDownDataset(images_list=all_images, angles_list=angles)\n",
+        "print(dataset.__len__())\n",
+        "print(dataset.__getitem__(15)[0].shape, dataset.__getitem__(15)[1])"
+      ],
+      "metadata": {
+        "id": "pc1CHBWqOb6I",
+        "outputId": "80ee4bf3-c409-457e-a3a1-317177a5e1f5",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "180000\n",
+            "torch.Size([3, 224, 224]) tensor([0., 0., 1., 0., 0., 0., 0., 0.])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "os.environ[\"CUDA_LAUNCH_BLOCKING\"] = \"1\"\n",
+        "\n",
+        "import torch\n",
+        "import torchvision\n",
+        "import torchvision.transforms as transforms\n",
+        "import torch.optim as optim\n",
+        "import numpy as np\n",
+        "\n",
+        "\n",
+        "batch_size = 32\n",
+        "\n",
+        "dataset_len = len(dataset)\n",
+        "train_amount, val_amount = int(0.7 * dataset_len), int(0.2 * dataset_len)\n",
+        "test_amount = dataset_len - (train_amount + val_amount)\n",
+        "train_set, val_set, test_set = torch.utils.data.random_split(dataset, [train_amount, val_amount, test_amount])\n",
+        "\n",
+        "trainloader = torch.utils.data.DataLoader(train_set, batch_size=batch_size,\n",
+        "                                          shuffle=True, num_workers=2)\n",
+        "validationloader = torch.utils.data.DataLoader(val_set, batch_size=batch_size,\n",
+        "                                         shuffle=False, num_workers=2)\n",
+        "testloader = torch.utils.data.DataLoader(test_set, batch_size=batch_size,\n",
+        "                                         shuffle=False, num_workers=2)\n",
+        "\n",
+        "\n",
+        "criterion = nn.CrossEntropyLoss()\n",
+        "optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
+        "model = model.cuda()\n",
+        "\n",
+        "EPOCHS = 10\n",
+        "for epoch in range(EPOCHS):  # loop over the dataset multiple times\n",
+        "\n",
+        "    running_loss = 0.0\n",
+        "    for i, data in enumerate(trainloader):\n",
+        "        # get the inputs; data is a list of [inputs, labels]\n",
+        "        inputs, labels = data\n",
+        "\n",
+        "        # zero the parameter gradients\n",
+        "        optimizer.zero_grad()\n",
+        "\n",
+        "        # forward + backward + optimize\n",
+        "        outputs = model(inputs.cuda())\n",
+        "        loss = criterion(outputs, labels.cuda())\n",
+        "        loss.backward()\n",
+        "        optimizer.step()\n",
+        "\n",
+        "        # print statistics\n",
+        "        running_loss += loss.item()\n",
+        "        if i % 2000 == 1999:    # print every 2000 mini-batches\n",
+        "            print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')\n",
+        "            running_loss = 0.0\n",
+        "\n",
+        "print('Finished Training')"
+      ],
+      "metadata": {
+        "id": "9TcAXOX2hlIv",
+        "outputId": "49bc6ac6-9a01-4e54-f61e-2eb07e7850d6",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.7/dist-packages/torch/nn/modules/container.py:141: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
+            "  input = module(input)\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "[1,  2000] loss: 2.079\n",
+            "[2,  2000] loss: 2.078\n",
+            "[3,  2000] loss: 2.034\n",
+            "[4,  2000] loss: 1.952\n",
+            "[5,  2000] loss: 1.941\n",
+            "[6,  2000] loss: 1.920\n",
+            "[7,  2000] loss: 1.840\n",
+            "[8,  2000] loss: 1.782\n",
+            "[9,  2000] loss: 1.735\n",
+            "[10,  2000] loss: 1.696\n",
+            "Finished Training\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ],
+      "metadata": {
+        "id": "6Ipqob3xEZKn",
+        "outputId": "25720ce1-e54b-4056-8193-fedf4b7bc61f",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mounted at /content/drive\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "torch.save(model.state_dict(), \"/content/drive/MyDrive/upside_down_model_weughts.pth\")"
+      ],
+      "metadata": {
+        "id": "8nhGxmFpEghe"
+      },
+      "execution_count": 8,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# correct = 0\n",
+        "# total = 0\n",
+        "# # since we're not training, we don't need to calculate the gradients for our outputs\n",
+        "# with torch.no_grad():\n",
+        "#     for data in testloader:\n",
+        "#         images, labels = data\n",
+        "#         # calculate outputs by running images through the network\n",
+        "#         outputs = model(images.cuda())\n",
+        "#         # the class with the highest energy is what we choose as prediction\n",
+        "#         predicted = outputs.data.argmax(axis=1)\n",
+        "#         # print(predicted.shape)\n",
+        "#         # print(labels.argmax(axis=1).shape)\n",
+        "#         total += labels.size(0)\n",
+        "#         correct += (predicted.cpu() == labels.argmax(axis=1)).sum().item()\n",
+        "\n",
+        "# print(f'Accuracy of the network on the {total} test images: {100 * correct // total} %')\n",
+        "\n",
+        "\n",
+        "# prepare to count predictions for each class\n",
+        "correct_pred = {classname: 0 for classname in angles}\n",
+        "total_pred = {classname: 0 for classname in angles}\n",
+        "\n",
+        "# again no gradients needed\n",
+        "with torch.no_grad():\n",
+        "    for data in testloader:\n",
+        "        images, labels = data\n",
+        "        outputs = model(images.cuda())\n",
+        "        predictions = outputs.data.argmax(axis=1).cpu()\n",
+        "        labels = labels.argmax(axis=1)\n",
+        "        # collect the correct predictions for each class\n",
+        "        for label, prediction in zip(labels, predictions):\n",
+        "            if label == prediction:\n",
+        "                correct_pred[angles[label]] += 1\n",
+        "            total_pred[angles[label]] += 1\n"
+      ],
+      "metadata": {
+        "id": "CXEbyGwdKhs-",
+        "outputId": "e93e6099-c297-41b7-e03d-c7d6c0b325a2",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 264
+        }
+      },
+      "execution_count": 23,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.7/dist-packages/torch/nn/modules/container.py:141: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
+            "  input = module(input)\n"
+          ]
+        },
+        {
+          "output_type": "error",
+          "ename": "ValueError",
+          "evalue": "ignored",
+          "traceback": [
+            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+            "\u001b[0;32m<ipython-input-23-9719f7405f9f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     38\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mclassname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcorrect_count\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mcorrect_pred\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     39\u001b[0m     \u001b[0maccuracy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m100\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcorrect_count\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mtotal_pred\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mclassname\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 40\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf'Accuracy for class: {classname:5s} is {accuracy:.1f} %'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+            "\u001b[0;31mValueError\u001b[0m: Unknown format code 's' for object of type 'int'"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "\n",
+        "# print accuracy for each class\n",
+        "for classname, correct_count in correct_pred.items():\n",
+        "    accuracy = 100 * float(correct_count) / total_pred[classname]\n",
+        "    print(f'Accuracy for class: {classname} is {accuracy:.1f} %')"
+      ],
+      "metadata": {
+        "id": "H_EnvtnBQ22l",
+        "outputId": "510345fb-5ecd-4ea7-8b7a-15eaf8f3c325",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 24,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Accuracy for class: 0 is 52.8 %\n",
+            "Accuracy for class: 45 is 78.7 %\n",
+            "Accuracy for class: 90 is 49.1 %\n",
+            "Accuracy for class: 135 is 72.1 %\n",
+            "Accuracy for class: 180 is 65.0 %\n",
+            "Accuracy for class: 225 is 0.0 %\n",
+            "Accuracy for class: 270 is 57.7 %\n",
+            "Accuracy for class: 315 is 98.2 %\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install huggingface_hub"
+      ],
+      "metadata": {
+        "id": "iC1dtDoGVe1g",
+        "outputId": "e14f64e6-ba54-4f62-c8b5-f1b5d8f55c94",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        }
+      },
+      "execution_count": 25,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Requirement already satisfied: huggingface_hub in /usr/local/lib/python3.7/dist-packages (0.4.0)\n",
+            "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.7/dist-packages (from huggingface_hub) (4.11.3)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.7/dist-packages (from huggingface_hub) (3.6.0)\n",
+            "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.7/dist-packages (from huggingface_hub) (3.10.0.2)\n",
+            "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from huggingface_hub) (3.13)\n",
+            "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from huggingface_hub) (2.23.0)\n",
+            "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from huggingface_hub) (4.63.0)\n",
+            "Requirement already satisfied: packaging>=20.9 in /usr/local/lib/python3.7/dist-packages (from huggingface_hub) (21.3)\n",
+            "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging>=20.9->huggingface_hub) (3.0.7)\n",
+            "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata->huggingface_hub) (3.7.0)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->huggingface_hub) (2021.10.8)\n",
+            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->huggingface_hub) (1.25.11)\n",
+            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->huggingface_hub) (3.0.4)\n",
+            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->huggingface_hub) (2.10)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Write up**: \n",
+        "* Link to the model on Hugging Face Hub: \n",
+        "* Include some examples of misclassified images. Please explain what you might do to improve your model's performance on these images in the future (you do not need to impelement these suggestions)"
+      ],
+      "metadata": {
+        "id": "qSeLed2JxvGI"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "sFU9LTOyMiMj"
+      },
+      "source": [
+        "# 2. Deep Learning for NLP\n",
+        "\n",
+        "**Fake news classifier**: Train a text classification model to detect fake news articles!\n",
+        "\n",
+        "* Download the dataset here: https://www.kaggle.com/clmentbisaillon/fake-and-real-news-dataset\n",
+        "* Develop an NLP model for classification that uses a pretrained language model\n",
+        "* Finetune your model on the dataset, and generate an AUC curve of your model on the test set of your choice. \n",
+        "* [Upload the the model to the Hugging Face Hub](https://huggingface.co/docs/hub/adding-a-model), and add a link to your model below.\n",
+        "* *Answer the following question*: Look at some of the news articles that were classified incorrectly. Please explain what you might do to improve your model's performance on these news articles in the future (you do not need to impelement these suggestions)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "### WRITE YOUR CODE TO TRAIN THE MODEL HERE"
+      ],
+      "metadata": {
+        "id": "E90i018KyJH3"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Write up**: \n",
+        "* Link to the model on Hugging Face Hub: \n",
+        "* Include some examples of misclassified news articles. Please explain what you might do to improve your model's performance on these news articles in the future (you do not need to impelement these suggestions)"
+      ],
+      "metadata": {
+        "id": "kpInVUMLyJ24"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "jTfHpo6BOmE8"
+      },
+      "source": [
+        "# 3. Deep RL / Robotics"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "saB64bbTXWgZ"
+      },
+      "source": [
+        "**RL for Classical Control:** Using any of the [classical control](https://github.com/openai/gym/blob/master/docs/environments.md#classic-control) environments from OpenAI's `gym`, implement a deep NN that learns an optimal policy which maximizes the reward of the environment.\n",
+        "\n",
+        "* Describe the NN you implemented and the behavior you observe from the agent as the model converges (or diverges).\n",
+        "* Plot the reward as a function of steps (or Epochs).\n",
+        "Compare your results to a random agent.\n",
+        "* Discuss whether you think your model has learned the optimal policy and potential methods for improving it and/or where it might fail.\n",
+        "* (Optional) [Upload the the model to the Hugging Face Hub](https://huggingface.co/docs/hub/adding-a-model), and add a link to your model below.\n",
+        "\n",
+        "\n",
+        "You may use any frameworks you like, but you must implement your NN on your own (no pre-defined/trained models like [`stable_baselines`](https://stable-baselines.readthedocs.io/en/master/)).\n",
+        "\n",
+        "You may use any simulator other than `gym` _however_:\n",
+        "* The environment has to be similar to the classical control environments (or more complex like [`robosuite`](https://github.com/ARISE-Initiative/robosuite)).\n",
+        "* You cannot choose a game/Atari/text based environment. The purpose of this challenge is to demonstrate an understanding of basic kinematic/dynamic systems."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "### WRITE YOUR CODE TO TRAIN THE MODEL HERE"
+      ],
+      "metadata": {
+        "id": "CUhkTcoeynVv"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Write up**: \n",
+        "* (Optional) link to the model on Hugging Face Hub: \n",
+        "* Discuss whether you think your model has learned the optimal policy and potential methods for improving it and/or where it might fail."
+      ],
+      "metadata": {
+        "id": "bWllPZhJyotg"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "rbrRbrISa5J_"
+      },
+      "source": [
+        "# 4. Theory / Linear Algebra "
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "KFkLRCzTXTzL"
+      },
+      "source": [
+        "**Implement Contrastive PCA** Read [this paper](https://www.nature.com/articles/s41467-018-04608-8) and implement contrastive PCA in Python.\n",
+        "\n",
+        "* First, please discuss what kind of dataset this would make sense to use this method on\n",
+        "* Implement the method in Python (do not use previous implementations of the method if they already exist)\n",
+        "* Then create a synthetic dataset and apply the method to the synthetic data. Compare with standard PCA.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Write up**: Discuss what kind of dataset it would make sense to use Contrastive PCA"
+      ],
+      "metadata": {
+        "id": "TpyqWl-ly0wy"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "### WRITE YOUR CODE HERE"
+      ],
+      "metadata": {
+        "id": "1CQzUSfQywRk"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# 5. Systems"
+      ],
+      "metadata": {
+        "id": "dlqmZS5Hy6q-"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Inference on the edge**: Measure the inference times in various computationally-constrained settings\n",
+        "\n",
+        "* Pick a few different speech detection models (we suggest looking at models  on the [Hugging Face Hub](https://huggingface.co/models?pipeline_tag=automatic-speech-recognition&sort=downloads))\n",
+        "* Simulate different memory constraints and CPU allocations that are realistic for edge devices that might run such models, such as smart speakers or microcontrollers, and measure what is the average inference time of the models under these conditions \n",
+        "* How does the inference time vary with (1) choice of model (2) available system memory (3) available CPU (4) size of input?\n",
+        "\n",
+        "Are there any surprising discoveries? (Note that this coding challenge is fairly open-ended, so we will be considering the amount of effort invested in discovering something interesting here)."
+      ],
+      "metadata": {
+        "id": "QW_eiDFw1QKm"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "### WRITE YOUR CODE HERE"
+      ],
+      "metadata": {
+        "id": "OYp94wLP1kWJ"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Write up**: What surprising discoveries do you see?"
+      ],
+      "metadata": {
+        "id": "yoHmutWx2jer"
+      }
+    }
+  ]
+}

upside_down_model_weights.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc6b74c2546cee5e4dac87ddbc1c38af24de484741a26f0b08caa2d9b228a178
+size 25260869