ClimatematchAcademy_DL_Tutorial_Carpentry.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "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*"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "qfFA1VsB4Ieb"
      },
      "source": [
        "**Our 2023 Sponsors**\n",
        "\n",
        "<!-- <p align='center'><img src='https://github.com/NeuromatchAcademy/widgets/blob/master/sponsors.png?raw=True'/></p> -->"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "gzAa0I1xZ79h"
      },
      "source": [
        "---\n",
        "#Tutorial Objectives\n",
        "\n",
        "Teach how to create didactic, easily digestable and fun content for the CMA-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",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 501
        },
        "id": "6C8JNxNy7KvH",
        "outputId": "1b193555-e352-488b-ca00-294780b3d3c6"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "\n",
              "        <iframe\n",
              "            width=\"854\"\n",
              "            height=\"480\"\n",
              "            src=\"https://mfr.ca-1.osf.io/render?url=https://osf.io/wcjrv/?direct%26mode=render%26action=download%26mode=render\"\n",
              "            frameborder=\"0\"\n",
              "            allowfullscreen\n",
              "        ></iframe>\n",
              "        "
            ],
            "text/plain": [
              "<IPython.lib.display.IFrame at 0x7f381c5c2710>"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# @title Tutorial slides\n",
        "\n",
        "from IPython.display import IFrame\n",
        "IFrame(src=f\"https://mfr.ca-1.osf.io/render?url=https://osf.io/wcjrv/?direct%26mode=render%26action=download%26mode=render\", width=854, height=480)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q3FT_nBtiZxt"
      },
      "source": [
        "These are the slides for all videos in this tutorial. If you want to locally download the slides, click [here](https://osf.io/wcjrv/download)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KXX5qll-dtCl"
      },
      "source": [
        "---\n",
        "# Setup"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "cellView": "both",
        "id": "3Yuh005kCT0v"
      },
      "outputs": [],
      "source": [
        "# Import\n",
        "# Import only the libraries/objects that you use in this tutorial. \n",
        "\n",
        "# follow this order: numpy>matplotlib. \n",
        "# import widgets in hidden Figure settings cell\n",
        "\n",
        "import os\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"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "PCOz4jKJXGya"
      },
      "outputs": [],
      "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/CMA.mplstyle\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fbUVuJDTSmZP"
      },
      "source": [
        "# Common Helper Functions "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "vG8R5TW1eGWS"
      },
      "outputs": [],
      "source": [
        "# @title Helper functions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "36wVs0wpeJSP"
      },
      "outputs": [],
      "source": [
        "# @title Plotting functions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vGVC4AWz41jD",
        "outputId": "2a219f84-33e8-48ee-b8aa-4f85d3a29275"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Random seed 2021 has been set.\n"
          ]
        }
      ],
      "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"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "gqgSq2WT_yEz"
      },
      "outputs": [],
      "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(\"GPU is not enabled in this notebook. \\n\"\n",
        "          \"If you want to enable it, in the menu under `Runtime` -> \\n\"\n",
        "          \"`Hardware accelerator.` and select `GPU` from the dropdown menu\")\n",
        "  else:\n",
        "    print(\"GPU is enabled in this notebook. \\n\"\n",
        "          \"If you want to disable it, in the menu under `Runtime` -> \\n\"\n",
        "          \"`Hardware accelerator.` and select `None` from the dropdown menu\")\n",
        "\n",
        "  return device"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YvR8oC4K4nH4",
        "outputId": "854b9057-2898-4e1b-95ab-b0fbd9bb8f83"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Random seed 2021 has been set.\n",
            "GPU is not enabled in this notebook. \n",
            "If you want to enable it, in the menu under `Runtime` -> \n",
            "`Hardware accelerator.` and select `GPU` from the dropdown menu\n"
          ]
        }
      ],
      "source": [
        "SEED = 2021\n",
        "set_seed(seed=SEED)\n",
        "DEVICE = set_device()"
      ]
    },
    {
      "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",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 581,
          "referenced_widgets": [
            "35efd76700784537a72c83b39a255794",
            "8dca7a3ae86d42ed90798b04c7f20abc",
            "7d2ce27219d74b32b04eb9132aa01a39",
            "c3c3af7354644ddcac793383b1432f6e",
            "fe81dbd640d74725b201b5d5b8ef1e9b",
            "f42105e9561049758cb8726fe2143d64"
          ]
        },
        "id": "ThcPwgvzvV-6",
        "outputId": "de12b710-651d-47fa-9055-21fd1bb4abde"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "35efd76700784537a72c83b39a255794",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "Tab(children=(Output(), Output()), _titles={'0': 'Youtube', '1': 'Bilibili'})"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# @title Video 1: Video 1 Name\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=\"BV1Av411n7oL\", 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=\"ca21SNqt78I\", 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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7w9LT3ywjeNH"
      },
      "source": [
        "The final cell with the video should look like the one below:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 581,
          "referenced_widgets": [
            "d0a94d24d1524b61bb91555c126b38a9",
            "ddd2e299da414bb1b86826dec34207ab",
            "0b90acf947b9409582f31a2be08e78ee",
            "3941a890518743cd947ae60a2bcf15b0",
            "4476cd6ebb0044e798adcd638100a22c",
            "abf1a0bc9f48441a98aa56d75024e26e"
          ]
        },
        "id": "0ORMQP5RjkIk",
        "outputId": "a6eaa2a5-8f7c-4269-b9df-4ad0ec619717"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "d0a94d24d1524b61bb91555c126b38a9",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "Tab(children=(Output(), Output()), _titles={'0': 'Youtube', '1': 'Bilibili'})"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# @title Video 2: Video 2 Name\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=\"BV1gf4y1j7UZ\", 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=\"l-K6495BN-4\", 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)"
      ]
    },
    {
      "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": [
        "---\n",
        "# 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": [
        "---\n",
        "# Section 3: Writing Exercises "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KMFOHL7Pj8mf"
      },
      "source": [
        "This 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",
      "execution_count": 12,
      "metadata": {
        "id": "DyrdSzS4mIFI"
      },
      "outputs": [],
      "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()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cw463ZN4m4sG"
      },
      "source": [
        "## Coding Exercise 3: Exercise title\n",
        "\n",
        "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",
      "execution_count": 13,
      "metadata": {
        "id": "ztCl8eDHjyuX"
      },
      "outputs": [],
      "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)"
      ]
    },
    {
      "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",
      "execution_count": 14,
      "metadata": {
        "cellView": "both",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 450
        },
        "id": "tycSi5Pxbsne",
        "outputId": "16f6849b-5d44-496a-a8e9-62e8163e0a2d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Random seed 2021 has been set.\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "image/png": {
              "height": 416,
              "width": 560
            }
          },
          "output_type": "display_data"
        }
      ],
      "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)"
      ]
    },
    {
      "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",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 519
        },
        "id": "AFd7Ji-twKIK",
        "outputId": "63a24e8d-ee69-4932-e77e-cbbe5f107bf5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Video available at https://youtu.be/\n"
          ]
        },
        {
          "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 0x7f3714e08e10>"
            ]
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "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"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Z6vKsN89rN1"
      },
      "source": [
        "## Section 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",
      "execution_count": 16,
      "metadata": {
        "id": "mjXZX2bBFq5A"
      },
      "outputs": [],
      "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"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "msrOpAg6Hclj"
      },
      "outputs": [],
      "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"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ersfq2c8VGGH"
      },
      "source": [
        "## Section 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": [
        "## Section 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",
      "execution_count": 18,
      "metadata": {
        "id": "DTY-kaQ-re74"
      },
      "outputs": [],
      "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)"
      ]
    },
    {
      "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",
      "execution_count": 19,
      "metadata": {
        "id": "tKtCYIqMueeK"
      },
      "outputs": [],
      "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"
      ]
    },
    {
      "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": [
        "## Section 4.4: 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",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5vKsuzCRULET",
        "outputId": "481e84a2-ec08-4b4b-ff8a-4c934d0bdd97"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "torch.Size([5, 128, 100, 3])\n"
          ]
        }
      ],
      "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)"
      ]
    },
    {
      "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",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g4oiA3clUykv",
        "outputId": "dad8ef32-9b1e-456d-b4e2-aae92f2b55dd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "torch.Size([5, 12800, 3])\n"
          ]
        }
      ],
      "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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WhzpNLFSQ9IT"
      },
      "source": [
        "### Adding dimensions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LC93wfg70qmi",
        "outputId": "de5b2011-abef-48e6-a768-0a1d3a2166df"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "torch.Size([1, 100, 128, 1])\n"
          ]
        }
      ],
      "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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iNIu3GJyxD2c"
      },
      "source": [
        "---\n",
        "# Section 5: 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",
      "execution_count": 22,
      "metadata": {
        "id": "JQycBYKgd47Q"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jENvGy_Jd6AD"
      },
      "source": [
        "---\n",
        "# Section 6: RL Specific Info\n",
        "### TO-DO"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "include_colab_link": true,
      "name": "NeuromatchAcademy_DL_Tutorial Carpentry",
      "provenance": [],
      "toc_visible": 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": {
        "0b90acf947b9409582f31a2be08e78ee": {
          "model_module": "@jupyter-widgets/output",
          "model_module_version": "1.0.0",
          "model_name": "OutputModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/output",
            "_model_module_version": "1.0.0",
            "_model_name": "OutputModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/output",
            "_view_module_version": "1.0.0",
            "_view_name": "OutputView",
            "layout": "IPY_MODEL_4476cd6ebb0044e798adcd638100a22c",
            "msg_id": "",
            "outputs": [
              {
                "name": "stdout",
                "output_type": "stream",
                "text": [
                  "Video available at https://youtube.com/watch?v=l-K6495BN-4\n"
                ]
              },
              {
                "data": {
                  "image/jpeg": "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\n",
                  "text/html": "\n        <iframe\n            width=\"854\"\n            height=\"480\"\n            src=\"https://www.youtube.com/embed/l-K6495BN-4?fs=1&rel=0\"\n            frameborder=\"0\"\n            allowfullscreen\n        ></iframe>\n        ",
                  "text/plain": "<IPython.lib.display.YouTubeVideo at 0x7f3714e7c9d0>"
                },
                "metadata": {},
                "output_type": "display_data"
              }
            ]
          }
        },
        "35efd76700784537a72c83b39a255794": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "TabModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "TabModel",
            "_titles": {
              "0": "Youtube",
              "1": "Bilibili"
            },
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "TabView",
            "box_style": "",
            "children": [
              "IPY_MODEL_7d2ce27219d74b32b04eb9132aa01a39",
              "IPY_MODEL_c3c3af7354644ddcac793383b1432f6e"
            ],
            "layout": "IPY_MODEL_8dca7a3ae86d42ed90798b04c7f20abc",
            "selected_index": 0
          }
        },
        "3941a890518743cd947ae60a2bcf15b0": {
          "model_module": "@jupyter-widgets/output",
          "model_module_version": "1.0.0",
          "model_name": "OutputModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/output",
            "_model_module_version": "1.0.0",
            "_model_name": "OutputModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/output",
            "_view_module_version": "1.0.0",
            "_view_name": "OutputView",
            "layout": "IPY_MODEL_abf1a0bc9f48441a98aa56d75024e26e",
            "msg_id": "",
            "outputs": [
              {
                "name": "stdout",
                "output_type": "stream",
                "text": [
                  "Video available at https://www.bilibili.com/video/BV1gf4y1j7UZ\n"
                ]
              },
              {
                "data": {
                  "text/html": "\n        <iframe\n            width=\"854\"\n            height=\"480\"\n            src=\"https://player.bilibili.com/player.html?bvid=BV1gf4y1j7UZ&page=1?fs=1\"\n            frameborder=\"0\"\n            allowfullscreen\n        ></iframe>\n        ",
                  "text/plain": "<__main__.BiliVideo at 0x7f3714e53110>"
                },
                "metadata": {},
                "output_type": "display_data"
              }
            ]
          }
        },
        "4476cd6ebb0044e798adcd638100a22c": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "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
          }
        },
        "7d2ce27219d74b32b04eb9132aa01a39": {
          "model_module": "@jupyter-widgets/output",
          "model_module_version": "1.0.0",
          "model_name": "OutputModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/output",
            "_model_module_version": "1.0.0",
            "_model_name": "OutputModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/output",
            "_view_module_version": "1.0.0",
            "_view_name": "OutputView",
            "layout": "IPY_MODEL_fe81dbd640d74725b201b5d5b8ef1e9b",
            "msg_id": "",
            "outputs": [
              {
                "name": "stdout",
                "output_type": "stream",
                "text": [
                  "Video available at https://youtube.com/watch?v=ca21SNqt78I\n"
                ]
              },
              {
                "data": {
                  "image/jpeg": "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\n",
                  "text/html": "\n        <iframe\n            width=\"854\"\n            height=\"480\"\n            src=\"https://www.youtube.com/embed/ca21SNqt78I?fs=1&rel=0\"\n            frameborder=\"0\"\n            allowfullscreen\n        ></iframe>\n        ",
                  "text/plain": "<IPython.lib.display.YouTubeVideo at 0x7f3717c0e910>"
                },
                "metadata": {},
                "output_type": "display_data"
              }
            ]
          }
        },
        "8dca7a3ae86d42ed90798b04c7f20abc": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "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
          }
        },
        "abf1a0bc9f48441a98aa56d75024e26e": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "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
          }
        },
        "c3c3af7354644ddcac793383b1432f6e": {
          "model_module": "@jupyter-widgets/output",
          "model_module_version": "1.0.0",
          "model_name": "OutputModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/output",
            "_model_module_version": "1.0.0",
            "_model_name": "OutputModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/output",
            "_view_module_version": "1.0.0",
            "_view_name": "OutputView",
            "layout": "IPY_MODEL_f42105e9561049758cb8726fe2143d64",
            "msg_id": "",
            "outputs": [
              {
                "name": "stdout",
                "output_type": "stream",
                "text": [
                  "Video available at https://www.bilibili.com/video/BV1Av411n7oL\n"
                ]
              },
              {
                "data": {
                  "text/html": "\n        <iframe\n            width=\"854\"\n            height=\"480\"\n            src=\"https://player.bilibili.com/player.html?bvid=BV1Av411n7oL&page=1?fs=1\"\n            frameborder=\"0\"\n            allowfullscreen\n        ></iframe>\n        ",
                  "text/plain": "<__main__.BiliVideo at 0x7f3715a19790>"
                },
                "metadata": {},
                "output_type": "display_data"
              }
            ]
          }
        },
        "d0a94d24d1524b61bb91555c126b38a9": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "TabModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "TabModel",
            "_titles": {
              "0": "Youtube",
              "1": "Bilibili"
            },
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "TabView",
            "box_style": "",
            "children": [
              "IPY_MODEL_0b90acf947b9409582f31a2be08e78ee",
              "IPY_MODEL_3941a890518743cd947ae60a2bcf15b0"
            ],
            "layout": "IPY_MODEL_ddd2e299da414bb1b86826dec34207ab",
            "selected_index": 0
          }
        },
        "ddd2e299da414bb1b86826dec34207ab": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "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
          }
        },
        "f42105e9561049758cb8726fe2143d64": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "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
          }
        },
        "fe81dbd640d74725b201b5d5b8ef1e9b": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "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
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}