NeuromatchAcademy_DL_Tutorial_Carpentry.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "NeuromatchAcademy_DL_Tutorial Carpentry",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.3"
    },
    "toc-autonumbering": true,
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "a176645b25f14ef3ab016ec61c9bf186": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "TabModel",
          "state": {
            "_view_name": "TabView",
            "_dom_classes": [],
            "_titles": {
              "0": "Youtube",
              "1": "Bilibili"
            },
            "_model_name": "TabModel",
            "_view_module": "@jupyter-widgets/controls",
            "selected_index": 0,
            "_model_module_version": "1.5.0",
            "_view_count": null,
            "_view_module_version": "1.5.0",
            "box_style": "",
            "layout": "IPY_MODEL_9a1f2d41bc78472595e0f4ca4d90cd0a",
            "_model_module": "@jupyter-widgets/controls",
            "children": [
              "IPY_MODEL_1ab63da5cec04c11a88310cfd56b35a0",
              "IPY_MODEL_b7abe20ae54841338aad3b214322e5f3"
            ]
          }
        },
        "9a1f2d41bc78472595e0f4ca4d90cd0a": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        },
        "1ab63da5cec04c11a88310cfd56b35a0": {
          "model_module": "@jupyter-widgets/output",
          "model_name": "OutputModel",
          "state": {
            "_view_name": "OutputView",
            "msg_id": "",
            "_dom_classes": [],
            "_model_name": "OutputModel",
            "outputs": [
              {
                "output_type": "stream",
                "metadata": {
                  "tags": []
                },
                "text": "Video available at https://youtube.com/watch?v=\n",
                "stream": "stdout"
              },
              {
                "output_type": "display_data",
                "metadata": {
                  "tags": []
                },
                "text/html": "\n        <iframe\n            width=\"854\"\n            height=\"480\"\n            src=\"https://www.youtube.com/embed/?fs=1&rel=0\"\n            frameborder=\"0\"\n            allowfullscreen\n        ></iframe>\n        ",
                "text/plain": "<IPython.lib.display.YouTubeVideo at 0x7f47daca1090>"
              }
            ],
            "_view_module": "@jupyter-widgets/output",
            "_model_module_version": "1.0.0",
            "_view_count": null,
            "_view_module_version": "1.0.0",
            "layout": "IPY_MODEL_a1cdecad0a50487791af335f1305d369",
            "_model_module": "@jupyter-widgets/output"
          }
        },
        "b7abe20ae54841338aad3b214322e5f3": {
          "model_module": "@jupyter-widgets/output",
          "model_name": "OutputModel",
          "state": {
            "_view_name": "OutputView",
            "msg_id": "",
            "_dom_classes": [],
            "_model_name": "OutputModel",
            "outputs": [
              {
                "output_type": "stream",
                "metadata": {
                  "tags": []
                },
                "text": "Video available at https://www.bilibili.com/video/\n",
                "stream": "stdout"
              },
              {
                "output_type": "display_data",
                "metadata": {
                  "tags": []
                },
                "text/html": "\n        <iframe\n            width=\"854\"\n            height=\"480\"\n            src=\"https://player.bilibili.com/player.html?bvid=&page=1?fs=1\"\n            frameborder=\"0\"\n            allowfullscreen\n        ></iframe>\n        ",
                "text/plain": "<__main__.BiliVideo at 0x7f4836e705d0>"
              }
            ],
            "_view_module": "@jupyter-widgets/output",
            "_model_module_version": "1.0.0",
            "_view_count": null,
            "_view_module_version": "1.0.0",
            "layout": "IPY_MODEL_d3742bb982ae4451ba85b1768c484b61",
            "_model_module": "@jupyter-widgets/output"
          }
        },
        "a1cdecad0a50487791af335f1305d369": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        },
        "d3742bb982ae4451ba85b1768c484b61": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "state": {
            "_view_name": "LayoutView",
            "grid_template_rows": null,
            "right": null,
            "justify_content": null,
            "_view_module": "@jupyter-widgets/base",
            "overflow": null,
            "_model_module_version": "1.2.0",
            "_view_count": null,
            "flex_flow": null,
            "width": null,
            "min_width": null,
            "border": null,
            "align_items": null,
            "bottom": null,
            "_model_module": "@jupyter-widgets/base",
            "top": null,
            "grid_column": null,
            "overflow_y": null,
            "overflow_x": null,
            "grid_auto_flow": null,
            "grid_area": null,
            "grid_template_columns": null,
            "flex": null,
            "_model_name": "LayoutModel",
            "justify_items": null,
            "grid_row": null,
            "max_height": null,
            "align_content": null,
            "visibility": null,
            "align_self": null,
            "height": null,
            "min_height": null,
            "padding": null,
            "grid_auto_rows": null,
            "grid_gap": null,
            "max_width": null,
            "order": null,
            "_view_module_version": "1.2.0",
            "grid_template_areas": null,
            "object_position": null,
            "object_fit": null,
            "grid_auto_columns": null,
            "margin": null,
            "display": null,
            "left": null
          }
        }
      }
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/NeuromatchAcademy/content-creation/blob/main/NeuromatchAcademy_DL_Tutorial_Carpentry.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fDXAYdIHuyCV"
      },
      "source": [
        "# Tutorial ?: Tutorial's name\n",
        "**Week ?, Day ?: Name of the day**\n",
        "\n",
        "**By Neuromatch Academy**\n",
        "\n",
        "__Content creators:__ Name Surname, Name Surname, Day Lead's Name\n",
        "\n",
        "__Content reviewers:__ Name Surname, Name Surname\n",
        "\n",
        "__Content editors:__ Name Surname, Name Surname\n",
        "\n",
        "__Production editors:__ Name Surname, Name Surname\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "-This tutorial carpentry was originally written by *Kelson Shilling-Scrivo*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qfFA1VsB4Ieb"
      },
      "source": [
        "**Our 2021 Sponsors, including Presenting Sponsor Facebook Reality Labs**\n",
        "\n",
        "<p align='center'><img src='https://github.com/NeuromatchAcademy/widgets/blob/master/sponsors.png?raw=True'/></p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gzAa0I1xZ79h"
      },
      "source": [
        "---\n",
        "#Tutorial Objectives\n",
        "\n",
        "Teach how to create didactic, easily digestable and fun content for the NMA-DL course.\n",
        "\n",
        "\n",
        "\n",
        "This course will teach you:\n",
        "*   DL code Styleguide\n",
        "*   Video Do's / Don'ts\n",
        "*   Written Content Do's / Don'ts\n",
        "*   Exercise Creation Do's don't\n",
        "\n",
        "This course will not teach you:\n",
        "\n",
        "*   Tutorial formatting [found here](https://github.com/NeuromatchAcademy/content-creation/blob/main/Neuromatch_Tutorial_Format.ipynb)\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6C8JNxNy7KvH",
        "outputId": "e70d37ac-714e-4c5f-9c2f-54191ffce338",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 590
        }
      },
      "source": [
        "#@markdown Tutorial slides\n",
        "# you should link the slides for all tutorial videos here (we will store pdfs on osf)\n",
        "\n",
        "from IPython.display import HTML\n",
        "HTML('<iframe src=\"https://mfr.ca-1.osf.io/render?url=https://osf.io/kaq2x/?direct%26mode=render%26action=download%26mode=render\" frameborder=\"0\" width=\"960\" height=\"569\" allowfullscreen=\"true\" mozallowfullscreen=\"true\" webkitallowfullscreen=\"true\"></iframe>')"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<iframe src=\"https://mfr.ca-1.osf.io/render?url=https://osf.io/kaq2x/?direct%26mode=render%26action=download%26mode=render\" frameborder=\"0\" width=\"960\" height=\"569\" allowfullscreen=\"true\" mozallowfullscreen=\"true\" webkitallowfullscreen=\"true\"></iframe>"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "id": "3Yuh005kCT0v"
      },
      "source": [
        "# Import\n",
        "\n",
        "# Import only the libraries/objects that you use in this tutorial. \n",
        "\n",
        "# If any external library has to be installed, !pip install library --quiet\n",
        "# follow this order: numpy>matplotlib. \n",
        "# import widgets in hidden Figure settings cell\n",
        "\n",
        "!pip install einops --quiet #TODO get einops installed by default \n",
        "\n",
        "# Imports\n",
        "\n",
        "import os\n",
        "\n",
        "import pathlib\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.cm as cm\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.ticker as ticker\n",
        "from tqdm.notebook import tqdm, trange\n",
        "\n",
        "# torch import style\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torch.nn.functional as F\n",
        "import torchvision.transforms as transforms\n",
        "from torchvision.datasets import ImageFolder\n",
        "import torchvision.datasets as datasets\n",
        "from torch.utils.data import DataLoader, TensorDataset\n",
        "from torchvision.utils import make_grid\n",
        "from IPython.display import HTML, display"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PCOz4jKJXGya"
      },
      "source": [
        "#@title Figure settings\n",
        "import ipywidgets as widgets       # interactive display\n",
        "%config InlineBackend.figure_format = 'retina'\n",
        "plt.style.use(\"https://raw.githubusercontent.com/NeuromatchAcademy/content-creation/main/nma.mplstyle\")"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fbUVuJDTSmZP"
      },
      "source": [
        "# Common Helper Functions "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vGVC4AWz41jD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "68e053ef-f486-447c-ed5c-32733e50b896"
      },
      "source": [
        "#@title Set random seed. \n",
        "\n",
        "#@markdown Executing `set_seed(seed=seed)` you are setting the seed\n",
        "\n",
        "# for DL its critical to set the random seed so that students can have a\n",
        "# baseline to compare their results to expected results.\n",
        "# Read more here: https://pytorch.org/docs/stable/notes/randomness.html\n",
        "\n",
        "# Call `set_seed` function in the exercises to ensure reproducibility.\n",
        "import random\n",
        "\n",
        "def set_seed(seed=None, seed_torch=True):\n",
        "  if seed is None:\n",
        "    seed = np.random.choice(2 ** 32)\n",
        "  random.seed(seed)\n",
        "  np.random.seed(seed)\n",
        "  if seed_torch:\n",
        "    torch.manual_seed(seed)\n",
        "    torch.cuda.manual_seed_all(seed)\n",
        "    torch.cuda.manual_seed(seed)\n",
        "    torch.backends.cudnn.benchmark = False\n",
        "    torch.backends.cudnn.deterministic = True\n",
        "\n",
        "  print(f'Random seed {seed} has been set.')\n",
        "\n",
        "# In case that `DataLoader` is used\n",
        "def seed_worker(worker_id):\n",
        "  worker_seed = torch.initial_seed() % 2**32\n",
        "  np.random.seed(worker_seed)\n",
        "  random.seed(worker_seed)\n",
        "\n",
        "\n",
        "# Before the exercises it should re-executed to ensure reproducibility\n",
        "set_seed(seed=2021)  # change 2021 with any number you like"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Random seed 2021 has been set.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gqgSq2WT_yEz"
      },
      "source": [
        "#@title Set device (GPU or CPU). Execute `set_device()`\n",
        "\n",
        "# inform the user if the notebook uses GPU or CPU.\n",
        "\n",
        "def set_device():\n",
        "  device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "  if device != \"cuda\":\n",
        "    print(\"WARNING: For this notebook to perform best, \"\n",
        "        \"if possible, in the menu under `Runtime` -> \"\n",
        "        \"`Change runtime type.`  select `GPU` \")\n",
        "  else:\n",
        "    print(\"GPU is enabled in this notebook.\")\n",
        "\n",
        "  return device"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YvR8oC4K4nH4",
        "outputId": "c04b4732-91a5-44f5-e430-95178f51fa84",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "DEVICE = set_device()\n",
        "SEED = 2021\n",
        "set_seed(seed=SEED, seed_torch=True)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "WARNING: For this notebook to perform best, if possible, in the menu under `Runtime` -> `Change runtime type.`  select `GPU` \n",
            "Random seed 2021 has been set.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nULavCfq4o07"
      },
      "source": [
        "---\n",
        "\n",
        "# Section 1: Videos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MycGcXpOi_E6"
      },
      "source": [
        "Place the youtube video ID and then hide the cell. Videos can be found [here](https://docs.google.com/spreadsheets/d/1I-q6YRn-o9XCE45KCd4zs80LKPiu7BvuqmAO_xIr55Y/edit?usp=sharing). The list is continuously being updated."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 580,
          "referenced_widgets": [
            "a176645b25f14ef3ab016ec61c9bf186",
            "9a1f2d41bc78472595e0f4ca4d90cd0a",
            "1ab63da5cec04c11a88310cfd56b35a0",
            "b7abe20ae54841338aad3b214322e5f3",
            "a1cdecad0a50487791af335f1305d369",
            "d3742bb982ae4451ba85b1768c484b61"
          ]
        },
        "id": "ThcPwgvzvV-6",
        "outputId": "4aade120-7721-4660-d1ca-cfa0f144b03e"
      },
      "source": [
        "#@title Video 1: Video 1 Name\n",
        "# Insert the ID of the corresponding youtube video\n",
        "from ipywidgets import widgets\n",
        "\n",
        "out2 = widgets.Output()\n",
        "with out2:\n",
        "  from IPython.display import IFrame\n",
        "  class BiliVideo(IFrame):\n",
        "      def __init__(self, id, page=1, width=400, height=300, **kwargs):\n",
        "          self.id=id\n",
        "          src = \"https://player.bilibili.com/player.html?bvid={0}&page={1}\".format(id, page)\n",
        "          super(BiliVideo, self).__init__(src, width, height, **kwargs)\n",
        "\n",
        "  video = BiliVideo(id=f\"\", width=854, height=480, fs=1)\n",
        "  print(\"Video available at https://www.bilibili.com/video/{0}\".format(video.id))\n",
        "  display(video)\n",
        "\n",
        "out1 = widgets.Output()\n",
        "with out1:\n",
        "  from IPython.display import YouTubeVideo\n",
        "  video = YouTubeVideo(id=f\"\", width=854, height=480, fs=1, rel=0)\n",
        "  print(\"Video available at https://youtube.com/watch?v=\" + video.id)\n",
        "  display(video)\n",
        "\n",
        "out = widgets.Tab([out1, out2])\n",
        "out.set_title(0, 'Youtube')\n",
        "out.set_title(1, 'Bilibili')\n",
        "\n",
        "display(out)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "a176645b25f14ef3ab016ec61c9bf186",
              "version_minor": 0,
              "version_major": 2
            },
            "text/plain": [
              "Tab(children=(Output(), Output()), _titles={'0': 'Youtube', '1': 'Bilibili'})"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7w9LT3ywjeNH"
      },
      "source": [
        "The final cell with the video should look like the one below:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 518
        },
        "id": "0ORMQP5RjkIk",
        "outputId": "f13161a8-176c-4041-c4ca-186f01ec4f59"
      },
      "source": [
        "#@title Video 2: DL welcome blah blah\n",
        "# Insert the ID of the corresponding youtube video\n",
        "from IPython.display import YouTubeVideo\n",
        "video = YouTubeVideo(id=\"ca21SNqt78I\", width=854, height=480, fs=1)\n",
        "print(\"Video available at https://youtu.be/\" + video.id)\n",
        "video"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Video available at https://youtu.be/ca21SNqt78I\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "\n",
              "        <iframe\n",
              "            width=\"854\"\n",
              "            height=\"480\"\n",
              "            src=\"https://www.youtube.com/embed/ca21SNqt78I?fs=1\"\n",
              "            frameborder=\"0\"\n",
              "            allowfullscreen\n",
              "        ></iframe>\n",
              "        "
            ],
            "text/plain": [
              "<IPython.lib.display.YouTubeVideo at 0x7f47db85cb10>"
            ],
            "image/jpeg": "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\n"
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z8axuI6upLv4"
      },
      "source": [
        "Take-aways: \n",
        "\n",
        "1.   one concept per video \n",
        "2.   many small videos preferable to 1 large video\n",
        "3.   Keep distance between idea and interaction small \n",
        "\n",
        "Do not: \n",
        "\n",
        "1.   Speak in mathematical notation \n",
        "\n",
        "\n",
        "> instead of: as we increase alpha, Say : as  we increase the learning rate. \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j9n17gXFOIXX"
      },
      "source": [
        "## Section 2: Written Text\n",
        "The text is meant to suppliment the videos and reiterate the key information provided in the lecture. It is the RAM buffer that stores the key points of the video while they complete the exercise. It is **not** a source of completely new information. Writing an entire section with a new concept entirely in text form is a anti-pattern and usually a sign that a video was missing a key concept, and a large written section was used as a band-aid. \n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6StJS7a_yFbO"
      },
      "source": [
        "# Section 3: Writing Exercises "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KMFOHL7Pj8mf"
      },
      "source": [
        "his exercise fits in this subsection so is a level 3 header. We name it after the section it is in.\n",
        "\n",
        "Very briefly summarize the exercise here. The first exercise should not be too difficult, to serve as a warm-up for students. Outputs of the code cell will ideally be a plot or a print of the architecture (so students can easily check against the correct one). In limited cases, the output may be printing numbers, text, etc. In that case you need to write the solution output manually after the exercise (E.g.: \"You should see the syntetic data when running the cell above\")."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "DyrdSzS4mIFI"
      },
      "source": [
        "# @markdown *Execute this cell to enable the plotting function: `plot_data`*\n",
        "\n",
        "def plot_data(X, y):\n",
        "  \"\"\"\n",
        "  Synthetic data generator in the form:\n",
        "      y = Xw + b + gaussian_noise(0, sigma).\n",
        "  \n",
        "  Parameters\n",
        "  ----------\n",
        "  X: torch.tensor\n",
        "      the independent variable(s).\n",
        "  y: torch.tensor\n",
        "      the dependent variable\n",
        "  \n",
        "  Returns\n",
        "  -------\n",
        "  Nothing.\n",
        "  \"\"\"\n",
        "\n",
        "  plt.figure()\n",
        "  plt.scatter(X, y)\n",
        "  plt.xlabel('x (independent variable)')\n",
        "  plt.ylabel('y (dependent variable)')\n",
        "  plt.show()"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cw463ZN4m4sG"
      },
      "source": [
        "Warn them when they will use a helper function. For example: In this exercise, you will also invoke `plot_data` which plots the data you have generated."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ztCl8eDHjyuX"
      },
      "source": [
        "def synthetic_dataset(weights, bias, num_examples=1000, sigma=0.01, seed=2021):\n",
        "  \"\"\"\n",
        "  Synthetic data generator in the form:\n",
        "      y = Xw + b + gaussian_noise(0, sigma).\n",
        "  \n",
        "  Parameters\n",
        "  ----------\n",
        "  weights : torch.tensor\n",
        "      weights. The length of `w` denotes the number of independent variables\n",
        "  bias : torch.tensor\n",
        "      bias (offset or intercept).\n",
        "  num_examples : INT, optional\n",
        "      DESCRIPTION. The default is 1000.\n",
        "  sigma : FLOAT, optional\n",
        "      Standard deviation of the Gaussian noise. The default is 0.01.\n",
        "  seed : INT, optional\n",
        "      Seed the RNG for reproducibility. The default is 2021.\n",
        "  \n",
        "  Returns\n",
        "  -------\n",
        "  X: torch.tensor\n",
        "      the independent variable(s).\n",
        "  y: torch.tensor\n",
        "      the dependent variable\n",
        "  \n",
        "  \"\"\"\n",
        "\n",
        "  # Set the seed for reproducibility\n",
        "  set_seed(seed)\n",
        "\n",
        "  X = torch.normal(0, 1, (weights.shape[0], num_examples))\n",
        "  #################################################\n",
        "  ## TODO for students: details of what they should do ##\n",
        "  # Fill out function and remove\n",
        "  raise NotImplementedError(\"Student exercise: say what they should have done\")\n",
        "  #################################################\n",
        "  # Have a comment for every line of code they need to write, and when possible have\n",
        "  # variables written with ellipses where they should fill in or ellipses where they should\n",
        "  # fill in inputs to functions\n",
        "  y = ...\n",
        "  # Another comment because they need to add another line of code\n",
        "  y += ...\n",
        "\n",
        "  return X, y.reshape((-1, 1))\n",
        "\n",
        "\n",
        "w = torch.tensor([2.5]).reshape(-1,1)\n",
        "b = 1.2\n",
        "N = 50\n",
        "\n",
        "# Uncomment the code below to test your function\n",
        "# we usually define the plotting function in the hidden Helper Functions\n",
        "# so students don't have to see a bunch of boilerplate matplotlib code\n",
        "# xkcd style for solution plot\n",
        "# X, y = synthetic_dataset(weights=w, bias=b, num_examples=10, sigma=2.5,\n",
        "#                          seed=2021)\n",
        "# plot_data(X, y)"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vd9JfcDrbQ_d"
      },
      "source": [
        "---\n",
        "__Editor guideline for exercise solution formatting:__\n",
        "- the presence of # to_remove solution in the first line of solution block\n",
        "- The absence of the fenced (#####) block that raises a NotImplementedError\n",
        "- Valid code replacing all ellipses  (...)\n",
        "- Code that uses or depends on the completed function/lines is uncommented\n",
        "- Plotting code is indented under a with plt.xkcd(): context manager.\n",
        "- Using ***SAME SEED*** such that student should be able to replicate sample results **exactly**.\n",
        "- **All other comments and code should be identical**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "both",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 450
        },
        "id": "tycSi5Pxbsne",
        "outputId": "edd0251c-8984-470b-9755-2313c4318299"
      },
      "source": [
        "def synthetic_dataset(weights, bias, num_examples=1000, sigma=0.01, seed=2021):\n",
        "  \"\"\"\n",
        "  Synthetic data generator in the form:\n",
        "      y = Xw + b + gaussian_noise(0, sigma).\n",
        "  \n",
        "  Parameters\n",
        "  ----------\n",
        "  weights : torch.tensor\n",
        "      weights. The length of `w` denotes the number of independent variables\n",
        "  bias : torch.tensor\n",
        "      bias (offset or intercept).\n",
        "  num_examples : INT, optional\n",
        "      DESCRIPTION. The default is 1000.\n",
        "  sigma : FLOAT, optional\n",
        "      Standard deviation of the Gaussian noise. The default is 0.01.\n",
        "  seed : INT, optional\n",
        "      Seed the RNG for reproducibility. The default is 2021.\n",
        "  \n",
        "  Returns\n",
        "  -------\n",
        "  X: torch.tensor\n",
        "      the independent variable(s).\n",
        "  y: torch.tensor\n",
        "      the dependent variable\n",
        "  \n",
        "  \"\"\"\n",
        "\n",
        "  # Set the seed for reproducibility\n",
        "  set_seed(seed)\n",
        "\n",
        "  X = torch.normal(0, 1, (weights.shape[0], num_examples))\n",
        "  # Have a comment for every line of code they need to write, and when possible have\n",
        "  # variables written with ellipses where they should fill in or ellipses where they should\n",
        "  # fill in inputs to functions\n",
        "  y = torch.matmul(w.T, X) + b\n",
        "  # Another comment because they need to add another line of code\n",
        "  y += torch.normal(0, sigma, y.shape)\n",
        "\n",
        "  return X, y.reshape((-1, 1))\n",
        "\n",
        "\n",
        "w = torch.tensor([2.5]).reshape(-1,1)\n",
        "b = 1.2\n",
        "N = 50\n",
        "\n",
        "# Uncomment the code below to test your function\n",
        "# we usually define the plotting function in the hidden Helper Functions\n",
        "# so students don't have to see a bunch of boilerplate matplotlib code\n",
        "# xkcd style for solution plot\n",
        "X, y = synthetic_dataset(weights=w, bias=b, num_examples=10, sigma=2.5,\n",
        "                         seed=2021)\n",
        "with plt.xkcd():\n",
        "  plot_data(X, y)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Random seed 2021 has been set.\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "image/png": {
              "width": 560,
              "height": 416
            }
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EuqpiL2Av-vd"
      },
      "source": [
        "---\n",
        "# Section 4: Code Style Guide\n",
        "\n",
        "This section will give you the information you'll need to write clear code in your networks and exercises. All code should be written in pytorch and follow standard PEP8 styleguides. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 518
        },
        "id": "AFd7Ji-twKIK",
        "outputId": "0dcb9874-2f26-4714-e17d-2f6e71ee79ff"
      },
      "source": [
        "#@title Video 3: Video 3 Name\n",
        "# Insert the ID of the corresponding youtube video\n",
        "from IPython.display import YouTubeVideo\n",
        "video = YouTubeVideo(id=\"\", width=854, height=480, fs=1)\n",
        "print(\"Video available at https://youtu.be/\" + video.id)\n",
        "video"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Video available at https://youtu.be/\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "\n",
              "        <iframe\n",
              "            width=\"854\"\n",
              "            height=\"480\"\n",
              "            src=\"https://www.youtube.com/embed/?fs=1\"\n",
              "            frameborder=\"0\"\n",
              "            allowfullscreen\n",
              "        ></iframe>\n",
              "        "
            ],
            "text/plain": [
              "<IPython.lib.display.YouTubeVideo at 0x7f47dabf4dd0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Z6vKsN89rN1"
      },
      "source": [
        "\n",
        "# 4.1 Building your network\n",
        "\n",
        "## Layer names guide\n",
        " Having consistent layer promotes learning by focusing attention on relevant changes to code. Students will take just as long to figure out why output layer is called 'fc' vs 'out' or 'linear' as they do to figure out which layer to use. For these common layers please adhere to the naming conventions below.\n",
        "for multiple layers please use: name1 , name2 to differentiate  \n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "Layer guide\n",
        "1.   self.fc  = nn.Linear()    (for Fully Connected)\n",
        "2.   self.conv = nn.Conv2d()  \n",
        "3.   self.pool = nn.MaxPool()  \n",
        "4.   self.dropout = nn.Dropout() \n",
        "5.   self.batch_norm = nn.BatchNorm2d() \n",
        "6.   self.relu = F.Relu() \n",
        "7.   etc...\n",
        "---\n",
        "\n",
        "\n",
        " If there is some edge case and you feel the name is not elegant enough or you have important reason to name layers do so as:  name_* .\n",
        "\n",
        " For example, if you want a linear encoding and decoding layer, fc1 and fc2 would be confusing, so for clarity, you should write the layers as\n",
        "\n",
        "  fc_encoding_layer, fc_decoding_layer. \n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mjXZX2bBFq5A"
      },
      "source": [
        "class CNN(nn.Module):\n",
        "  def __init__(self):\n",
        "    super(CNN, self).__init__()\n",
        "\n",
        "    ####################################################################\n",
        "    # Fill in missing code below (...),\n",
        "    # then remove or comment the line below to test your function\n",
        "    raise NotImplementedError(\"Define the required layers\")\n",
        "    ####################################################################\n",
        "    self.conv1 = nn.Conv2d(...)\n",
        "    self.conv2 = nn.Conv2d(...)\n",
        "    self.fc1 = nn.Linear(...)\n",
        "    self.fc2 = nn.Linear(...)\n",
        "    self.pool = nn.MaxPool2d(...)\n",
        "\n",
        "  def forward(self, x):\n",
        "    ####################################################################\n",
        "    # Fill in missing code below (...),\n",
        "    # then remove or comment the line below to test your function\n",
        "    # Hint: Do not forget to flatten the image as it goes from Convolution Layers to Linear Layers!\n",
        "    raise NotImplementedError(\"Define forward pass for any input x\")\n",
        "    ####################################################################\n",
        "    x = ...\n"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "msrOpAg6Hclj"
      },
      "source": [
        "# to_remove solution\n",
        "class CNN(nn.Module):\n",
        "  def __init__(self):\n",
        "  \n",
        "    super(CNN, self).__init__()\n",
        "    self.conv1 = nn.Conv2d(1, 32, 3)\n",
        "    self.conv2 = nn.Conv2d(32, 64, 3)\n",
        "    self.fc1 = nn.Linear(9216, 128)\n",
        "    self.fc2 = nn.Linear(128, 2)\n",
        "    self.pool = nn.MaxPool2d(2)\n",
        "\n",
        "  def forward(self, x):\n",
        "    x = self.conv1(x)\n",
        "    x = F.relu(x)\n",
        "    x = self.conv2(x)\n",
        "    x = F.relu(x)\n",
        "    x = self.pool(x)\n",
        "    x = torch.flatten(x, 1)\n",
        "    x = self.fc1(x)\n",
        "    x = F.relu(x)        \n",
        "    x = self.fc2(x)\n",
        "    return x\n"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ersfq2c8VGGH"
      },
      "source": [
        "# 4.2 Model Training\n",
        "Training models is often a time consuming process of DL. Given the limited time and different compute power the class will have, that is time we cannot afford. \n",
        "\n",
        "For your lectures you should make use of what we like to call the 'cooking show' method of tutorial preparation. They are as follows.\n",
        "\n",
        "\n",
        "\n",
        "1.   Ingredients\n",
        "2.   Recipe\n",
        "3.   \"Here is one I already prepared\"\n",
        "4.   Tasting \n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "1.   have an exercise to demonstrate the intuition of what the  key pieces of the network are doing\n",
        "2.   have an exercise that shows how the pieces all fit together \n",
        "3.   If training will take more than 5 minutes, load pretrained network.\n",
        "4.   Have students evaluate how pretrained or state of the art model performs. Have them try and break it! Understanding the current limits of DL shows students that DL isn't magic and gives insight as to what DL is good for. Plus students love it!  \n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y6Pux46LWw7e"
      },
      "source": [
        "# 4.3 Munging Guide\n",
        "Data Munging- ( transformation,permutation,manipulation ) is one of the hardest sections for a new student to master. Our general aim is to mitigate that as much as possible by doing several things\n",
        "\n",
        "---\n",
        "*   Putting Munging operations in their own lines for code exercises \n",
        "*   Providing clear,descriptive code hints for what transformation needs to occur (i.e don't use `.view` !) \n",
        "*   use operations that are explicit to allow the student more insight.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "## Examples \n",
        "Here is an example of a network that uses thes approaches well note how:\n",
        "\n",
        "\n",
        "1.   Tensor inputs and outputs shapes are clearly labeled\n",
        "2.   Hints are given when changes in these shapes occur\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DTY-kaQ-re74"
      },
      "source": [
        "class Encoder(nn.Module):\n",
        "  \"\"\"The RNN encoder for sequence to sequence learning.\"\"\"\n",
        "  def __init__(self, vocab_size, embed_size, num_hiddens, num_layers,\n",
        "                dropout=0):\n",
        "    super(Encoder, self).__init__()\n",
        "\n",
        "    self.embedding = nn.Embedding(vocab_size, embed_size)\n",
        "    self.gru = nn.GRU(embed_size, num_hiddens, num_layers,\n",
        "                      dropout=dropout)\n",
        "\n",
        "  def forward(self, X):\n",
        "    \"\"\"Hint: always make sure your sizes are correct\"\"\"\n",
        "    ####################################################################\n",
        "    # Fill in missing code below (...),\n",
        "    # then remove or comment the line below to test your function\n",
        "    raise NotImplementedError(\"Encoder Forward\")\n",
        "    ####################################################################\n",
        "\n",
        "    # The output `X` shape: (`batch_size`, `num_steps`, `embed_size`)\n",
        "\n",
        "    # Embedding layer + reshape\n",
        "    X = ...\n",
        "\n",
        "    # Recurrent unit\n",
        "\n",
        "    # `output` shape: (`num_steps`, `batch_size`, `num_hiddens`)\n",
        "    # `state` shape: (`num_layers`, `batch_size`, `num_hiddens`)\n",
        "    return output, state\n",
        "\n",
        "\n",
        "class Decoder(nn.Module):\n",
        "    \"\"\"The RNN decoder for sequence to sequence learning.\"\"\"\n",
        "    def __init__(self, vocab_size, embed_size, num_hiddens, num_layers,\n",
        "                 dropout=0):\n",
        "        super(Decoder, self).__init__()\n",
        "        self.embedding = nn.Embedding(vocab_size, embed_size)\n",
        "        \n",
        "        self.gru = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers,\n",
        "                          dropout=dropout)\n",
        "        self.dense = nn.Linear(num_hiddens, vocab_size)\n",
        "        \n",
        "    def init_state(self, enc_outputs):\n",
        "        return enc_outputs[1]\n",
        "\n",
        "    def forward(self, X, state):\n",
        "        \"\"\"Hint: always make sure your sizes are correct\"\"\"\n",
        "        ####################################################################\n",
        "        # Fill in missing code below (...),\n",
        "        # then remove or comment the line below to test your function\n",
        "        raise NotImplementedError(\"Decoder Forward\")\n",
        "        ####################################################################\n",
        "\n",
        "        # The output `X` shape: (`num_steps`, `batch_size`, `embed_size`)\n",
        "        X = ...\n",
        "        # Broadcast `context` so it has the same `num_steps` as `X`\n",
        "        context = ...\n",
        "\n",
        "        # Concatenate X and context \n",
        "        X_and_context = ...\n",
        "\n",
        "        # Recurrent unit\n",
        "        output, state = self.rnn(X_and_context, state)\n",
        "\n",
        "        # Linear layer\n",
        "        output = ...\n",
        "\n",
        "        # `output` shape: (`batch_size`, `num_steps`, `vocab_size`)\n",
        "        # `state` shape: (`num_layers`, `batch_size`, `num_hiddens`)\n",
        "        return output, state\n",
        "\n",
        "# # Uncomment to run\n",
        "# encoder = Encoder(1000, 300, 100, 2, 0.1)\n",
        "# decoder = Decoder(1000, 300, 100, 2, 0.1)\n",
        "# print(encoder)\n",
        "# print(decoder)"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EDporX7Trenr"
      },
      "source": [
        "# Here's a bad example \n",
        "\n",
        "Look at the LSTM's forward method, the first instance is what the student see's and forward method after the `#solution to_remove` is the perscribed answer\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tKtCYIqMueeK"
      },
      "source": [
        "class LSTM(nn.Module):\n",
        "  def __init__(self, layers, output_size, hidden_size, vocab_size, embed_size):\n",
        "    super(LSTM, self).__init__()\n",
        "\n",
        "    self.output_size = output_size\n",
        "    self.hidden_size = hidden_size\n",
        "    self.vocab_size = vocab_size\n",
        "    self.embed_size = embed_size\n",
        "    self.n_layers = layers\n",
        "\n",
        "    ####################################################################\n",
        "    # Fill in missing code below (...),\n",
        "    # then remove or comment the line below to test your function\n",
        "    raise NotImplementedError(\"LSTM Init\")\n",
        "    ####################################################################\n",
        "    self.word_embeddings = ...\n",
        "    self.dropout = ...\n",
        "    self.lstm = ...\n",
        "    self.fc = ...\n",
        "\n",
        "  def forward(self, input_sentences):\n",
        "    \"\"\"Hint: Make sure the shapes of your tensors match the requirement\"\"\"\n",
        "\n",
        "    ####################################################################\n",
        "    # Fill in missing code below (...),\n",
        "    # then remove or comment the line below to test your function\n",
        "    raise NotImplementedError(\"LSTM Forward\")\n",
        "    ####################################################################\n",
        "\n",
        "    # Embeddings \n",
        "    # `input` shape: (`num_steps`, `batch_size`, `num_hiddens`)\n",
        "    input = ...\n",
        "\n",
        "    # Initialize a random hidden state and cell state for this sequence\n",
        "    hidden = (torch.randn(self.n_layers, input.shape[1], self.hidden_size).to(device),\n",
        "            torch.randn(self.n_layers, input.shape[1], self.hidden_size).to(device))\n",
        "\n",
        "    # Dropout for regularization\n",
        "    input = self.dropout(input)\n",
        "\n",
        "    # LSTM \n",
        "    output, hidden = ...\n",
        "\n",
        "    # Pick the hidden state (not cell state) and reshape it for the linear layer\n",
        "    h_n = ...\n",
        "\n",
        "    # Linear \n",
        "    logits = self.fc(h_n)\n",
        "    return logits\n",
        "\n",
        "# # Uncomment to run\n",
        "# sampleLSTM = LSTM(3, 10, 100, 1000, 300)\n",
        "# print(sampleLSTM)\n",
        "\n",
        "\n",
        "\n",
        "# Solution - to remove\n",
        "class LSTM(nn.Module):\n",
        "  def __init__(self, layers, output_size, hidden_size, vocab_size, embed_size):\n",
        "    super(LSTM, self).__init__()\n",
        "\n",
        "    self.output_size = output_size\n",
        "    self.hidden_size = hidden_size\n",
        "    self.vocab_size = vocab_size\n",
        "    self.embed_size = embed_size\n",
        "    self.n_layers = layers\n",
        "\n",
        "    self.word_embeddings = nn.Embedding(vocab_size, embed_size)\n",
        "    self.dropout = nn.Dropout(0.5)\n",
        "    self.lstm = nn.LSTM(embed_size, hidden_size, num_layers=self.n_layers)\n",
        "    self.fc = nn.Linear(self.n_layers*self.hidden_size, output_size)\n",
        "\n",
        "  def forward(self, input_sentences):\n",
        "    input = self.word_embeddings(input_sentences).permute(1, 0, 2)\n",
        "    hidden = (torch.randn(self.n_layers, input.shape[1], self.hidden_size).to(device),\n",
        "            torch.randn(self.n_layers, input.shape[1], self.hidden_size).to(device))\n",
        "    input = self.dropout(input)\n",
        "    output, hidden = self.lstm(input, hidden)\n",
        "    h_n = hidden[0].permute(1, 0, 2)\n",
        "    h_n = h_n.contiguous().view(h_n.shape[0], -1)\n",
        "    logits = self.fc(h_n)\n",
        "    return logits"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mGVjVQytvAEH"
      },
      "source": [
        "There are several problems with this section, including:\n",
        "\n",
        "1.   Too many composed functions written in one line\n",
        "2.   no code hints to students describing what manipulations need to occur\n",
        "3.   It is not obvious what is occuring in the two h_n manipulations as the code is generic \n",
        "4.   Using Logits as output and using output as a different variable is confusing \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Q5mmpfWR1Gd"
      },
      "source": [
        "# 4.3 Munging Code Best Practices \n",
        "while not a complete list, here are some common operations and how to make them more interpretable"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5vKsuzCRULET",
        "outputId": "f57592ca-93dc-49d9-f64c-a32e7c8fa81b"
      },
      "source": [
        "# using rearrage instead of transpose allows users to understand from code\n",
        "# which dimensions are changing\n",
        "\n",
        "from einops import rearrange\n",
        "\n",
        "# `ims` is a input ( `batch_size`, `height`, `width`, `num_channels` ) tensor\n",
        "ims = torch.rand(5, 100, 128, 3)\n",
        "\n",
        "# ims.transpose(0,2,1,3) equivalent \n",
        "t = rearrange(ims, 'b h w c -> b w h c')\n",
        "print(t.shape)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([5, 128, 100, 3])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rxAPhrthUlQA"
      },
      "source": [
        "Full einops tutorial [here](http://einops.rocks/1-einops-basics/#welcome-to-einops-land)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xweIQTUCQ5vd"
      },
      "source": [
        "## Flattening tensors"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g4oiA3clUykv",
        "outputId": "44f9ec3d-a511-40b2-c55b-35174dd6eb17"
      },
      "source": [
        "# Flatten Tensors with rearrange or torch.flatten\n",
        "# ims.view(-1)\n",
        "\n",
        "t = torch.flatten(ims, start_dim=1, end_dim = 2)\n",
        "print(t.shape)"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([5, 12800, 3])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WhzpNLFSQ9IT"
      },
      "source": [
        "## Adding dimensions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LC93wfg70qmi",
        "outputId": "fe9ecb8c-847e-4c09-acf6-303751239b6e"
      },
      "source": [
        "# Add dimensions using unsqueeze \n",
        "im = torch.rand(100, 128)\n",
        "\n",
        "# lets say im is one image from our dataset and we want to set it back to \n",
        "# a 4-d `batch` , `height`, `width`, `channels` tensor \n",
        "\n",
        "t = im.unsqueeze(0).unsqueeze(3) \n",
        "print(t.shape)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([1, 100, 128, 1])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iNIu3GJyxD2c"
      },
      "source": [
        "# NLP Specific info\n",
        "\n",
        "From Dr. Lyle Ungar \n",
        "\n",
        "1.   This is a international class so use Glove for word embedding.\n",
        "2.   Use smaller networks, RoBERTA works even better than BERT and is same size. it will have a warning that CLS token is untrained but can suppress.\n",
        "3.   Training times for NLp can be quite large so be sure to use pretrained models when appropriate\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JQycBYKgd47Q"
      },
      "source": [
        ""
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jENvGy_Jd6AD"
      },
      "source": [
        "# RL Specific Info\n",
        "### TO-DO"
      ]
    }
  ]
}