colabs/summer_schools/intro_to_python_numpy_for_deep_learning.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N1EHYIqxd80m"
      },
      "source": [
        "\u003e Copyright 2022 DeepMind Technologies Limited.\n",
        "\u003e\n",
        "\u003e Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "\u003e you may not use this file except in compliance with the License.\n",
        "\u003e\n",
        "\u003e You may obtain a copy of the License at\n",
        "\u003e https://www.apache.org/licenses/LICENSE-2.0\n",
        "\u003e\n",
        "\u003e Unless required by applicable law or agreed to in writing, software\n",
        "\u003e distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "\u003e WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "\u003e See the License for the specific language governing permissions and\n",
        "\u003e limitations under the License."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-yUlZFskgI5g"
      },
      "source": [
        "# **Introduction to Python and NumPy for Deep Learning**\n",
        "\n",
        "All the code examples and tutorials provided in this repository use the [Python](https://www.python.org/) programming language and heavily rely on the [NumPy](https://numpy.org/) package for scientific computing with Python.\n",
        "\n",
        "### **What does this introduction cover?**\n",
        "\n",
        "This colab should be seen as a reference resource for Python and NumPy that covers foundational topics used in other educational colabs in this repository.\n",
        "\n",
        "This colab should help you with questions like:\n",
        "\n",
        "* What library can I use for debugging in Python?\n",
        "* What are these libraries and packages that come up in the other colabs, such as `functools`, `dataclasses` and `re`?\n",
        "* How can I use NumPy to do my data transformations, such as reshaping arrays and accessing specific slices of elements?\n",
        "\n",
        "This colab is not intended to be an exhaustive resource for teaching either Python or NumPy. For more details not covered here, we recommend checking the additional resources listed throughout the colab."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M8axcHd2TDvF"
      },
      "source": [
        "## Before getting started...\n",
        "\n",
        "If you're not familiar with using Colabs, please check out this [quick tutorial](https://www.youtube.com/watch?v=inN8seMm7UI) and [intro notebook](https://colab.sandbox.google.com/notebooks/intro.ipynb).\n",
        "\n",
        "This material assumes you're already familiar with programming. In case you are not, you can check these great resources:\n",
        "\n",
        "* [Introduction to Programming and Computer Science - Full Course @ freeCodeCamp.org](https://www.youtube.com/watch?v=zOjov-2OZ0E)\n",
        "* [Code Yourself! An Introduction to Programming @ Coursera](https://www.coursera.org/learn/intro-programming)\n",
        "* [Introductory Programming Courses @ MITOpenCourseware](https://ocw.mit.edu/courses/intro-programming/)\n",
        "* [Online Programming Courses @ Harvard Online Courses](https://online-learning.harvard.edu/subject/programming)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "npBq24DzB4NB"
      },
      "source": [
        "### Python Version\n",
        "\n",
        "For this series of colabs, we use Python 3.7. Make sure to check that your environment is using a Python version \u003e= 3.7:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "W7r82pml7s_u"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Python version:\n",
            "3.7.13 (default, Apr 24 2022, 01:04:09) \n",
            "[GCC 7.5.0]\n"
          ]
        }
      ],
      "source": [
        "import sys  # https://docs.python.org/3/library/sys.html\n",
        "\n",
        "# Let's check which version of Python we're using.\n",
        "print('Python version:')\n",
        "print(sys.version)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rt4JECYLgRW6"
      },
      "source": [
        "# Part I: Introduction to Python\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BdIl5Hm_bkf9"
      },
      "source": [
        "### About the Python Language\n",
        "\n",
        "[Python](https://www.python.org/) is a  **interpreted** (1), **high-level** (2), and **dynamically-typed** (3) programming language.\n",
        "\n",
        "Let's break down what we mean by this:\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jjc-FaouVsVN"
      },
      "source": [
        "\n",
        "#### 1. Python is an **interpreted** language.\n",
        "\n",
        "This means that there's no compilation step to execute Python code – the code is transformed into machine instructions during execution by a Python interpreter.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xK5LMB6xVtda"
      },
      "source": [
        "\n",
        "\n",
        "#### 2. Python is **high-level**.\n",
        "\n",
        "Python offers many abstractions that make it easy for programmers to code programs without having to understand all the mechanisms underneath that allow the code to actually execute. In fact, reading Python is very similar to reading pseudo-code or even natural language.\n",
        "\n",
        "For example, here is the pseudo-code for bubble sort:\n",
        "\n",
        "```\n",
        "BubbleSort(Array)\n",
        "{\n",
        "    Initialise n = Length of Array\n",
        "    for i = 1 to n do\n",
        "        for j = 1 to n-1 do\n",
        "            if Array[j] \u003e Array[j+1] do\n",
        "                swap(Array[j], Array[j+1])\n",
        "            end\n",
        "        end\n",
        "    end\n",
        "}\n",
        "```\n",
        "\n",
        "And here is the code in actual Python:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YIoSouabfCqe"
      },
      "outputs": [],
      "source": [
        "def bubble_sort(array):\n",
        "  n = len(array)\n",
        "  for i in range(n):\n",
        "    for j in range(n-1):\n",
        "      if array[j] \u003e array[j+1]:\n",
        "        array[j], array[j+1] = array[j+1], array[j]\n",
        "  return array\n",
        "\n",
        "# Checking if the sorting algorithm works as expected.\n",
        "assert bubble_sort([1, 2, 5, 0, 12, 8, 5]) == [0, 1, 2, 5, 5, 8, 12]\n",
        "assert bubble_sort(\n",
        "    [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
        "assert bubble_sort([0]) == [0]\n",
        "assert bubble_sort([100, 500, -1, 0]) == [-1, 0, 100, 500]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dXFtEam69sHW"
      },
      "source": [
        "The fact that Python is high-level makes it quite readable (compared to other programming languages, for example C++ or Java) - we hope you agree! :) \n",
        "\n",
        "#### 3. Python is **dynamically-typed**\n",
        "\n",
        "This means that the type of a variable (e.g. whether it's an integer or string) is checked during runtime, so we don't need to specify the variable type when defining it:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fWkjOIoxUdBK"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "11"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "var = 1   # Here, `var` is an int, but we don't need to explicitly state that.\n",
        "var + 10  # Since `var` is an int, we can perform mathematical operations on it."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ajt-R__y-exy"
      },
      "source": [
        "We could also make `var` be a string (again, without declaring the type beforehand):"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "a9r8-U95-PTa"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'HELLO'"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "var = 'hello'\n",
        "var.upper()  # We can use the string method upper()."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UCjIoZL0VwP_"
      },
      "source": [
        "## Producing outputs\n",
        "\n",
        "\n",
        "We can write a message on the user's screen with the `print` function."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3XR4ywX7V0EA"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hello Machine Learning World!\n"
          ]
        }
      ],
      "source": [
        "print('Hello Machine Learning World!')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mIEgt1lcWG_C"
      },
      "source": [
        "We can use the colab **form** field to parameterise some code (i.e. expect an input from the user, and change the code behaviour accordingly):"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ahWxMZjdWJm1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hello World\n"
          ]
        }
      ],
      "source": [
        "name = \"World\" # @param {type:\"string\"}\n",
        "\n",
        "print('Hello', name)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gnv6ll4CWay4"
      },
      "source": [
        "It's common to format a printed message printed in a more customised manner by using **f-strings** to intersperse raw strings with Python variables or code. F-strings are easy to use: they are in quotes like normal strings, but they start with `f` and contain code elements within squiggly brackets `{}`:\n",
        "\n",
        "For example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VTP-xnKpWw1N"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hello Alan, good to see you here!\n",
            "How are you, Alan Turing?\n",
            "I hear you were born in 1912!\n"
          ]
        }
      ],
      "source": [
        "name = \"Alan\" # @param {type:\"string\"}\n",
        "last_name = \"Turing\"  # @param {type:\"string\"}\n",
        "birth_year = 1912 # @param {type:\"integer\"}\n",
        "\n",
        "print(f'Hello {name}, good to see you here!')\n",
        "print(f'How are you, {name + \" \" + last_name}?')\n",
        "print(f'I hear you were born in {birth_year}!')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SRTcZKEonA7Q"
      },
      "source": [
        "For more about string formatting, check out [this resource](https://docs.python.org/3/tutorial/inputoutput.html)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rDKC2-zcl8TO"
      },
      "source": [
        "## Common Python Types and How to Manipulate Them\n",
        "\n",
        "Here, we define the most common Python types – from simpler types such as numbers, strings and booleans, to more complex container types such as lists, tuples and dictionaries."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oefDNdUwmGgm"
      },
      "source": [
        "### Numbers\n",
        "\n",
        "Python supports three basic number types: **integers**, **floating point** numbers (or **floats**) and **complex numbers**. Here, we'll take a look at integers and floating point numbers."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7wj461apaIwH"
      },
      "source": [
        "#### Types of Numbers"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-zHYAtRCmI4o"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1 \t\t type num_1: \u003cclass 'int'\u003e\n",
            "1.0 \t\t type num_2: \u003cclass 'float'\u003e\n",
            "1000000.0 \t type num_3: \u003cclass 'float'\u003e\n",
            "-25000000.0 \t type num_4: \u003cclass 'float'\u003e\n",
            "-0.000314 \t type num_5: \u003cclass 'float'\u003e\n",
            "14000000 \t type num_6: \u003cclass 'int'\u003e\n"
          ]
        }
      ],
      "source": [
        "num_1 = 1\n",
        "# Note that \\t is a character that prints a \"tab key\", a special character\n",
        "# often used to create nicely aligned output (see the output of this cell).\n",
        "print(num_1, '\\t\\t', 'type num_1:', type(num_1))\n",
        "\n",
        "num_2 = 1.0\n",
        "print(num_2, '\\t\\t', 'type num_2:', type(num_2))\n",
        "\n",
        "# Scientific notation using e\u003cnumber\u003e facilitates reading very large\n",
        "# or very small numbers.\n",
        "num_3 = 1e6\n",
        "print(num_3, '\\t', 'type num_3:', type(num_3))\n",
        "num_4 = -2.5e7\n",
        "print(num_4, '\\t', 'type num_4:', type(num_4))\n",
        "num_5 = -3.14e-4\n",
        "print(num_5, '\\t', 'type num_5:', type(num_5))\n",
        "\n",
        "# Underscore notation using _ facilitates reading very large numbers.\n",
        "num_6 = 14_000_000\n",
        "print(num_6, '\\t', 'type num_6:', type(num_6))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C4wz_kcoF65A"
      },
      "source": [
        "You can mix integers and floats in operations:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FJpu_8SfmQiU"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "num_1: 1\n",
            "num_2: 1.0\n",
            "sum of num_1 and num_2 is 2.0 which is type \u003cclass 'float'\u003e\n"
          ]
        }
      ],
      "source": [
        "# Sum of int type + float type = float type.\n",
        "print(f'num_1: {num_1}\\nnum_2: {num_2}')\n",
        "print(f'sum of num_1 and num_2 is {num_1 + num_2} '\n",
        "      f'which is type {type(num_1 + num_2)}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9FDPGCh5nipZ"
      },
      "source": [
        "Python supports arbitrarily large integers – any number that needs more than 32-bits to be encoded will be automatically and transparently handled!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MxQewixloIyG"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "5294967295.0"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "(2 ** 32 - 1) + 1e9"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dI3ny3H5XCnO"
      },
      "source": [
        "#### Mathematical Operations on Numbers"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rAqmCSuIXFhh"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Sum\t\t20 + 3 = 23\n",
            "Division\t20 / 3 = 6.666666666666667\n",
            "Floor Division\t20 // 3 = 6\n",
            "Modulo\t\t20 % 3 = 2\n",
            "Multiplication\t20 * 3 = 60\n",
            "Exponentiation\t20 ** 3 = 8000\n",
            "Negated value\t-(20) = -20\n",
            "Absolute value\tabs(-20) = 20\n"
          ]
        }
      ],
      "source": [
        "num_1 = 20  # @param\n",
        "num_2 = 3   # @param\n",
        "\n",
        "# Sum.\n",
        "print(f'Sum\\t\\t{num_1} + {num_2} =', num_1 + num_2)\n",
        "\n",
        "# Division.\n",
        "print(f'Division\\t{num_1} / {num_2} =', num_1 / num_2)\n",
        "\n",
        "# Floor division.\n",
        "print(f'Floor Division\\t{num_1} // {num_2} =', num_1 // num_2)\n",
        "\n",
        "# Modulo (division remainder).\n",
        "print(f'Modulo\\t\\t{num_1} % {num_2} =', num_1 % num_2)\n",
        "\n",
        "# Multiplication.\n",
        "print(f'Multiplication\\t{num_1} * {num_2} =', num_1 * num_2)\n",
        "\n",
        "# Exponentiation.\n",
        "print(f'Exponentiation\\t{num_1} ** {num_2} =', num_1 ** num_2)\n",
        "\n",
        "# Negative.\n",
        "print(f'Negated value\\t-({num_1}) =', -num_1)\n",
        "\n",
        "# Absolute value.\n",
        "print(f'Absolute value\\tabs({-num_1}) =', abs(-num_1))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rntGHAAlnckp"
      },
      "source": [
        "#### Mathematical Expressions\n",
        "\n",
        "In the examples above, we only did operations between two numbers. But what happens if we have an expression with more numbers? For example:\n",
        "\n",
        "`3 + 5 * 10`\n",
        "\n",
        "Should we first add 10 to 11 or multiply 11 to 10? For this, we need to define **operator precedence**. As in mathematics, in Python multiplication is granted a higher precedence than addition.\n",
        "\n",
        "Check out [this resource](https://docs.python.org/3/reference/expressions.html#operator-precedence) for more information on operator precedence.\n",
        "\n",
        "By default, running the expression above produces the following output:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KYFjIeWXnf-t"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "53"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "3 + 5 * 10"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "daRh6OvNoVhb"
      },
      "source": [
        "In order to explicitly express which subexpressions we would like to have higher precedence, we can add brackets `()`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "geBL6irbonhi"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "80"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "(3 + 5) * 10"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8LiS9gsFovqH"
      },
      "source": [
        "### Strings\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qF6RSXz1pLyv"
      },
      "source": [
        "Python has a lot of facilities to manipulate strings. Check out [these docs]( https://docs.python.org/3.4/library/string.html) for more examples.\n",
        "\n",
        "Here is a non-exhaustive list of cool things we can do with strings:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1UysSiXZpOFY"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "String \"abc\" has length 3\n"
          ]
        }
      ],
      "source": [
        "# We can check the length of a string.\n",
        "str_1 = 'abc'\n",
        "print(f'String \"{str_1}\" has length', len(str_1))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b9y5SpWnVmUU"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "First letter of string \"abc\" is a\n",
            "Second letter of string \"abc\" is b\n",
            "Third letter of string \"abc\" is c\n"
          ]
        }
      ],
      "source": [
        "# We can get a specific letter from the string using indexing.\n",
        "print(f'First letter of string \"{str_1}\" is {str_1[0]}')\n",
        "print(f'Second letter of string \"{str_1}\" is {str_1[1]}')\n",
        "print(f'Third letter of string \"{str_1}\" is {str_1[2]}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ksGbeemNqFK8"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'abc def'"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Concatenate strings!\n",
        "str_2 = 'def'\n",
        "str_1 + ' ' + str_2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XIA8Js4S3-qX"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "abc abcabcabcabcabcabcabcabcabcabc\n"
          ]
        }
      ],
      "source": [
        "# Repeat a string many times.\n",
        "print(str_1, str_1 * 10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XZFxD3eApInb"
      },
      "source": [
        "**Important: Strings in Python are immutable!**\n",
        "Meaning, as opposed to some languages, you cannot change a value of a character in a string without creating a new string."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hDURmrTmo91Z"
      },
      "outputs": [
        {
          "ename": "TypeError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m\u003cipython-input-18-c394cadd07e7\u003e\u001b[0m in \u001b[0;36m\u003cmodule\u003e\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mstr_1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'abc'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# We can't assign a new value to a character in a string!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----\u003e 3\u001b[0;31m \u001b[0mstr_1\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'2'\u001b[0m  \u001b[0;31m# TypeError: 'str' object does not support item assignment\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
          ]
        }
      ],
      "source": [
        "str_1 = 'abc'\n",
        "# We can't assign a new value to a character in a string!\n",
        "str_1[0] = '2'  # TypeError: 'str' object does not support item assignment"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bAPxI5oFHMl5"
      },
      "source": [
        "What you observe above is called an **exception**. An exception is an error in execution, which in this case occurs because a string does not support item assignment. We will not go into the details of exceptions and exception handling (which is writing Python programs such that they can catch errors and change their behaviour based on the error). For more details on errors, please check the Python documentation [here](https://docs.python.org/3/tutorial/errors.html)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ib9uUH_7nM8_"
      },
      "source": [
        "### Booleans\n",
        "\n",
        "Booleans represent the logical values 1 (`True`) or 0 (`False`)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ifVo1myInMo-"
      },
      "outputs": [],
      "source": [
        "bool_a = True\n",
        "bool_b = False"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ENgv2gQiwTFd"
      },
      "source": [
        "Let's get familiar with some operations involving boolean variables:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wR-1cQqfpjBp"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "OR \t True OR False = True\n",
            "AND \t True AND False = False\n",
            "NOT \t NOT True = False\n",
            "XOR \t True XOR False = True\n"
          ]
        }
      ],
      "source": [
        "print(f'OR \\t {bool_a} OR {bool_b} =', bool_a or bool_b)\n",
        "print(f'AND \\t {bool_a} AND {bool_b} =', bool_a and bool_b)\n",
        "print(f'NOT \\t NOT {bool_a} =', not bool_a)\n",
        "print(f'XOR \\t {bool_a} XOR {bool_b} =', bool_a ^ bool_b)  # Exclusive OR."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6zU3TAnbaVRZ"
      },
      "source": [
        "### Containers\n",
        "\n",
        "Containers are capable of storing many values in a single place. Python has many different containers. Here, we'll talk about the most common ones:\n",
        "\n",
        "* Lists\n",
        "* Tuples\n",
        "* Dictionaries\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GPIxKmWwBSwt"
      },
      "source": [
        "\n",
        "#### Lists\n",
        "\n",
        "Lists are similar to arrays in other programming languages but are **dynamic**, which means that they can increase in size:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ru7wkhA1sNKg"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1] \n",
            "\n",
            "[1, 1, 2, 3]\n",
            "4 \n",
            "\n",
            "2 \n",
            "\n",
            "4 \n",
            "\n",
            "[1000, 1, 2, 3, 1000, 1, 2, 3] \n",
            "\n",
            "[1, 2, 3, 1000] \n",
            "\n",
            "[1000, 1, 3] \n",
            "\n"
          ]
        }
      ],
      "source": [
        "my_list = []       # Define a list.\n",
        "my_list.append(1)  # Add an element to a list.\n",
        "print(my_list, '\\n')\n",
        "\n",
        "my_list.extend([1, 2, 3])  # Extend a list with another list.\n",
        "print(my_list)\n",
        "print(len(my_list), '\\n')  # Get the number of values in the list.\n",
        "\n",
        "# We can access values by index.\n",
        "print(my_list[2], '\\n')\n",
        "\n",
        "my_list[0] = 1000  # Change value of first element in list.\n",
        "print(len(my_list), '\\n')\n",
        "\n",
        "# The add operation concatenates lists!\n",
        "print(my_list + my_list, '\\n')\n",
        "\n",
        "# We can sort a list.\n",
        "print(sorted(my_list), '\\n')\n",
        "\n",
        "my_list.remove(2)   # Removes the first occurrence of a value.\n",
        "print(my_list, '\\n')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wpdl3dQeBUPz"
      },
      "source": [
        "#### Matrices\n",
        "\n",
        "We can represent a matrix in Python by having a list of lists where all the inner lists have the same length:\n",
        "\n",
        "\n",
        "![picture](https://storage.googleapis.com/dm-educational/assets/intro-to-python-and-numpy/indexing_2d.svg)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "M6cGwJLJBlRx"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3\n",
            "5\n",
            "Number of rows 4\n",
            "Number of columns 3\n"
          ]
        }
      ],
      "source": [
        "matrix = [\n",
        "          [1, 2, 3],\n",
        "          [4, 5, 6],\n",
        "          [7, 8, 9],\n",
        "          [10, 11, 12],\n",
        "          ]\n",
        "\n",
        "# Get a specific element.\n",
        "print(matrix[0][2])  # Get the element at the first row, third column.\n",
        "print(matrix[1][1])  # Get the element at the second row, second column.\n",
        "\n",
        "print('Number of rows', len(matrix))\n",
        "print('Number of columns', len(matrix[0]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zOUZi16tBk0I"
      },
      "source": [
        "**Note that a list of lists is not necessarily a matrix**, since the inner lists can have a different number of elements implying on an inconsistent number of columns!!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VlBtF_gRCFl-"
      },
      "outputs": [],
      "source": [
        "# Valid list of lists but this is not a matrix.\n",
        "list_of_lists = [\n",
        "                 [1],\n",
        "                 [4, 5, 6],\n",
        "                 [7, 8, 9],\n",
        "                 [11, 12]\n",
        "                 ]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I-ZLLKRdzaly"
      },
      "source": [
        "In practice, in machine learning we nearly always use **NumPy arrays** to store and manipulate matrices of numbers (see NumPy sections below)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oq4VgBSZs2Q_"
      },
      "source": [
        "#### Tuples\n",
        "\n",
        "Tuples are similar to lists but are **immutable**."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f4FTlflRuVIW"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(1, 2, 3)\n",
            "1\n",
            "2\n",
            "3\n",
            "1 2 3\n",
            "(1, 2, 3, 4)\n"
          ]
        }
      ],
      "source": [
        "my_tuple = (1, 2, 3)  # Create a tuple.\n",
        "print(my_tuple)\n",
        "\n",
        "# Access its values using indices.\n",
        "print(my_tuple[0])\n",
        "print(my_tuple[1])\n",
        "print(my_tuple[2])\n",
        "\n",
        "# Access its values by unpacking (assigning variables for each tuple value).\n",
        "a, b, c = my_tuple\n",
        "print(a, b, c)\n",
        "\n",
        "print(my_tuple + (4,))  # We can concatenate tuples."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tD_ARdxOu2GZ"
      },
      "source": [
        "Notice that `(4)` is not a tuple – it is a number between brackets, but `(4,`) is a tuple of length 1!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KXaBDfYeu70l"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "execution_count": 25,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "type((4))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8JkklsBL0Abk"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "execution_count": 26,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = (4)\n",
        "x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "C21cou_ru826"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "execution_count": 27,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "type((4,))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gq0SZT5AvD06"
      },
      "source": [
        "#### Dictionaries\n",
        "\n",
        "Dictionaries (also called maps or associative arrays in other languages) associate two types of elements to each other: `keys` and `values`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hfZ5gJD5ve47"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'num_fruit': 5}\n"
          ]
        }
      ],
      "source": [
        "my_dict = {}    # Create an empty dictionary.\n",
        "my_dict['num_fruit'] = 5  # Associates the key 'num_fruit' to the value 5.\n",
        "print(my_dict)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "egoMuN9-veQ9"
      },
      "source": [
        "`keys` are unique, so a dictionary  can't have multiple multiple values associated with a given `key`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "G7My37dGvp59"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'num_fruit': 2}\n"
          ]
        }
      ],
      "source": [
        "# Update the value of key 'num_fruit' to be associated with the value 2.\n",
        "my_dict['num_fruit'] = 2\n",
        "print(my_dict)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Zk8OPaJI0sNU"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'num_fruit': 10, 'origin': 'Brazil'}"
            ]
          },
          "execution_count": 30,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# We can also update a dictionary using `update()`.\n",
        "my_dict.update({'num_fruit': 10,\n",
        "                'origin': 'Brazil'})\n",
        "my_dict"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tlHxIRnT0rKj"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10\n"
          ]
        }
      ],
      "source": [
        "print(my_dict['num_fruit'])  # Access a specific value by keying in."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "e8hQyBlAxQ-J"
      },
      "outputs": [
        {
          "ename": "KeyError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m\u003cipython-input-32-1ec72684f3bd\u003e\u001b[0m in \u001b[0;36m\u003cmodule\u003e\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# We'll see a KeyError if we try to access a key that is not on the dict.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----\u003e 2\u001b[0;31m \u001b[0mmy_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'ripe'\u001b[0m\u001b[0;34m]\u001b[0m  \u001b[0;31m# KeyError: 'ripe'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m: 'ripe'"
          ]
        }
      ],
      "source": [
        "# We'll see a KeyError if we try to access a key that is not on the dict.\n",
        "my_dict['ripe']  # KeyError: 'ripe'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1Vv5XcWtxaGo"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "False\n",
            "True\n"
          ]
        }
      ],
      "source": [
        "# We can check if a key is in the dict before trying to get its value.\n",
        "print('ripe' in my_dict)\n",
        "print('origin' in my_dict)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n0VFm9IBvwYo"
      },
      "source": [
        "We can also create a dictionary with prepopulated keys and values."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LWcMIGhDv0BF"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "{'num_fruit': 10, 'origin': 'Brazil', 'ripe': True}\n",
            "True\n"
          ]
        }
      ],
      "source": [
        "my_dict = {\n",
        "    'num_fruit': 10,\n",
        "    'origin': 'Brazil',\n",
        "    'ripe': True\n",
        "}\n",
        "\n",
        "print(my_dict)\n",
        "print(my_dict['ripe'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5GK1KsTlv-cS"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "dict_keys(['num_fruit', 'origin', 'ripe'])\n",
            "dict_values([10, 'Brazil', True])\n",
            "dict_items([('num_fruit', 10), ('origin', 'Brazil'), ('ripe', True)])\n"
          ]
        }
      ],
      "source": [
        "print(my_dict.keys())    # Get only the keys.\n",
        "print(my_dict.values())  # Get only the values.\n",
        "print(my_dict.items())   # Get both keys and values as a tuple!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wy9905NUwWNw"
      },
      "source": [
        "In machine learning, we can use dictionaries to for example map strings to numbers. Machine learning models generally don't understand strings, so when dealing with text data, it is very common to map each string to a numerical value:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "a62lM_H9woLm"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n",
            "3\n",
            "False\n"
          ]
        }
      ],
      "source": [
        "my_strings = ['I', 'love', 'ML', '\u003c3', '\u003c3', '\u003c3', '!']\n",
        "\n",
        "str_to_int = {\n",
        "    'I': 1,\n",
        "    'love': 2,\n",
        "    'ML': 3,\n",
        "    '\u003c3': 4,\n",
        "    }\n",
        "\n",
        "print(str_to_int['I'])\n",
        "print(str_to_int[my_strings[2]])\n",
        "print('!' in str_to_int)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nU6hLwijafuO"
      },
      "source": [
        "## Conditions\n",
        "\n",
        "In Python, we can check for conditions using `if`, `elif` and `else`.\n",
        "\n",
        "As we saw before, it is a good idea to check if the key is present before trying to access its value. Here is a common usage pattern using `if` to accomplish this:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UaNa-LexyGdr"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n",
            "The value for love is 2\n"
          ]
        }
      ],
      "source": [
        "# Check if the key is in dict.\n",
        "key = 'love'  #@param\n",
        "\n",
        "print(key in str_to_int)\n",
        "\n",
        "if key in str_to_int:\n",
        "  print(f'The value for {key} is {str_to_int[key]}')\n",
        "else:\n",
        "  print(f'{key} is not in the dictionary')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NzoJV0jkzFj8"
      },
      "source": [
        "We can also use `elif` to check multiple conditions. For example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dj8sWzxEzJdH"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "47 is bigger than 11\n"
          ]
        }
      ],
      "source": [
        "num_1 = 47  #@param {type:\"slider\", min:0, max:100, step:1}\n",
        "num_2 = 11  #@param {type:\"slider\", min:0, max:100, step:1}\n",
        "\n",
        "if num_1 \u003e num_2:\n",
        "  print(f'{num_1} is bigger than {num_2}')\n",
        "elif num_1 \u003c num_2:\n",
        "  print(f'{num_1} is smaller than {num_2}')\n",
        "# We could have more elif blocks here...\n",
        "else:\n",
        "  print(f'{num_1} is equal to {num_2}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zdVeoIsCrBFq"
      },
      "source": [
        "### Comparisons\n",
        "\n",
        "The `\u003e` (greater than) and `\u003c` (less than) operators used above are just some of the comparison operators that Python supports. For more information, [check out this resource](https://docs.python.org/3/library/stdtypes.html#comparisons).\n",
        "\n",
        "Some additional examples to peruse:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "V9TZvhzTzvJQ"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n",
            "True\n",
            "True\n"
          ]
        }
      ],
      "source": [
        "print(10 \u003e 6)   # True: 10 is larger than 6.\n",
        "print(6 \u003e 6)    # False: 6 is not larger than 6.\n",
        "print(10 \u003e= 6)  # True: 10 is larger or equal to 6.\n",
        "print(6 \u003e= 6)   # True: 6 is larger or equal to 6."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3w37W1Pu33eK"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "False\n",
            "False\n",
            "True\n"
          ]
        }
      ],
      "source": [
        "print(10 \u003c 5)   # False: 10 is not less than 5.\n",
        "print(10 == 5)  # False: 10 is not equal to 5.\n",
        "print(10 != 5)  # True: 10 is different than 5."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZYOHH0RE34py"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "False\n",
            "True\n",
            "True\n",
            "False\n"
          ]
        }
      ],
      "source": [
        "print('abc' == 'foo')  # False: abc is not equal to foo.\n",
        "print('abc' \u003c 'foo')   # True: abc is alphabetically before foo.\n",
        "print('abc' \u003c 'abcz')  # True: abc is alphabetically before abcz.\n",
        "print('abc' == 1)      # False: abc is not equal to 1."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MCf8VK2E08uq"
      },
      "outputs": [],
      "source": [
        "# Not a valid operation! How could we compare a string to an int?\n",
        "# print('abc' \u003c 1)  # TypeError: '\u003c' not supported between instances of 'str' and 'int'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Okej7Duoqnkz"
      },
      "source": [
        "## Loops\n",
        "\n",
        "Loops are very useful when we want to execute the same computation many times without repeating our code. For example, let's say we want to print \"Hello World\" 5 times. We could copy and paste our code 5 times:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sprhB7Z02V6R"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hello World\n",
            "Hello World\n",
            "Hello World\n",
            "Hello World\n",
            "Hello World\n"
          ]
        }
      ],
      "source": [
        "print('Hello World')\n",
        "print('Hello World')\n",
        "print('Hello World')\n",
        "print('Hello World')\n",
        "print('Hello World')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MCUNVYQ_2ipR"
      },
      "source": [
        "Or better yet, put the code inside of a loop!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LH69vBTW2hn7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hello World\n",
            "Hello World\n",
            "Hello World\n",
            "Hello World\n",
            "Hello World\n"
          ]
        }
      ],
      "source": [
        "for i in range(5):  # Iterate 5 times.\n",
        "  print('Hello World')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lsgEqSRY4YJL"
      },
      "source": [
        "The `for` loop option is preferable because it's more compact and readable.\n",
        "\n",
        "Another `for` loop example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OsQHqE9f2x1K"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0 1 2 3 4 5 6 7 8 9 "
          ]
        }
      ],
      "source": [
        "# Print the values between [0, 10).\n",
        "for i in range(10):\n",
        "  print(i, end=' ')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6JGXUJwc4oT5"
      },
      "source": [
        "Another type of loop is a `while` loop, which will execute until a certain expression is `False` OR until it reaches a `break` clause:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dkxjxODA23mG"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Current value of counter: 1\n",
            "Current value of counter: 2\n",
            "Current value of counter: 3\n",
            "Current value of counter: 4\n",
            "Current value of counter: 5\n",
            "Current value of counter: 6\n",
            "Flipping the flag to True!\n"
          ]
        }
      ],
      "source": [
        "flag = False\n",
        "counter = 0\n",
        "while not flag:\n",
        "  counter += 1\n",
        "  print(f'Current value of counter: {counter}')\n",
        "  if counter \u003e 5:\n",
        "    print('Flipping the flag to True!')\n",
        "    flag = True"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mLz5_dpn3E1_"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Current value of counter: 1\n"
          ]
        }
      ],
      "source": [
        "# The break clause will immediately end the loop as soon as we reach it.\n",
        "flag = False\n",
        "counter = 0\n",
        "while not flag:\n",
        "  counter += 1\n",
        "  print(f'Current value of counter: {counter}')\n",
        "  if counter \u003e 5:\n",
        "    print('Flipping the flag to True!')\n",
        "    flag = True\n",
        "  break"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dvs3fyOIavnz"
      },
      "source": [
        "The `range` function used above facilitates iterating over ranges of values using the following syntax:\n",
        "\n",
        "`range(start (inclusive), end (not inclusive), increment)`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UEV8-IX_5w5w"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n"
          ]
        }
      ],
      "source": [
        "for value in range(5, 10, 1):\n",
        "  print(value)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tuuJB5v857KB"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10\n",
            "12\n",
            "14\n",
            "16\n",
            "18\n"
          ]
        }
      ],
      "source": [
        "for value in range(10, 20, 2):\n",
        "  print(value)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "drld3nfD2VpX"
      },
      "source": [
        "Another common use case for loops is to iterate over elements of containers:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "p_8bYRDA3RtQ"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "100\n",
            "150\n",
            "200\n"
          ]
        }
      ],
      "source": [
        "my_list = [100, 150, 200]\n",
        "\n",
        "for value in my_list:\n",
        "  print(value)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CjjWEVu16G04"
      },
      "source": [
        "We can use `enumerate` to get also the index of the elements:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "W-KfUiQjqqnx"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0 100\n",
            "1 150\n",
            "2 200\n"
          ]
        }
      ],
      "source": [
        "for index, value in enumerate(my_list):\n",
        "  print(index, value)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y0hTrSry6StW"
      },
      "source": [
        "Let's try iterating over keys and values in a dictionary:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CQ_62ZEh3g4K"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1 a\n",
            "2 b\n",
            "3 c\n"
          ]
        }
      ],
      "source": [
        "my_dict = {1: 'a', 2: 'b', 3: 'c'}\n",
        "\n",
        "# If we iterate on a dict, we get its keys.\n",
        "for key in my_dict:\n",
        "  print(key, my_dict[key])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1UcDATA86j4z"
      },
      "source": [
        "A more elegant way to iterate over the `(key, value)` tuples in a dictionary is by using `items()`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_aPWsv_z6jCv"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1 a\n",
            "2 b\n",
            "3 c\n"
          ]
        }
      ],
      "source": [
        "for key, value in my_dict.items():\n",
        "  print(key, value)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z6vPOTOFaitM"
      },
      "source": [
        "## Functions\n",
        "\n",
        "Let's say we want to add two numbers then print the result in a nice message, and let's say we have many different pairs of numbers we want to add.\n",
        "\n",
        "We could accomplish this by copy-pasting our code:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hLMrEHfl4fQD"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The sum of 10 + 12 is 22\n",
            "The sum of 1.3 + -1 is 0.30000000000000004\n",
            "The sum of 10000000.0 + 2e-06 is 10000000.000002\n"
          ]
        }
      ],
      "source": [
        "a = 10\n",
        "b = 12\n",
        "print(f'The sum of {a} + {b} is {a + b}')\n",
        "c = 1.3\n",
        "d = -1\n",
        "print(f'The sum of {c} + {d} is {c + d}')\n",
        "e = 1e7\n",
        "f = 2e-6\n",
        "print(f'The sum of {e} + {f} is {e + f}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rx7vdNJY5GPE"
      },
      "source": [
        "But a more compact, readable, and maintanable solution would be to implement a **function** that does exactly this and expects two numbers as input:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yU2m0sBj5LD2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The sum of 10 + 12 is 22\n",
            "The sum of 1.3 + -1 is 0.30000000000000004\n",
            "The sum of 10000000.0 + 2e-06 is 10000000.000002\n"
          ]
        }
      ],
      "source": [
        "def print_sum(num_1, num_2):\n",
        "  print(f'The sum of {num_1} + {num_2} is {num_1 + num_2}')\n",
        "\n",
        "print_sum(a, b)\n",
        "print_sum(c, d)\n",
        "print_sum(e, f)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jaANQLTn4ctx"
      },
      "source": [
        "## Classes and Objects\n",
        "\n",
        "Python is an **Object Oriented** language. As the [Python docs](https://docs.python.org/3/reference/datamodel.html) state:\n",
        "\n",
        "\u003e Objects are Python’s abstraction for data. All data in a Python program is represented by objects or by relations between objects.\n",
        "\n",
        "Below is how you create a class in Python.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gvARiSXg5fd9"
      },
      "outputs": [],
      "source": [
        "class PrintMessage:\n",
        "  \"\"\"A simple example class.\"\"\"\n",
        "\n",
        "  # Init method initialises attributes.\n",
        "  def __init__(self, message):\n",
        "    self.message = message\n",
        "\n",
        "  def print_message(self):\n",
        "    print(self.message)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uWCyh0JD53bP"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hello World\n"
          ]
        }
      ],
      "source": [
        "obj = PrintMessage('Hello World')     # Instantiate an object.\n",
        "obj.print_message()                   # Execute method."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LUHPVGP67hcC"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\u003cclass '__main__.PrintMessage'\u003e\n",
            "True\n"
          ]
        }
      ],
      "source": [
        "print(type(obj))                      # Check the type of object.\n",
        "print(isinstance(obj, PrintMessage))  # Check if object is instance of PrintMessage."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EkvQLxln7v8F"
      },
      "source": [
        "An important concept in object-oriented programming is that of **inheritance**, which is helpful for code re-use and for organising hierarchical relationships between objects. The main concept is that **child classes** can inherit functionality from **parent classes**:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "n3wuiV0G8dWT"
      },
      "outputs": [],
      "source": [
        "# By adding the `PrintMessage` class between brackets when defining a new\n",
        "# class, the ChildClass will inherit from it.\n",
        "class ChildClass(PrintMessage):\n",
        "\n",
        "  name = 'abc'  # Let's add a new attribute to the class.\n",
        "\n",
        "  # Let's add a new method to the class.\n",
        "  def abs_value(self, a):\n",
        "    super().print_message()  # We can access the parent's methods with super.\n",
        "    return abs(a)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "P2wntNA08-kQ"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\u003cclass '__main__.ChildClass'\u003e\n"
          ]
        }
      ],
      "source": [
        "obj = ChildClass('Hello World')  # Instantiate an object.\n",
        "print(type(obj))  # Check type of object."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mxEAPgL-8dPG"
      },
      "source": [
        "The object is both of type `ChildClass` and `PrintMessage`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "A3SARBMG8cIp"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n",
            "True\n"
          ]
        }
      ],
      "source": [
        "print(isinstance(obj, PrintMessage))  # Check if object is instance of PrintMessage.\n",
        "print(isinstance(obj, ChildClass))  # Check if object is instance of ChildClass."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6FhPwUBG80rc"
      },
      "source": [
        "We can use both the `abs_value` defined in the `ChildClass` class, and the `print_message` method defined in the parent class we inherited from:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Rh2zDNpj8_DC"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hello World\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "execution_count": 62,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "obj.abs_value(-1)  # Method defined in ChildClass."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MElnVygA8j2l"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hello World\n"
          ]
        }
      ],
      "source": [
        "obj.print_message()  # Method defined in the parent class PrintMessage."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PG-UEIP9bcpV"
      },
      "source": [
        "**Important**: Python allows **multiple inheritance**! This is when a class inherits from multiple parent classes:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nHXdMt8z8sKo"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n",
            "True\n"
          ]
        }
      ],
      "source": [
        "# Illustrative example of multiple inheritance.\n",
        "class ParentClass1:\n",
        "  pass\n",
        "\n",
        "class ParentClass2:\n",
        "  pass\n",
        "\n",
        "class ChildClass(ParentClass1, ParentClass2):\n",
        "  pass\n",
        "\n",
        "obj = ChildClass()\n",
        "\n",
        "print(isinstance(obj, ParentClass1))\n",
        "print(isinstance(obj, ParentClass2))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nNlKy-wq8Az5"
      },
      "source": [
        "\n",
        "For more information on classes in Python, check out [this resource](https://docs.python.org/3/tutorial/classes.html)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LYP7crsbclrc"
      },
      "source": [
        "## Suggested Exercises\n",
        "\n",
        "1. What does `11 % 3` mean, and what will it evaluate to?\n",
        "2. What does `True ^ False` mean, and what will it evaluate to?\n",
        "3. What will the following expression evaluate to?: `(1 + 2) * -1 * (3 + 4 * 2)`\n",
        "\n",
        "4. What do you think the following code block will print?\n",
        "```python\n",
        "for value in range(8, 3, -1):\n",
        "     print(value)\n",
        "```\n",
        "5. **Challenge Problem**: due to a food transportation logistics issue, we will lose half of our already ripe fruit. How can we update the following fruit dicts to reflect this scenario?\n",
        "\n",
        "```python\n",
        "fruit_dict_1 = {\n",
        "    'num_fruit': 10,\n",
        "    'origin': 'Brazil',\n",
        "    'ripe': True,\n",
        "}\n",
        "\n",
        "fruit_dict_2 = {\n",
        "    'num_fruit': 7,\n",
        "    'origin': 'California',\n",
        "    'ripe': False,\n",
        "}\n",
        "\n",
        "# Write your code to update `num_fruit` in these dicts based on ripeness.\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A5CrAQLYBnKd"
      },
      "source": [
        "\u003cdetails\u003e   )\n",
        "  \u003csummary\u003eClick here to see the \u003cfont color=\"red\"\u003e\u003cb\u003eExercise Solutions\u003c/b\u003e\u003c/font\u003e (but no peeking before you try!)\u003c/summary\u003e\n",
        "\n",
        "1. This is the modulo operator, which will return the remainder of the division (in this case, 2).\n",
        "2. This is the exclusive or (XOR) operator. The expression will evaluate to `True`, because exactly one of the two elements is `True`.\n",
        "3. -33\n",
        "4. The `-1` means we will go down by 1 at each step, starting from 8 (inclusive) and ending at 4 (exclusive).\n",
        "5. You could do something like the following:\n",
        "``` python\n",
        "# Iterating over a list of dicts.\n",
        "for fruit_dict in [fruit_dict_1, fruit_dict_2]:\n",
        "      if fruit_dict['ripe']:  # Equivalent to if fruit_dict['ripe'] == True.\n",
        "        # Use floor division since partially rotten fruit is maybe also lost.\n",
        "        fruit_dict['num_fruit'] = fruit_dict['num_fruit'] // 2\n",
        "```\n",
        "\u003c/details\u003e\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aIPclS7GaleK"
      },
      "source": [
        "##  Useful things to know!\n",
        "\n",
        "Now that we're comfortable with the basics of Python, we can introduce some additional useful tools that you will see repeatedly in machine learning code, starting with indexing and slicing:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wPWlFFtu_fWa"
      },
      "source": [
        "### Indexing \u0026 Slicing\n",
        "\n",
        "\n",
        "Indexing and slicing are extremely useful ways of extracting elements from index-based collections.\n",
        "\n",
        "Indexing accesses elements, whereas slicing extracts a sequence of elements. Consider the following list of lists (which is a matrix of integers, containing 3 rows and 4 columns):\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "15NsfxTxE6lI"
      },
      "outputs": [],
      "source": [
        "a = [\n",
        "     [1, 2, 3, 4],\n",
        "     [5, 6, 7, 8],\n",
        "     [9, 10, 11, 12],\n",
        "     ]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HYrsPQ0vE8wK"
      },
      "source": [
        "We can access various elements and slices of this matrix as follows:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ohb4LO1JE56H"
      },
      "source": [
        "\n",
        "\n",
        "![picture](https://storage.googleapis.com/dm-educational/assets/intro-to-python-and-numpy/indexing_2d.svg)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wc6QprU-CoyS"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "6\n",
            "[7, 8, 9]\n",
            "[5, 6]\n"
          ]
        }
      ],
      "source": [
        "print(matrix[1][2])  # Access element in row index 1 and column index 2.\n",
        "print(matrix[:][2])  # Access elements in any row but column index 2.\n",
        "print(matrix[1][1:3])  # Access elements in row index 1, and column indices 1 and 2."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1xGTijYXCkI4"
      },
      "source": [
        "#### Indexing Tips\n",
        "\n",
        "**Note that indexing in Python is zero-based**: [0 denotes the first element](https://en.wikipedia.org/wiki/Zero-based_numbering). This is a bit of a gotcha that catches people off guard. This zero-based indexing is in contrast to some other programming languages like R, in which index numbering starts at 1. People like to have very spirited arguments about which approach is correct/better! ;)\n",
        "\n",
        "Also note that indexing is always integer-based (since passing in floats wouldn't make much sense - what's the 3.7th element in a list?). You can index into various Python containers in a similar manner:\n",
        "\n",
        "* `matrix[i][j]`\n",
        "* `list[i]`\n",
        "* `tuple[i]`\n",
        "* `str[i]`\n",
        "\n",
        "#### Slicing Tips\n",
        "\n",
        "Slicing syntax can be a bit tricky if you are not used to it – slicing in Python is achieved with the `start:stop:step` notation, which denotes:\n",
        "- Where a slice should start (inclusive) by the `start` position\n",
        "- Where the slice should stop by the `stop` position (**not inclusive!** i.e. exclusive)\n",
        "- And what the step size should be along the way by `step` (which is by default 1 if it is not specified)\n",
        "\n",
        "For example:\n",
        "- `:` means the full slice\n",
        "- `1:` means slice from the 2nd element onwards (remember zero-based indexing/slicing!)\n",
        "- `:-1` means slice until the last element (not inclusive; so effectively, this drops the final element).\n",
        "- `1:3` means slice including the second and third elements (the fourth element at index 3 is NOT included).\n",
        "- `::2` means to slice all positions, but take every other element (every 2nd element).\n",
        "\n",
        "\n",
        "One thing to note here: we can do the same with for/while loops and ifs, however it is MUCH more efficient to do this via the built-in mechanisms.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ve3S2HBYJX9c"
      },
      "source": [
        "Let's play around with some examples of indexing and slicing using our matrix `a`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hNLJmAzXJctE"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[5, 6, 7, 8]\n",
            "[5, 6, 7, 8]\n"
          ]
        }
      ],
      "source": [
        "a = [\n",
        "     [1, 2, 3, 4],\n",
        "     [5, 6, 7, 8],\n",
        "     [9, 10, 11, 12],\n",
        "     ]\n",
        "\n",
        "print(a[1])     # 2nd row.\n",
        "print(a[1][:])  # The same as above (colon = full slice)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U3JBzA0tJ7lC"
      },
      "source": [
        "Let's get slightly trickier:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0uHSv9a4GDG8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[6, 7, 8]\n",
            "[5, 6, 7]\n"
          ]
        }
      ],
      "source": [
        "print(a[1][1:])   # Get elements in 2nd row, from the 2nd column until the end.\n",
        "print(a[1][:-1])  # Get elements in 2nd row, until the last column (not inclusive)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qpHT33GcUkPb"
      },
      "source": [
        "We can use indexing and slicing for modification too:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iDb0-D-fGM8f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Before the modification: [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]] \n",
            "\n",
            "After the modification: [[100, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]\n"
          ]
        }
      ],
      "source": [
        "a = [[1, 2, 3, 4],\n",
        "     [5, 6, 7, 8],\n",
        "     [9, 10, 11, 12]]\n",
        "print('Before the modification:', a, '\\n')\n",
        "\n",
        "# Modify the first element.\n",
        "a[0][0] = 100\n",
        "print('After the modification:', a)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YNrq2jM2Hjlp"
      },
      "source": [
        "Be careful with assignment while slicing, since a slice (e.g. `a[:]`) creates a **copy of the referred inner object**! This means that you might think you're updating the values in a slice, but actually nothing changes.\n",
        "\n",
        "Some examples to illustrate:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "H98e5gB3GVHn"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Before modification: [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]] \n",
            "\n",
            "After attempted modification: [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]] \n",
            "\n",
            "After successful modification: [[1, 2, 500, 4], [5, 6, 7, 8], [9, 10, 11, 12]] \n",
            "\n",
            "After another modification: [[1, 2, 500, 4], [1, 2], [9, 10, 11, 12]] \n",
            "\n"
          ]
        }
      ],
      "source": [
        "a = [[1, 2, 3, 4],\n",
        "     [5, 6, 7, 8],\n",
        "     [9, 10, 11, 12]]\n",
        "print('Before modification:', a, '\\n')\n",
        "\n",
        "# Try to replace some values with 500.\n",
        "a[1:3][1] = 500  # a[:] returns a copy so `a` is not modified!\n",
        "print('After attempted modification:', a, '\\n')\n",
        "\n",
        "a[0][2] = 500  # But a[index][:] will work. Think about why...\n",
        "print('After successful modification:', a, '\\n')\n",
        "\n",
        "# We can also substitute the entire list.\n",
        "a[1][:] = [1, 2]  # This is the same as `a[1] = [1, 2]`.\n",
        "print('After another modification:', a, '\\n')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7sM89ctRcKqz"
      },
      "source": [
        "### List comprehensions\n",
        "\n",
        "**List comprehensions** are a very common construct in Python. They are very helpful for writing more concise code when manipulating lists and other container objects, and are particularly useful when we either want to slightly modify a container or filter elements based on a condition.\n",
        "\n",
        "From the [Python documentation](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions):\n",
        "\u003e \"List comprehension consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses. The result will be a new list resulting from evaluating the expression in the context of the for and if clauses which follow it.\"\n",
        "\n",
        "For example, let's say we have a list of ints `list_a` and we would like a new list `list_a_plus_10` with each value in `list_a` increased by 10. How would you do this?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0-MFhGFLdCSR"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[10, 4, 3, 2, 5, 9, 0]\n",
            "[20, 14, 13, 12, 15, 19, 10]\n"
          ]
        }
      ],
      "source": [
        "list_a = [10, 4, 3, 2, 5, 9, 0]\n",
        "\n",
        "# Boring solution...\n",
        "list_a_plus_10 = []\n",
        "for value in list_a:\n",
        "  list_a_plus_10.append(value + 10)\n",
        "\n",
        "print(list_a)\n",
        "print(list_a_plus_10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zunOX1w5UvHp"
      },
      "source": [
        "This works, but let's use a list comprehension instead:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RJK2kClpdOr9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[10, 4, 3, 2, 5, 9, 0]\n",
            "[20, 14, 13, 12, 15, 19, 10]\n"
          ]
        }
      ],
      "source": [
        "# Cool solution using a list comprehension.\n",
        "list_a_plus_10 = [value + 10 for value in list_a]\n",
        "print(list_a)\n",
        "print(list_a_plus_10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xN7qfZ6Odfmc"
      },
      "source": [
        "Now let's say we want a new list `odds_a_plus_10` with each value in `list_a` added by 10 but only if the number is odd, otherwise we should not include it in the list. How would you do this?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Bx5XNG13d3RV"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[10, 4, 3, 2, 5, 9, 0]\n",
            "[13, 15, 19]\n"
          ]
        }
      ],
      "source": [
        "list_a = [10, 4, 3, 2, 5, 9, 0]\n",
        "\n",
        "# Boring solution...\n",
        "odds_a_plus_10 = []\n",
        "for value in list_a:\n",
        "  if value % 2 == 1:\n",
        "    odds_a_plus_10.append(value + 10)\n",
        "\n",
        "print(list_a)\n",
        "print(odds_a_plus_10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9COaDGvdeBUY"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[10, 4, 3, 2, 5, 9, 0]\n",
            "[13, 15, 19]\n"
          ]
        }
      ],
      "source": [
        "# Cool solution using a list comprehension.\n",
        "odds_a_plus_10 = [value + 10 for value in list_a if value % 2 == 1]\n",
        "print(list_a)\n",
        "print(odds_a_plus_10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "htXUG7L7VFyF"
      },
      "source": [
        "That's significantly more concise and readable! :) List comprehensions are also often faster than `for` loops."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w0kQQnN_eink"
      },
      "source": [
        "### Iterators\n",
        "\n",
        "Iterators in Python are objects used to iterate on containers.\n",
        "\n",
        "Iterators have the following methods:\n",
        "\n",
        "* `__iter__`: used for initialisation.\n",
        "\n",
        "* `__next__`: gets the next element for iteration. Raises a `StopIteration` error when there are no more elements left to grab.\n",
        "\n",
        "\n",
        "Iterators are very useful in machine learning since we usually have a dataset we want to iterate on. So, we can create an iterator and explicitly ask for more examples:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xL3WJouVe3m5"
      },
      "outputs": [],
      "source": [
        "class MyDatasetIterator:\n",
        "\n",
        "  def __init__(self, dataset):\n",
        "    self.dataset = dataset\n",
        "    self.counter = 0\n",
        "    self.limit = len(self.dataset)\n",
        "\n",
        "  def __iter__(self):\n",
        "    return self\n",
        "\n",
        "  def __next__(self):\n",
        "    if self.counter \u003e= self.limit:\n",
        "      raise StopIteration\n",
        "\n",
        "    curr_value = self.dataset[self.counter]\n",
        "    self.counter += 1\n",
        "    return curr_value"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "t6hyubTSfz5e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n",
            "3\n",
            "10\n",
            "4\n"
          ]
        }
      ],
      "source": [
        "it = MyDatasetIterator([1, 3, 10, 4])\n",
        "\n",
        "while True:\n",
        "  # We can ask for an element using next.\n",
        "  try:\n",
        "    print(next(it))\n",
        "  except StopIteration:\n",
        "    break"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-YqgdBlzq2KP"
      },
      "source": [
        "We can also iterate on iterators using a `for` loop instead of `next`. Not surprising, right?\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nh3dgVfOi48M"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n",
            "3\n",
            "10\n",
            "4\n"
          ]
        }
      ],
      "source": [
        "it = MyDatasetIterator([1, 3, 10, 4])\n",
        "\n",
        "for value in it:\n",
        "  print(value)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SnwBp55NrE26"
      },
      "source": [
        "What would happen if we now try to iterate on `it` again, after we exhausted all the values?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bvpgA_iKq90c"
      },
      "outputs": [],
      "source": [
        "for value in it:\n",
        "  print(value)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GNbtDQFgrZaV"
      },
      "source": [
        "Nothing! Think about why. Hint: try running `list(it)`.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QbxWRyxUjtRQ"
      },
      "source": [
        "### Regex\n",
        "\n",
        "Regular expressions (regex) are expressions that allow you to match or replace parts of strings in a flexible way. The Python module that provides regular expression operations is called `re`. For more information, check out [these docs](https://docs.python.org/3.4/library/re.html).\n",
        "\n",
        "Here, we'll just run through a few quick use cases that are commonly encountered:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0QI83HpI9Xfv"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "None\n",
            "None\n",
            "None\n",
            "\u003cre.Match object; span=(0, 3), match='abc'\u003e\n"
          ]
        }
      ],
      "source": [
        "import re\n",
        "\n",
        "# Compile a pattern.\n",
        "# [a-z]+ means to match any lowercase letter occurring one or more times.\n",
        "pattern = re.compile(\"[a-z]+\")\n",
        "\n",
        "# Check what strings match a pattern.\n",
        "print(pattern.match(\"\"))     # If the string is not a match, it returns None.\n",
        "print(pattern.match(\"123\"))  # If the string is not a match, it returns None.\n",
        "print(pattern.match(\"ABC\"))  # If the string is not a match, it returns None.\n",
        "print(pattern.match(\"abc\"))  # If there's a match, it returns a Match object."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JlFFICqOt8u5"
      },
      "source": [
        "`search` returns a corresponding `Match` object instance:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wjN0IW6utt6M"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\u003cre.Match object; span=(4, 7), match='abc'\u003e\n"
          ]
        }
      ],
      "source": [
        "print(pattern.search(\"123 abc def 45 123\"))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DO_qdeW2uGRM"
      },
      "source": [
        "`findall` returns all strings that match the pattern:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IrUsnDE3uEzK"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['abc', 'def']\n"
          ]
        }
      ],
      "source": [
        "print(pattern.findall(\"123 abc def 45 123\"))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qR_CsEP_uKuR"
      },
      "source": [
        "`finditer` returns an iterator of `Match` objects:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HVXhFjjkuNEO"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\u003cre.Match object; span=(4, 7), match='abc'\u003e\n",
            "\u003cre.Match object; span=(8, 11), match='def'\u003e\n"
          ]
        }
      ],
      "source": [
        "it = pattern.finditer(\"123 abc def 45 123\")\n",
        "for match in it:\n",
        "  print(match)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w_wc_jSgts6V"
      },
      "source": [
        "### Functools\n",
        "\n",
        "Functools is a library that facilitates creating new functions based on existing ones.\n",
        "\n",
        "From the [documentation](\n",
        "https://docs.python.org/3.7/library/functools.html):\n",
        "\n",
        "\u003e \"The functools module is for higher-order functions: functions that act on or return other functions. In general, any callable object can be treated as a function for the purposes of this module.\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wBxGxajItt_O"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2 ** 3 = 8\n"
          ]
        }
      ],
      "source": [
        "import functools\n",
        "\n",
        "# Let's define a function. Nothing new here.\n",
        "def print_power(base, exponent):\n",
        "  print(f'{base} ** {exponent} = {base ** exponent}')\n",
        "print_power(base=2, exponent=3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kJ7KPjtZvqWa"
      },
      "source": [
        "Using `functools.partial`, we can create a new function with default arguments, whose output is a new function with a simplified signature:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KH8p-tA7vmEW"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\u003cclass 'functools.partial'\u003e\n",
            "Is this new function callable? True\n",
            "1 ** 3 = 1\n",
            "2 ** 3 = 8\n",
            "3 ** 3 = 27\n"
          ]
        }
      ],
      "source": [
        "print_power_exponent_3 = functools.partial(print_power, exponent=3)\n",
        "# Returns a function.\n",
        "print(type(print_power_exponent_3))\n",
        "print(\"Is this new function callable?\", callable(print_power_exponent_3))\n",
        "print_power_exponent_3(base=1)\n",
        "print_power_exponent_3(base=2)\n",
        "print_power_exponent_3(base=3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dt40w7NUwGsi"
      },
      "source": [
        "We could set the `base` argument to a fixed value instead:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "evUAZwK4v2dg"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2 ** 4 = 16\n",
            "2 ** 5 = 32\n",
            "2 ** 6 = 64\n"
          ]
        }
      ],
      "source": [
        "print_power_base_2 = functools.partial(print_power, base=2)\n",
        "print_power_base_2(exponent=4)\n",
        "print_power_base_2(exponent=5)\n",
        "print_power_base_2(exponent=6)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_VVc0NT2weTO"
      },
      "source": [
        "We could even pre-specify the values for all arguments in a function:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mJlQYFkxwIaM"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2 ** 10 = 1024\n"
          ]
        }
      ],
      "source": [
        "# By default: base = 2, exponent = 10.\n",
        "print_fixed_power = functools.partial(print_power, base=2, exponent=10)\n",
        "print_fixed_power()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vOTR2kVfwuDk"
      },
      "source": [
        "Though note that we can still pass different values for the arguments if we'd like:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KqMFhUUnwjmY"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "5 ** 4 = 625\n"
          ]
        }
      ],
      "source": [
        "print_fixed_power(exponent=4, base=5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DJxnMeo8b0il"
      },
      "source": [
        "## Type annotation\n",
        "\n",
        "Python is **dynamically-typed**, so we do not need to prespecify the types of variables or what type of return we should expect from a function. However, Python does offer the ability to optionally supply this information (this is called \"**type hinting**\", \"type annotation\", or simply \"typing\"). Type annotation can be helpful for:\n",
        "\n",
        "*  **Documenting your code** and making it easier for others to read and work with. With type annotations, it's immediately clear to everyone what a function's inputs and outputs are.\n",
        "* **Helping you write better code** by forcing you to think about the types involved.\n",
        "* **Catching certain errors**, especially if you're using a linter or building your code.\n",
        "\n",
        "Let's first write a simple function:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5r_gMPmUzPE-"
      },
      "outputs": [],
      "source": [
        "def repeat_string(string, num_repeats):\n",
        "  return string * num_repeats"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Vp4Cwm-wzuiT"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'hellohellohello'"
            ]
          },
          "execution_count": 89,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "repeat_string('hello', 3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "puDF-K4hzWJ_"
      },
      "source": [
        "And let's add type annotation, to specify the types of each input argument, and the type of the function output:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fB28lGyjzT-i"
      },
      "outputs": [],
      "source": [
        "def repeat_string(string: str, num_repeats: int) -\u003e str:\n",
        "  return string * num_repeats"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "__dyvPPbzb5B"
      },
      "source": [
        "Finally, we can add a **docstring** to complete our function documentation:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1xD9sBbl1C8p"
      },
      "outputs": [],
      "source": [
        "def repeat_string(string: str, num_repeats: int) -\u003e str:\n",
        "  \"\"\"Repeats a string a certain number of times.\n",
        "\n",
        "  Args:\n",
        "    string: string to be repeated.\n",
        "    num_repeats: number of repeats of the string.\n",
        "\n",
        "  Returns:\n",
        "    A repeated string.\n",
        "  \"\"\"\n",
        "  return string * num_repeats"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tiTbuGZ91GE5"
      },
      "source": [
        "Although in this case the function was quite simple and perhaps didn't need this extra documentation, in real code cases it's almost always worth the extra bit of time to type annotate and document your code in this way. Your collaborators will thank you! :)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MQ2X-IymbGVd"
      },
      "source": [
        "## Using dataclasses\n",
        "\n",
        "You are likely to encounter dataclasses when reading machine learning code – as the name might suggest, these are classes which store data, and are helpful for logically grouping multiple variables.\n",
        "\n",
        "In Python, we can use `@dataclasses.dataclass` to create a simple dataclass. If you're familiar with C++, this is similar to structs.\n",
        "\n",
        "For example, we might want to write a `Metrics` dataclass to group together some model performance metrics:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "c0thZdYpbdeZ"
      },
      "outputs": [],
      "source": [
        "import dataclasses\n",
        "\n",
        "@dataclasses.dataclass\n",
        "class Metrics:\n",
        "  loss: float  # No default value means that loss must always be specified.\n",
        "  accuracy: float = 0.0\n",
        "  recall: float = 0.0\n",
        "  precision: float = 0.0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vLWCi-XO2Hs3"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Metrics(loss=1.2, accuracy=0.0, recall=0.1, precision=0.0)"
            ]
          },
          "execution_count": 93,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "metrics = Metrics(loss=1.2, recall=0.1)\n",
        "metrics"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VWSPsKxg2L_h"
      },
      "source": [
        "We expect an error if we don't pass in a `loss` value:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fb5i4Qj32JCu"
      },
      "outputs": [
        {
          "ename": "TypeError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m\u003cipython-input-94-548328cd20ca\u003e\u001b[0m in \u001b[0;36m\u003cmodule\u003e\u001b[0;34m()\u001b[0m\n\u001b[0;32m----\u003e 1\u001b[0;31m \u001b[0mmetrics\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMetrics\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maccuracy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mmetrics\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: __init__() missing 1 required positional argument: 'loss'"
          ]
        }
      ],
      "source": [
        "metrics = Metrics(accuracy=0.3)\n",
        "metrics"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OxhUWZZ1kKiL"
      },
      "source": [
        "### Debugging in Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yf_c3Aj6kMZQ"
      },
      "source": [
        "#### Help\n",
        "\n",
        "For checking the documentation of any Python object, you can use the `help` function. For example, to access some more information in integers, you can do:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yBHcvyUAq6K1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Help on class int in module builtins:\n",
            "\n",
            "class int(object)\n",
            " |  int([x]) -\u003e integer\n",
            " |  int(x, base=10) -\u003e integer\n",
            " |  \n",
            " |  Convert a number or string to an integer, or return 0 if no arguments\n",
            " |  are given.  If x is a number, return x.__int__().  For floating point\n",
            " |  numbers, this truncates towards zero.\n",
            " |  \n",
            " |  If x is not a number or if base is given, then x must be a string,\n",
            " |  bytes, or bytearray instance representing an integer literal in the\n",
            " |  given base.  The literal can be preceded by '+' or '-' and be surrounded\n",
            " |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.\n",
            " |  Base 0 means to interpret the base from the string as an integer literal.\n",
            " |  \u003e\u003e\u003e int('0b100', base=0)\n",
            " |  4\n",
            " |  \n",
            " |  Methods defined here:\n",
            " |  \n",
            " |  __abs__(self, /)\n",
            " |      abs(self)\n",
            " |  \n",
            " |  __add__(self, value, /)\n",
            " |      Return self+value.\n",
            " |  \n",
            " |  __and__(self, value, /)\n",
            " |      Return self\u0026value.\n",
            " |  \n",
            " |  __bool__(self, /)\n",
            " |      self != 0\n",
            " |  \n",
            " |  __ceil__(...)\n",
            " |      Ceiling of an Integral returns itself.\n",
            " |  \n",
            " |  __divmod__(self, value, /)\n",
            " |      Return divmod(self, value).\n",
            " |  \n",
            " |  __eq__(self, value, /)\n",
            " |      Return self==value.\n",
            " |  \n",
            " |  __float__(self, /)\n",
            " |      float(self)\n",
            " |  \n",
            " |  __floor__(...)\n",
            " |      Flooring an Integral returns itself.\n",
            " |  \n",
            " |  __floordiv__(self, value, /)\n",
            " |      Return self//value.\n",
            " |  \n",
            " |  __format__(self, format_spec, /)\n",
            " |      Default object formatter.\n",
            " |  \n",
            " |  __ge__(self, value, /)\n",
            " |      Return self\u003e=value.\n",
            " |  \n",
            " |  __getattribute__(self, name, /)\n",
            " |      Return getattr(self, name).\n",
            " |  \n",
            " |  __getnewargs__(self, /)\n",
            " |  \n",
            " |  __gt__(self, value, /)\n",
            " |      Return self\u003evalue.\n",
            " |  \n",
            " |  __hash__(self, /)\n",
            " |      Return hash(self).\n",
            " |  \n",
            " |  __index__(self, /)\n",
            " |      Return self converted to an integer, if self is suitable for use as an index into a list.\n",
            " |  \n",
            " |  __int__(self, /)\n",
            " |      int(self)\n",
            " |  \n",
            " |  __invert__(self, /)\n",
            " |      ~self\n",
            " |  \n",
            " |  __le__(self, value, /)\n",
            " |      Return self\u003c=value.\n",
            " |  \n",
            " |  __lshift__(self, value, /)\n",
            " |      Return self\u003c\u003cvalue.\n",
            " |  \n",
            " |  __lt__(self, value, /)\n",
            " |      Return self\u003cvalue.\n",
            " |  \n",
            " |  __mod__(self, value, /)\n",
            " |      Return self%value.\n",
            " |  \n",
            " |  __mul__(self, value, /)\n",
            " |      Return self*value.\n",
            " |  \n",
            " |  __ne__(self, value, /)\n",
            " |      Return self!=value.\n",
            " |  \n",
            " |  __neg__(self, /)\n",
            " |      -self\n",
            " |  \n",
            " |  __or__(self, value, /)\n",
            " |      Return self|value.\n",
            " |  \n",
            " |  __pos__(self, /)\n",
            " |      +self\n",
            " |  \n",
            " |  __pow__(self, value, mod=None, /)\n",
            " |      Return pow(self, value, mod).\n",
            " |  \n",
            " |  __radd__(self, value, /)\n",
            " |      Return value+self.\n",
            " |  \n",
            " |  __rand__(self, value, /)\n",
            " |      Return value\u0026self.\n",
            " |  \n",
            " |  __rdivmod__(self, value, /)\n",
            " |      Return divmod(value, self).\n",
            " |  \n",
            " |  __repr__(self, /)\n",
            " |      Return repr(self).\n",
            " |  \n",
            " |  __rfloordiv__(self, value, /)\n",
            " |      Return value//self.\n",
            " |  \n",
            " |  __rlshift__(self, value, /)\n",
            " |      Return value\u003c\u003cself.\n",
            " |  \n",
            " |  __rmod__(self, value, /)\n",
            " |      Return value%self.\n",
            " |  \n",
            " |  __rmul__(self, value, /)\n",
            " |      Return value*self.\n",
            " |  \n",
            " |  __ror__(self, value, /)\n",
            " |      Return value|self.\n",
            " |  \n",
            " |  __round__(...)\n",
            " |      Rounding an Integral returns itself.\n",
            " |      Rounding with an ndigits argument also returns an integer.\n",
            " |  \n",
            " |  __rpow__(self, value, mod=None, /)\n",
            " |      Return pow(value, self, mod).\n",
            " |  \n",
            " |  __rrshift__(self, value, /)\n",
            " |      Return value\u003e\u003eself.\n",
            " |  \n",
            " |  __rshift__(self, value, /)\n",
            " |      Return self\u003e\u003evalue.\n",
            " |  \n",
            " |  __rsub__(self, value, /)\n",
            " |      Return value-self.\n",
            " |  \n",
            " |  __rtruediv__(self, value, /)\n",
            " |      Return value/self.\n",
            " |  \n",
            " |  __rxor__(self, value, /)\n",
            " |      Return value^self.\n",
            " |  \n",
            " |  __sizeof__(self, /)\n",
            " |      Returns size in memory, in bytes.\n",
            " |  \n",
            " |  __str__(self, /)\n",
            " |      Return str(self).\n",
            " |  \n",
            " |  __sub__(self, value, /)\n",
            " |      Return self-value.\n",
            " |  \n",
            " |  __truediv__(self, value, /)\n",
            " |      Return self/value.\n",
            " |  \n",
            " |  __trunc__(...)\n",
            " |      Truncating an Integral returns itself.\n",
            " |  \n",
            " |  __xor__(self, value, /)\n",
            " |      Return self^value.\n",
            " |  \n",
            " |  bit_length(self, /)\n",
            " |      Number of bits necessary to represent self in binary.\n",
            " |      \n",
            " |      \u003e\u003e\u003e bin(37)\n",
            " |      '0b100101'\n",
            " |      \u003e\u003e\u003e (37).bit_length()\n",
            " |      6\n",
            " |  \n",
            " |  conjugate(...)\n",
            " |      Returns self, the complex conjugate of any int.\n",
            " |  \n",
            " |  to_bytes(self, /, length, byteorder, *, signed=False)\n",
            " |      Return an array of bytes representing an integer.\n",
            " |      \n",
            " |      length\n",
            " |        Length of bytes object to use.  An OverflowError is raised if the\n",
            " |        integer is not representable with the given number of bytes.\n",
            " |      byteorder\n",
            " |        The byte order used to represent the integer.  If byteorder is 'big',\n",
            " |        the most significant byte is at the beginning of the byte array.  If\n",
            " |        byteorder is 'little', the most significant byte is at the end of the\n",
            " |        byte array.  To request the native byte order of the host system, use\n",
            " |        `sys.byteorder' as the byte order value.\n",
            " |      signed\n",
            " |        Determines whether two's complement is used to represent the integer.\n",
            " |        If signed is False and a negative integer is given, an OverflowError\n",
            " |        is raised.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Class methods defined here:\n",
            " |  \n",
            " |  from_bytes(bytes, byteorder, *, signed=False) from builtins.type\n",
            " |      Return the integer represented by the given array of bytes.\n",
            " |      \n",
            " |      bytes\n",
            " |        Holds the array of bytes to convert.  The argument must either\n",
            " |        support the buffer protocol or be an iterable object producing bytes.\n",
            " |        Bytes and bytearray are examples of built-in objects that support the\n",
            " |        buffer protocol.\n",
            " |      byteorder\n",
            " |        The byte order used to represent the integer.  If byteorder is 'big',\n",
            " |        the most significant byte is at the beginning of the byte array.  If\n",
            " |        byteorder is 'little', the most significant byte is at the end of the\n",
            " |        byte array.  To request the native byte order of the host system, use\n",
            " |        `sys.byteorder' as the byte order value.\n",
            " |      signed\n",
            " |        Indicates whether two's complement is used to represent the integer.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Static methods defined here:\n",
            " |  \n",
            " |  __new__(*args, **kwargs) from builtins.type\n",
            " |      Create and return a new object.  See help(type) for accurate signature.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Data descriptors defined here:\n",
            " |  \n",
            " |  denominator\n",
            " |      the denominator of a rational number in lowest terms\n",
            " |  \n",
            " |  imag\n",
            " |      the imaginary part of a complex number\n",
            " |  \n",
            " |  numerator\n",
            " |      the numerator of a rational number in lowest terms\n",
            " |  \n",
            " |  real\n",
            " |      the real part of a complex number\n",
            "\n"
          ]
        }
      ],
      "source": [
        "help(int)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bmAMrNgdCwIo"
      },
      "source": [
        "You can even get help on `help`!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zTnIQZcdqxo3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Help on _Helper in module _sitebuiltins object:\n",
            "\n",
            "class _Helper(builtins.object)\n",
            " |  Define the builtin 'help'.\n",
            " |  \n",
            " |  This is a wrapper around pydoc.help that provides a helpful message\n",
            " |  when 'help' is typed at the Python interactive prompt.\n",
            " |  \n",
            " |  Calling help() at the Python prompt starts an interactive help session.\n",
            " |  Calling help(thing) prints help for the python object 'thing'.\n",
            " |  \n",
            " |  Methods defined here:\n",
            " |  \n",
            " |  __call__(self, *args, **kwds)\n",
            " |      Call self as a function.\n",
            " |  \n",
            " |  __repr__(self)\n",
            " |      Return repr(self).\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Data descriptors defined here:\n",
            " |  \n",
            " |  __dict__\n",
            " |      dictionary for instance variables (if defined)\n",
            " |  \n",
            " |  __weakref__\n",
            " |      list of weak references to the object (if defined)\n",
            "\n"
          ]
        }
      ],
      "source": [
        "help(help)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I8WPVnN_kP76"
      },
      "source": [
        "#### pdb\n",
        "\n",
        "Pdb is Python’s interactive code debugger ([more information here](https://docs.python.org/3.7/library/pdb)). It is not unusual to write code that is not working as intended or is breaking for unknown reasons.\n",
        "\n",
        "For situations like this, we can use `pdb` to stop execution at a specific point (the \"breakpoint\") and interact with the code aat that exact state of the code (with the specific variable values and function outputs that are present at the breakpoint).\n",
        "\n",
        "One of the common functionalities used with pdb is `pdb.set_trace()`:\n",
        "\n",
        "```import pdb; pdb.set_trace()```\n",
        "\n",
        "We usually `import pdb` and call `pdb.set_trace()` on the same line so that we don't forget to remove the import and trace after we solve the issue with our code.\n",
        "\n",
        "Below is an example of what we can do with `pdb`:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qO2laNdUrA6i"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\n",
            "PYDEV DEBUGGER WARNING:\n",
            "sys.settrace() should not be used when the debugger is being used.\n",
            "This may cause the debugger to stop working correctly.\n",
            "If this is needed, please check: \n",
            "http://pydev.blogspot.com/2007/06/why-cant-pydev-debugger-work-with.html\n",
            "to see how to restore the debug tracing back correctly.\n",
            "Call Location:\n",
            "  File \"/usr/lib/python3.7/bdb.py\", line 332, in set_trace\n",
            "    sys.settrace(self.trace_dispatch)\n",
            "\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\u003e \u003cipython-input-97-e12fd12d27b2\u003e(11)\u003cmodule\u003e()\n",
            "-\u003e output = multiply_values(x, y) + z\n",
            "(Pdb) q\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "\n",
            "PYDEV DEBUGGER WARNING:\n",
            "sys.settrace() should not be used when the debugger is being used.\n",
            "This may cause the debugger to stop working correctly.\n",
            "If this is needed, please check: \n",
            "http://pydev.blogspot.com/2007/06/why-cant-pydev-debugger-work-with.html\n",
            "to see how to restore the debug tracing back correctly.\n",
            "Call Location:\n",
            "  File \"/usr/lib/python3.7/bdb.py\", line 357, in set_quit\n",
            "    sys.settrace(None)\n",
            "\n"
          ]
        },
        {
          "ename": "BdbQuit",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mBdbQuit\u001b[0m                                   Traceback (most recent call last)",
            "\u001b[0;32m\u003cipython-input-97-e12fd12d27b2\u003e\u001b[0m in \u001b[0;36m\u003cmodule\u003e\u001b[0;34m()\u001b[0m\n\u001b[1;32m      9\u001b[0m   \u001b[0mx\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m   \u001b[0;32mimport\u001b[0m \u001b[0mpdb\u001b[0m\u001b[0;34m;\u001b[0m \u001b[0mpdb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---\u003e 11\u001b[0;31m   \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmultiply_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m\u003cipython-input-97-e12fd12d27b2\u003e\u001b[0m in \u001b[0;36m\u003cmodule\u003e\u001b[0;34m()\u001b[0m\n\u001b[1;32m      9\u001b[0m   \u001b[0mx\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m   \u001b[0;32mimport\u001b[0m \u001b[0mpdb\u001b[0m\u001b[0;34m;\u001b[0m \u001b[0mpdb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---\u003e 11\u001b[0;31m   \u001b[0moutput\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmultiply_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/lib/python3.7/bdb.py\u001b[0m in \u001b[0;36mtrace_dispatch\u001b[0;34m(self, frame, event, arg)\u001b[0m\n\u001b[1;32m     86\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0;31m# None\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     87\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mevent\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'line'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---\u003e 88\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdispatch_line\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     89\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mevent\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'call'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     90\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdispatch_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.7/bdb.py\u001b[0m in \u001b[0;36mdispatch_line\u001b[0;34m(self, frame)\u001b[0m\n\u001b[1;32m    111\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstop_here\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbreak_here\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    112\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muser_line\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mframe\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--\u003e 113\u001b[0;31m             \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mquitting\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mBdbQuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    114\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrace_dispatch\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    115\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mBdbQuit\u001b[0m: "
          ]
        }
      ],
      "source": [
        "x = 1\n",
        "y = 2\n",
        "z = 3\n",
        "\n",
        "def multiply_values(x, y):\n",
        "  return x*y\n",
        "\n",
        "for i in range(10):\n",
        "  x += 2\n",
        "  import pdb; pdb.set_trace()\n",
        "  output = multiply_values(x, y) + z"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HId1TZ1rIiLO"
      },
      "source": [
        "### Libraries for visualisation\n",
        "\n",
        "In deep learning, we interact with a lot of data – for example, the input data, model training curve data, and model predictions.\n",
        "\n",
        "It is often valuable to be able to quickly visualise this data in order to understand what is going on in it.\n",
        "\n",
        "The most popular library for visualisation in Python is `matplotlib`, which we introduce here.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-wpCxhF3Imud"
      },
      "source": [
        "#### Matplotlib\n",
        "\n",
        "Matplotlib is an extremely useful visualisation library for various tasks such as visualising data, checking data patterns, making animations, and visualising images.\n",
        "\n",
        "From the [matplotlib website](https://matplotlib.org/):\n",
        "\n",
        "\u003e Matplotlib is a comprehensive library for creating static, animated, and interactive visualisations in Python.\n",
        "\n",
        "\n",
        "Below are some examples of plots we can make with Matplotlib:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "c0f8j3KJJRhI"
      },
      "outputs": [],
      "source": [
        "# This is a common way to import matplotlib.\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BqeTzMcMJFY3"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "\u003cFigure size 432x288 with 1 Axes\u003e"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Plot a list of numbers as a line.\n",
        "numbers = range(20, 30)\n",
        "plt.plot(numbers)  # What's used as the x axis if only y axis values are given?\n",
        "plt.show()  # Show plot."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fmE8LhU_J0Qi"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "\u003cFigure size 432x288 with 1 Axes\u003e"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Second parameter controls style. 'r' changes the line colour to red,\n",
        "# and '--' is the style of the line.\n",
        "plt.plot(numbers, 'r--')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YdWtFUc9JeLS"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "\u003cFigure size 432x288 with 1 Axes\u003e"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Plot a list of numbers as a scatter plot.\n",
        "x = range(10)\n",
        "y = [v ** 2 for v in x]\n",
        "plt.scatter(x, y)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PpeaPkqWJ9yb"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "\u003cFigure size 864x288 with 3 Axes\u003e"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Present plots side by side\n",
        "fig, axes = plt.subplots(nrows=1, ncols=3)\n",
        "\n",
        "# Set figure size.\n",
        "fig.set_size_inches(w=12, h=4)\n",
        "\n",
        "axes[0].plot(numbers)\n",
        "axes[1].scatter(x, y)\n",
        "axes[2].scatter(x, y)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Btsqfv6nGKR3"
      },
      "source": [
        "Examine what the list of axes looked like in this case:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6FLaOeLDGI3A"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[\u003cmatplotlib.axes._subplots.AxesSubplot object at 0x7f3b40ab4f10\u003e\n",
            " \u003cmatplotlib.axes._subplots.AxesSubplot object at 0x7f3b40a11b10\u003e\n",
            " \u003cmatplotlib.axes._subplots.AxesSubplot object at 0x7f3b409d6110\u003e]\n"
          ]
        }
      ],
      "source": [
        "print(axes)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xpIKAhnVGcGQ"
      },
      "source": [
        "Let's try making a bar plot, labelling our axes, and writing a plot title:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yLFiN9eUGOXE"
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUcAAADgCAYAAACQJ6SJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAASiElEQVR4nO3de5QcZZ3G8e8DAYIJAjFjNiBhEMIiXsi6Ay7hYhBlWYUDuFxkQWG9RFBZUUFZQYE9u14Owt7FDcgJKoYFBQHDBhCBgKAwYQkJAoaFiYAhJCBCMIhJfvtHvQPF8PZMz2Sqq2fyfM7p01VvXd63u6eefquqq0YRgZmZvdJGdTfAzKwdORzNzDIcjmZmGQ5HM7MMh6OZWYbD0cwsw+FobUPSMZKur7sdZuBwtGEgqUfSakmrSo9tBrueiLgkIg4orTck7TRA3ZMlfVvSMknPSXpA0tmSxg3ltTRL0lmSvldlHVYvh6MNl4MjYnzp8ZvyREljhrtCSROAO4DNgT0jYgvgPcBWwI7DXZ9tWByOVpnU8/ukpCXAEkmdqWxMaZ6bJX00DR8v6bY0PD/NsjD1RI/KVPFZ4Dng2IjoAYiIRyPi0xFxb1rPdEl3Sfpdep5eqrtH0rtL4y/1BkttPU7SryWtlHR6mnYg8EXgqNS2haX2P5x6sI9IOmZ43kmrw7B/m5v1cSjwDmA1MKnZhSJiX0kB7BYRDzWY7d3AFRGxLjcx9SznAn8HzAGOAOZK2ikinmqyKXsDfwrsDNwp6YqImCfpK8BOEXFsqmsc8G/A7hHxoKTJwIQm67A25J6jDZcfSXomPX5UKv9qRDwdEasrqPN1wLJ+pr8PWBIR342INRExB3gAOHgQdZwdEasjYiGwENitn3nXAW+RtHlELIuI+wZRj7UZh6MNl0MjYqv0OLRU/miFdT4FTO5n+jbA0j5lS4FtB1HHE6Xh3wPjczNFxPPAUcAJwDJJcyXtMoh6rM04HK1q5ds+PZ+eX1Mq+5P1WPdPgMMkNfo7/g2wfZ+yKcDjpfYMtS2vup1VRFwXEe+hCOwHgAsGsT5rMw5Ha5mIWEERTMdK2ljSh+n/rPJy4I39TD8PeC1wsaTtASRtK+k8SW8DrgV2lvQ3ksakkzq7Aj9Oy98DfEDSJpK6gMMH8XKWA529wSxpkqRD0rHHPwCrKHazbYRyOFqrfQw4lWKX+M3A7f3MexZF8D0j6ci+EyPiaWA68EfgF5KeA24Efgc8lE66HAR8LtX3eeCgiFiZVvElinD+LXA28P1BvI7L0/NTku6m2JY+S9FbfRp4J3DiINZnbUa+2a2Z2au552hmluFwNDPLcDiamWU4HM3MMhyOZmYZI+La6okTJ0ZnZ2fdzTCzUWbBggUrI6IjN21EhGNnZyfd3d11N8PMRhlJfS8vfYl3q83MMhyOZmYZlYWjpO0k3STpl5Luk/TpVD5B0g2SlqTnratqg5nZUFXZc1wDfC4idgX+AvikpF2B04AbI2IqxXWwp1XYBjOzIaksHNPNPu9Ow88B91PcR+8Q4OI028UUd4o2M2srLTlbLakT+DPgF8CkiOi9e/MTNLh1vqSZwEyAKVOmDKXSwS/TjnxjELNaVH5CRtJ44IfAyRHxbHlaFLcEym79ETErIroioqujI/szJDOzylQajpI2oQjGSyLiilS8PP3zIdLzk1W2wcxsKKo8Wy3g28D9EXFeadLVwHFp+DjgqqraYGY2VFUec9wL+CCwSNI9qeyLwNeAyyR9hOKfHb3qDs9mZnWrLBwj4jag0VmR/auq18xsOPgKGTOzDIejmVmGw9HMLMPhaGaW4XA0M8twOJqZZTgczcwyHI5mZhkORzOzDIejmVmGw9HMLMPhaGaW4XA0M8twOJqZZTgczcwyHI5mZhkORzOzDIejmVmGw9HMLMPhaGaW4XA0M8twOJqZZTgczcwyHI5mZhkORzOzDIejmVmGw9HMLMPhaGaW4XA0M8twOJqZZVQWjpIukvSkpMWlsrMkPS7pnvR4b1X1m5mtjyp7jrOBAzPl/xwR09Lj2grrNzMbssrCMSLmA09XtX4zsyrVcczxU5LuTbvdWzeaSdJMSd2SulesWNHK9pmZtTwczwd2BKYBy4BzG80YEbMioisiujo6OlrVPjMzoMXhGBHLI2JtRKwDLgD2aGX9ZmbNamk4SppcGj0MWNxoXjOzOo2pasWS5gAzgImSHgPOBGZImgYE0AN8vKr6zczWR2XhGBFHZ4q/XVV9ZmbDyVfImJllOBzNzDIcjmZmGQ5HM7MMh6OZWYbD0cwsw+FoZpbhcDQzy3A4mpllOBzNzDIqu3zQzEYIqe4WDI+IYV2de45mZhkORzOzDIejmVmGw9HMLMPhaGaW0VQ4StqrmTIzs9Gi2Z7jvzdZZmY2KvT7O0dJewLTgQ5Jny1Nei2wcZUNMzOr00A/At8UGJ/m26JU/ixweFWNMjOrW7/hGBG3ALdImh0RS1vUJjOz2jV7+eBmkmYBneVlIuJdVTTKzKxuzYbj5cC3gAuBtdU1x8ysPTQbjmsi4vxKW2Jm1kaa/SnPNZI+IWmypAm9j0pbZmZWo2Z7jsel51NLZQG8cXibY2bWHpoKx4jYoeqGmJm1k6bCUdKHcuUR8Z3hbY6ZWXtodrd699LwWGB/4G7A4Whmo1Kzu9UnlcclbQVcWkmLzMzawFBvWfY80O9xSEkXSXpS0uJS2QRJN0hakp63HmL9ZmaVavaWZddIujo95gIPAlcOsNhs4MA+ZacBN0bEVODGNG5m1naaPeb4jdLwGmBpRDzW3wIRMV9SZ5/iQ4AZafhi4GbgC022wcysZZrqOaYbUDxAcWeerYEXh1jfpIhYloafACY1mlHSTEndkrpXrFgxxOrMzIam2d3qI4E7gSOAI4FfSFqvW5ZFRFD8kLzR9FkR0RURXR0dHetTlZnZoDW7W306sHtEPAkgqQP4CfCDQda3XNLkiFgmaTLw5CCXNzNriWbPVm/UG4zJU4NYtuxqXr4U8TjgqiGsw8yscs32HOdJug6Yk8aPAq7tbwFJcyhOvkyU9BhwJvA14DJJHwGWUuyim5m1nYH+h8xOFCdRTpX0fmDvNOkO4JL+lo2IoxtM2n/QrTQza7GBeo7/Avw9QERcAVwBIOmtadrBlbbOzKwmAx03nBQRi/oWprLOSlpkZtYGBgrHrfqZtvlwNsTMrJ0MFI7dkj7Wt1DSR4EF1TTJzKx+Ax1zPBm4UtIxvByGXRT/z/qwKhtmZlangf5v9XJguqT9gLek4rkR8dPKW2ZmVqNm7+d4E3BTxW0xM2sbQ72fo5nZqOZwNDPLcDiamWU4HM3MMhyOZmYZDkczswyHo5lZhsPRzCzD4WhmluFwNDPLcDiamWU4HM3MMhyOZmYZDkczswyHo5lZhsPRzCzD4WhmluFwNDPLcDiamWU4HM3MMhyOZmYZDkczs4ym/jXrcJPUAzwHrAXWRERXHe0wM2uklnBM9ouIlTXWb2bWkHerzcwy6grHAK6XtEDSzJraYGbWUF271XtHxOOSXg/cIOmBiJhfniGF5kyAKVOm1NFGM9uA1dJzjIjH0/OTwJXAHpl5ZkVEV0R0dXR0tLqJZraBa3k4ShonaYveYeAAYHGr22Fm1p86dqsnAVdK6q3/+xExr4Z2mJk11PJwjIiHgd1aXa+Z2WD4pzxmZhkORzOzDIejmVlGnZcP2oamOAk3OkTU3QKrmHuOZmYZDkczswyHo5lZhsPRzCzD4WhmluFwNDPLcDiamWU4HM3MMhyOZmYZDkczswyHo5lZhsPRzCzD4WhmluFwNDPLcDiamWU4HM3MMhyOZmYZDkczswyHo5lZhsPRzCzD4WhmluFwNDPLcDiamWU4HM3MMhyOZmYZDkczs4xawlHSgZIelPSQpNPqaIOZWX9aHo6SNgb+E/grYFfgaEm7trodZmb9qaPnuAfwUEQ8HBEvApcCh9TQDjOzhuoIx22BR0vjj6UyM7O2MabuBjQiaSYwM42ukvRgne1pYCKwstIapEpXPwpV/5mAP5fBa9dtZftGE+oIx8eB7Urjb0hlrxARs4BZrWrUUEjqjoiuutthL/Nn0p5G4udSx271XcBUSTtI2hT4AHB1De0wM2uo5T3HiFgj6VPAdcDGwEURcV+r22Fm1p9ajjlGxLXAtXXUPczaerd/A+XPpD2NuM9FEVF3G8zM2o4vHzQzyxiV4SjpZEmvqWC9syUdPszrvH0412c2WJLOknRKTXXPkDS9NH6CpA/V0Za+RmU4AicD2XBMly+2nKQxufGImJ5fwmyDMAN4aRuIiG9FxHfqa87LRnw4Shonaa6khZIWSzoT2Aa4SdJNaZ5Vks6VtBDYU9KXJd2V5p+lwuslLUjz7yYpJE1J4/9X6om+W1K3pF9JOihN31jSOWmd90r6eCqfIelWSVcDv+w73tu20ms5tbSOsxu8vqNa8b62A0lfSjcouU3SHEmnSLpZUleaPlFSTxruTO/t3ekxPZVfKul9pXXOlnR4o/k3BJI+lP7GFkr6bp9pO0qaJ2lBen92SeWzJZ0v6eeSHk5/yxdJul/S7NLyB0i6I72nl0san8p7JJ2dyhdJ2kVSJ3AC8BlJ90jap9yLTZ/11yXdmba3fVJ5o+1tsqT5aV2Le+cfsogY0Q/gr4ELSuNbAj3AxFJZAEeWxieUhr8LHJyG7wNeC3yK4veYx1D8gv6ONH02MI/iS2UqxaWPYymu5DkjzbMZ0A3sQPGt+DywQ5r2ivFUtio9H0BxRk9p/T8G9s29vrrf8xZ9rrsD96T3dwtgCXAKcDPQleaZCPSk4dcAY9PwVKA7DR8GXJyGN6W4dHXzRvOP9gfwZuBXvdsHMAE4Czgljd8ITE3D7wB+moZnU9wHQRT3QngWeGv6W10ATEufx3xgXFrmC8CX03APcFIa/gRwYRp+qe6+4+mzPjcNvxf4SRputL19Djg9lW8MbLE+71XbXj44CIuAcyV9HfhxRNyqV19GtBb4YWl8P0mfp9hAJlCE4jXA7cBeFKH0FeBAij+GW0vLXhYR64Alkh4GdqEItrfp5eORW1JscC8Cd0bEI6Xl+473OiA9/jeNj0/ruLXv62viPRkN9gKuiogXgBckXTPA/JsA/yFpGsXnvXMq/x/gXyVtRvF5zo+I1ZK2bDD/aPcu4PKIWAkQEU/3bi+plzcduLy0DW1WWvaaiAhJi4DlEbEoLXcf0ElxtduuwM/S8psCd5SWvyI9LwDe32R7y8t0puFG29tdwEWSNgF+FBH3NFlH1ogPx4j4laS3U3yz/KOkGzOzvRARawEkjQW+SdH7eFTSWRS9Eyi+9fah6C1eRfHNF8DccpV9m0ARoCdFxHXlCZJmUPQUy/qOvzQ78NWI+K9XTejz+iLiHxqsY0OwhpcPB40tlX8GWA7slqa/ABARL0i6GfhL4CiK3k/D+TdwGwHPRMS0BtP/kJ7XlYZ7x8dQfMncEBFHD7D8WprPntwy2e0NQNK+wPuA2ZLOi/U4fjkajjluA/w+Ir4HnAO8HXiOYlcsp3eDWpm+Kctnn28FjgWWpN7h0xShdFtpniMkbSRpR+CNwIMUV/ucmL6xkLSzpHGDfCnXAR8uHaPZVsVx0Nzr2xD8DDhY0tj0nhyUynuAP0/D5c9uS2BZ+tw+SLFb1eu/gb+l+OKb18T8o9lPKf6GXwcgaULvhIh4FnhE0hFpmiTtNoh1/xzYS9JOaflxkgbqkfe3rTaS3d4kbU/Ro70AuJD13FZGfM+R4rjHOZLWAX8ETgT2BOZJ+k1E7FeeOSKekXQBsBh4gqIr3jutR8X+wPxUdBvwhoj4bWkVvwbupDg2eULqmVxI0eW/Oy2/Ajh0MC8iIq6X9CbgjrRLsooiqHfKvL5RLyLuUnHi6l6KHt4i4HfAN4DLVNy1qdyj/ybwQxU/A5nHK3vo11McW74qinuIDjT/qBUR90n6J+AWSWspDuP0lGY5Bjhf0hkUhyouBRY2ue4Vko4H5qTDGABnUBzjbOQa4AeSDgFOavJlNNreZgCnSvojxfazXj8J8hUy1rYkjY+IVSp+KTAfmBkRd9fdLtswjIaeo41es1T8C42xFGecHYzWMu45mplljPgTMmZmVXA4mpllOBzNzDIcjjYiSFqbrpntfXQOYtmX7vQi6fj021GzfvmEjI0IklZFxPgG00Txt7yuifXcTHHtbvcwN9FGGfccbURScVedByV9h+IH/dvplXc4OlzpbjG9d3pJ1+J2AZek3ufmtTTeRgSHo40Um5d2qa9MZVOBb0bEmyNi6UAriIgfUNzB5ZiImBYRq6tssI1s/hG4jRSryzdESMccl0bEz2trkY1q7jnaSNb3eujyAfSxmK0Hh6ONJsslvUnSRhQ3uc0Zyl1gbAPkcLTR5DSKO6jfDixrMM9s4Fs+IWMD8U95zMwy3HM0M8twOJqZZTgczcwyHI5mZhkORzOzDIejmVmGw9HMLMPhaGaW8f8YXGAHA7dBeAAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "\u003cFigure size 360x216 with 1 Axes\u003e"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Creating the dataset.\n",
        "data = {'strawberries': 20,\n",
        "        'guava': 4,\n",
        "        'clementines': 13}\n",
        "fruits = list(data.keys())\n",
        "counts = list(data.values())\n",
        "\n",
        "fig = plt.figure(figsize=(5, 3))\n",
        "\n",
        "# Plot the bar plot.\n",
        "plt.bar(fruits, counts, color='red', width=0.5)\n",
        "\n",
        "plt.xlabel(\"Fruit\")\n",
        "plt.ylabel(\"Count\")\n",
        "plt.title(\"Fruit Counts\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lF9T8i12IoaD"
      },
      "source": [
        "#### Bokeh\n",
        "\n",
        "Bokeh is another visualisation library available in Python. Bokeh makes it easy to create **interactive visualisations**. From the [Bokeh docs](https://docs.bokeh.org/en/latest/index.html):\n",
        "\u003e Bokeh is a Python library for creating interactive visualisations for modern web browsers. It helps you build beautiful graphics, ranging from simple plots to complex dashboards with streaming datasets. With Bokeh, you can create JavaScript-powered visualisations without writing any JavaScript yourself.\n",
        "\n",
        "Below are some plot examples using Bokeh. For more detailed examples, check this [interactive tutorial](https://mybinder.org/v2/gh/bokeh/bokeh-notebooks/master?filepath=tutorial%2F00%20-%20Introduction%20and%20Setup.ipynb)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "l7EfZBViOJmQ"
      },
      "outputs": [],
      "source": [
        "from bokeh.io import output_notebook, show\n",
        "from bokeh.plotting import figure\n",
        "\n",
        "# The text below is from the Bokeh tutorial:\n",
        "# We are in a Jupyter notebook, so we will call `output_notebook()`.\n",
        "# We only need to call this once, and all subsequent calls to `show()` will\n",
        "# display inline in the notebook.\n",
        "output_notebook()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D0pi8wiwHjba"
      },
      "source": [
        "Let's start again by making a simple line plot:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "smOxoMjNNmhy"
      },
      "outputs": [
        {
          "data": {
            "application/javascript": [
              "\n",
              "(function(root) {\n",
              "  function now() {\n",
              "    return new Date();\n",
              "  }\n",
              "\n",
              "  var force = true;\n",
              "\n",
              "  if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n",
              "    root._bokeh_onload_callbacks = [];\n",
              "    root._bokeh_is_loading = undefined;\n",
              "  }\n",
              "\n",
              "  var JS_MIME_TYPE = 'application/javascript';\n",
              "  var HTML_MIME_TYPE = 'text/html';\n",
              "  var EXEC_MIME_TYPE = 'application/vnd.bokehjs_exec.v0+json';\n",
              "  var CLASS_NAME = 'output_bokeh rendered_html';\n",
              "\n",
              "  /**\n",
              "   * Render data to the DOM node\n",
              "   */\n",
              "  function render(props, node) {\n",
              "    var script = document.createElement(\"script\");\n",
              "    node.appendChild(script);\n",
              "  }\n",
              "\n",
              "  /**\n",
              "   * Handle when an output is cleared or removed\n",
              "   */\n",
              "  function handleClearOutput(event, handle) {\n",
              "    var cell = handle.cell;\n",
              "\n",
              "    var id = cell.output_area._bokeh_element_id;\n",
              "    var server_id = cell.output_area._bokeh_server_id;\n",
              "    // Clean up Bokeh references\n",
              "    if (id != null \u0026\u0026 id in Bokeh.index) {\n",
              "      Bokeh.index[id].model.document.clear();\n",
              "      delete Bokeh.index[id];\n",
              "    }\n",
              "\n",
              "    if (server_id !== undefined) {\n",
              "      // Clean up Bokeh references\n",
              "      var cmd = \"from bokeh.io.state import curstate; print(curstate().uuid_to_server['\" + server_id + \"'].get_sessions()[0].document.roots[0]._id)\";\n",
              "      cell.notebook.kernel.execute(cmd, {\n",
              "        iopub: {\n",
              "          output: function(msg) {\n",
              "            var id = msg.content.text.trim();\n",
              "            if (id in Bokeh.index) {\n",
              "              Bokeh.index[id].model.document.clear();\n",
              "              delete Bokeh.index[id];\n",
              "            }\n",
              "          }\n",
              "        }\n",
              "      });\n",
              "      // Destroy server and session\n",
              "      var cmd = \"import bokeh.io.notebook as ion; ion.destroy_server('\" + server_id + \"')\";\n",
              "      cell.notebook.kernel.execute(cmd);\n",
              "    }\n",
              "  }\n",
              "\n",
              "  /**\n",
              "   * Handle when a new output is added\n",
              "   */\n",
              "  function handleAddOutput(event, handle) {\n",
              "    var output_area = handle.output_area;\n",
              "    var output = handle.output;\n",
              "\n",
              "    // limit handleAddOutput to display_data with EXEC_MIME_TYPE content only\n",
              "    if ((output.output_type != \"display_data\") || (!Object.prototype.hasOwnProperty.call(output.data, EXEC_MIME_TYPE))) {\n",
              "      return\n",
              "    }\n",
              "\n",
              "    var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n",
              "\n",
              "    if (output.metadata[EXEC_MIME_TYPE][\"id\"] !== undefined) {\n",
              "      toinsert[toinsert.length - 1].firstChild.textContent = output.data[JS_MIME_TYPE];\n",
              "      // store reference to embed id on output_area\n",
              "      output_area._bokeh_element_id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n",
              "    }\n",
              "    if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n",
              "      var bk_div = document.createElement(\"div\");\n",
              "      bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n",
              "      var script_attrs = bk_div.children[0].attributes;\n",
              "      for (var i = 0; i \u003c script_attrs.length; i++) {\n",
              "        toinsert[toinsert.length - 1].firstChild.setAttribute(script_attrs[i].name, script_attrs[i].value);\n",
              "        toinsert[toinsert.length - 1].firstChild.textContent = bk_div.children[0].textContent\n",
              "      }\n",
              "      // store reference to server id on output_area\n",
              "      output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n",
              "    }\n",
              "  }\n",
              "\n",
              "  function register_renderer(events, OutputArea) {\n",
              "\n",
              "    function append_mime(data, metadata, element) {\n",
              "      // create a DOM node to render to\n",
              "      var toinsert = this.create_output_subarea(\n",
              "        metadata,\n",
              "        CLASS_NAME,\n",
              "        EXEC_MIME_TYPE\n",
              "      );\n",
              "      this.keyboard_manager.register_events(toinsert);\n",
              "      // Render to node\n",
              "      var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n",
              "      render(props, toinsert[toinsert.length - 1]);\n",
              "      element.append(toinsert);\n",
              "      return toinsert\n",
              "    }\n",
              "\n",
              "    /* Handle when an output is cleared or removed */\n",
              "    events.on('clear_output.CodeCell', handleClearOutput);\n",
              "    events.on('delete.Cell', handleClearOutput);\n",
              "\n",
              "    /* Handle when a new output is added */\n",
              "    events.on('output_added.OutputArea', handleAddOutput);\n",
              "\n",
              "    /**\n",
              "     * Register the mime type and append_mime function with output_area\n",
              "     */\n",
              "    OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n",
              "      /* Is output safe? */\n",
              "      safe: true,\n",
              "      /* Index of renderer in `output_area.display_order` */\n",
              "      index: 0\n",
              "    });\n",
              "  }\n",
              "\n",
              "  // register the mime type if in Jupyter Notebook environment and previously unregistered\n",
              "  if (root.Jupyter !== undefined) {\n",
              "    var events = require('base/js/events');\n",
              "    var OutputArea = require('notebook/js/outputarea').OutputArea;\n",
              "\n",
              "    if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n",
              "      register_renderer(events, OutputArea);\n",
              "    }\n",
              "  }\n",
              "\n",
              "  \n",
              "  if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n",
              "    root._bokeh_timeout = Date.now() + 5000;\n",
              "    root._bokeh_failed_load = false;\n",
              "  }\n",
              "\n",
              "  var NB_LOAD_WARNING = {'data': {'text/html':\n",
              "     \"\u003cdiv style='background-color: #fdd'\u003e\\n\"+\n",
              "     \"\u003cp\u003e\\n\"+\n",
              "     \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n",
              "     \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n",
              "     \"\u003c/p\u003e\\n\"+\n",
              "     \"\u003cul\u003e\\n\"+\n",
              "     \"\u003cli\u003ere-rerun `output_notebook()` to attempt to load from CDN again, or\u003c/li\u003e\\n\"+\n",
              "     \"\u003cli\u003euse INLINE resources instead, as so:\u003c/li\u003e\\n\"+\n",
              "     \"\u003c/ul\u003e\\n\"+\n",
              "     \"\u003ccode\u003e\\n\"+\n",
              "     \"from bokeh.resources import INLINE\\n\"+\n",
              "     \"output_notebook(resources=INLINE)\\n\"+\n",
              "     \"\u003c/code\u003e\\n\"+\n",
              "     \"\u003c/div\u003e\"}};\n",
              "\n",
              "  function display_loaded() {\n",
              "    var el = document.getElementById(null);\n",
              "    if (el != null) {\n",
              "      el.textContent = \"BokehJS is loading...\";\n",
              "    }\n",
              "    if (root.Bokeh !== undefined) {\n",
              "      if (el != null) {\n",
              "        el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n",
              "      }\n",
              "    } else if (Date.now() \u003c root._bokeh_timeout) {\n",
              "      setTimeout(display_loaded, 100)\n",
              "    }\n",
              "  }\n",
              "\n",
              "\n",
              "  function run_callbacks() {\n",
              "    try {\n",
              "      root._bokeh_onload_callbacks.forEach(function(callback) {\n",
              "        if (callback != null)\n",
              "          callback();\n",
              "      });\n",
              "    } finally {\n",
              "      delete root._bokeh_onload_callbacks\n",
              "    }\n",
              "    console.debug(\"Bokeh: all callbacks have finished\");\n",
              "  }\n",
              "\n",
              "  function load_libs(css_urls, js_urls, callback) {\n",
              "    if (css_urls == null) css_urls = [];\n",
              "    if (js_urls == null) js_urls = [];\n",
              "\n",
              "    root._bokeh_onload_callbacks.push(callback);\n",
              "    if (root._bokeh_is_loading \u003e 0) {\n",
              "      console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n",
              "      return null;\n",
              "    }\n",
              "    if (js_urls == null || js_urls.length === 0) {\n",
              "      run_callbacks();\n",
              "      return null;\n",
              "    }\n",
              "    console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n",
              "    root._bokeh_is_loading = css_urls.length + js_urls.length;\n",
              "\n",
              "    function on_load() {\n",
              "      root._bokeh_is_loading--;\n",
              "      if (root._bokeh_is_loading === 0) {\n",
              "        console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n",
              "        run_callbacks()\n",
              "      }\n",
              "    }\n",
              "\n",
              "    function on_error(url) {\n",
              "      console.error(\"failed to load \" + url);\n",
              "    }\n",
              "\n",
              "    for (let i = 0; i \u003c css_urls.length; i++) {\n",
              "      const url = css_urls[i];\n",
              "      const element = document.createElement(\"link\");\n",
              "      element.onload = on_load;\n",
              "      element.onerror = on_error.bind(null, url);\n",
              "      element.rel = \"stylesheet\";\n",
              "      element.type = \"text/css\";\n",
              "      element.href = url;\n",
              "      console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n",
              "      document.body.appendChild(element);\n",
              "    }\n",
              "\n",
              "    const hashes = {\"https://cdn.bokeh.org/bokeh/release/bokeh-2.3.3.min.js\": \"dM3QQsP+wXdHg42wTqW85BjZQdLNNIXqlPw/BgKoExPmTG7ZLML4EGqLMfqHT6ON\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.3.3.min.js\": \"8x57I4YuIfu8XyZfFo0XVr2WAT8EK4rh/uDe3wF7YuW2FNUSNEpJbsPaB1nJ2fz2\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.3.3.min.js\": \"3QTqdz9LyAm2i0sG5XTePsHec3UHWwVsrOL68SYRoAXsafvfAyqtQ+h440+qIBhS\"};\n",
              "\n",
              "    for (let i = 0; i \u003c js_urls.length; i++) {\n",
              "      const url = js_urls[i];\n",
              "      const element = document.createElement('script');\n",
              "      element.onload = on_load;\n",
              "      element.onerror = on_error.bind(null, url);\n",
              "      element.async = false;\n",
              "      element.src = url;\n",
              "      if (url in hashes) {\n",
              "        element.crossOrigin = \"anonymous\";\n",
              "        element.integrity = \"sha384-\" + hashes[url];\n",
              "      }\n",
              "      console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n",
              "      document.head.appendChild(element);\n",
              "    }\n",
              "  };\n",
              "\n",
              "  function inject_raw_css(css) {\n",
              "    const element = document.createElement(\"style\");\n",
              "    element.appendChild(document.createTextNode(css));\n",
              "    document.body.appendChild(element);\n",
              "  }\n",
              "\n",
              "  \n",
              "  var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.3.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.3.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.3.3.min.js\"];\n",
              "  var css_urls = [];\n",
              "  \n",
              "\n",
              "  var inline_js = [\n",
              "    function(Bokeh) {\n",
              "      Bokeh.set_log_level(\"info\");\n",
              "    },\n",
              "    function(Bokeh) {\n",
              "    \n",
              "    \n",
              "    }\n",
              "  ];\n",
              "\n",
              "  function run_inline_js() {\n",
              "    \n",
              "    if (root.Bokeh !== undefined || force === true) {\n",
              "      \n",
              "    for (var i = 0; i \u003c inline_js.length; i++) {\n",
              "      inline_js[i].call(root, root.Bokeh);\n",
              "    }\n",
              "    } else if (Date.now() \u003c root._bokeh_timeout) {\n",
              "      setTimeout(run_inline_js, 100);\n",
              "    } else if (!root._bokeh_failed_load) {\n",
              "      console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n",
              "      root._bokeh_failed_load = true;\n",
              "    } else if (force !== true) {\n",
              "      var cell = $(document.getElementById(null)).parents('.cell').data().cell;\n",
              "      cell.output_area.append_execute_result(NB_LOAD_WARNING)\n",
              "    }\n",
              "\n",
              "  }\n",
              "\n",
              "  if (root._bokeh_is_loading === 0) {\n",
              "    console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n",
              "    run_inline_js();\n",
              "  } else {\n",
              "    load_libs(css_urls, js_urls, function() {\n",
              "      console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n",
              "      run_inline_js();\n",
              "    });\n",
              "  }\n",
              "}(window));"
            ],
            "application/vnd.bokehjs_load.v0+json": "\n(function(root) {\n  function now() {\n    return new Date();\n  }\n\n  var force = true;\n\n  if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n    root._bokeh_onload_callbacks = [];\n    root._bokeh_is_loading = undefined;\n  }\n\n  \n\n  \n  if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n    root._bokeh_timeout = Date.now() + 5000;\n    root._bokeh_failed_load = false;\n  }\n\n  var NB_LOAD_WARNING = {'data': {'text/html':\n     \"\u003cdiv style='background-color: #fdd'\u003e\\n\"+\n     \"\u003cp\u003e\\n\"+\n     \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n     \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n     \"\u003c/p\u003e\\n\"+\n     \"\u003cul\u003e\\n\"+\n     \"\u003cli\u003ere-rerun `output_notebook()` to attempt to load from CDN again, or\u003c/li\u003e\\n\"+\n     \"\u003cli\u003euse INLINE resources instead, as so:\u003c/li\u003e\\n\"+\n     \"\u003c/ul\u003e\\n\"+\n     \"\u003ccode\u003e\\n\"+\n     \"from bokeh.resources import INLINE\\n\"+\n     \"output_notebook(resources=INLINE)\\n\"+\n     \"\u003c/code\u003e\\n\"+\n     \"\u003c/div\u003e\"}};\n\n  function display_loaded() {\n    var el = document.getElementById(null);\n    if (el != null) {\n      el.textContent = \"BokehJS is loading...\";\n    }\n    if (root.Bokeh !== undefined) {\n      if (el != null) {\n        el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n      }\n    } else if (Date.now() \u003c root._bokeh_timeout) {\n      setTimeout(display_loaded, 100)\n    }\n  }\n\n\n  function run_callbacks() {\n    try {\n      root._bokeh_onload_callbacks.forEach(function(callback) {\n        if (callback != null)\n          callback();\n      });\n    } finally {\n      delete root._bokeh_onload_callbacks\n    }\n    console.debug(\"Bokeh: all callbacks have finished\");\n  }\n\n  function load_libs(css_urls, js_urls, callback) {\n    if (css_urls == null) css_urls = [];\n    if (js_urls == null) js_urls = [];\n\n    root._bokeh_onload_callbacks.push(callback);\n    if (root._bokeh_is_loading \u003e 0) {\n      console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n      return null;\n    }\n    if (js_urls == null || js_urls.length === 0) {\n      run_callbacks();\n      return null;\n    }\n    console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n    root._bokeh_is_loading = css_urls.length + js_urls.length;\n\n    function on_load() {\n      root._bokeh_is_loading--;\n      if (root._bokeh_is_loading === 0) {\n        console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n        run_callbacks()\n      }\n    }\n\n    function on_error(url) {\n      console.error(\"failed to load \" + url);\n    }\n\n    for (let i = 0; i \u003c css_urls.length; i++) {\n      const url = css_urls[i];\n      const element = document.createElement(\"link\");\n      element.onload = on_load;\n      element.onerror = on_error.bind(null, url);\n      element.rel = \"stylesheet\";\n      element.type = \"text/css\";\n      element.href = url;\n      console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n      document.body.appendChild(element);\n    }\n\n    const hashes = {\"https://cdn.bokeh.org/bokeh/release/bokeh-2.3.3.min.js\": \"dM3QQsP+wXdHg42wTqW85BjZQdLNNIXqlPw/BgKoExPmTG7ZLML4EGqLMfqHT6ON\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.3.3.min.js\": \"8x57I4YuIfu8XyZfFo0XVr2WAT8EK4rh/uDe3wF7YuW2FNUSNEpJbsPaB1nJ2fz2\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.3.3.min.js\": \"3QTqdz9LyAm2i0sG5XTePsHec3UHWwVsrOL68SYRoAXsafvfAyqtQ+h440+qIBhS\"};\n\n    for (let i = 0; i \u003c js_urls.length; i++) {\n      const url = js_urls[i];\n      const element = document.createElement('script');\n      element.onload = on_load;\n      element.onerror = on_error.bind(null, url);\n      element.async = false;\n      element.src = url;\n      if (url in hashes) {\n        element.crossOrigin = \"anonymous\";\n        element.integrity = \"sha384-\" + hashes[url];\n      }\n      console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n      document.head.appendChild(element);\n    }\n  };\n\n  function inject_raw_css(css) {\n    const element = document.createElement(\"style\");\n    element.appendChild(document.createTextNode(css));\n    document.body.appendChild(element);\n  }\n\n  \n  var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.3.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.3.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.3.3.min.js\"];\n  var css_urls = [];\n  \n\n  var inline_js = [\n    function(Bokeh) {\n      Bokeh.set_log_level(\"info\");\n    },\n    function(Bokeh) {\n    \n    \n    }\n  ];\n\n  function run_inline_js() {\n    \n    if (root.Bokeh !== undefined || force === true) {\n      \n    for (var i = 0; i \u003c inline_js.length; i++) {\n      inline_js[i].call(root, root.Bokeh);\n    }\n    } else if (Date.now() \u003c root._bokeh_timeout) {\n      setTimeout(run_inline_js, 100);\n    } else if (!root._bokeh_failed_load) {\n      console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n      root._bokeh_failed_load = true;\n    } else if (force !== true) {\n      var cell = $(document.getElementById(null)).parents('.cell').data().cell;\n      cell.output_area.append_execute_result(NB_LOAD_WARNING)\n    }\n\n  }\n\n  if (root._bokeh_is_loading === 0) {\n    console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n    run_inline_js();\n  } else {\n    load_libs(css_urls, js_urls, function() {\n      console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n      run_inline_js();\n    });\n  }\n}(window));"
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/html": [
              "\n",
              "\n",
              "\n",
              "\n",
              "\n",
              "\n",
              "  \u003cdiv class=\"bk-root\" id=\"784b1521-ebc9-4659-a62b-97e59d3785f2\" data-root-id=\"1002\"\u003e\u003c/div\u003e\n"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "application/javascript": [
              "(function(root) {\n",
              "  function embed_document(root) {\n",
              "    \n",
              "  var docs_json = {\"f6cf3866-bcbf-451a-b051-66b20345a722\":{\"defs\":[],\"roots\":{\"references\":[{\"attributes\":{\"below\":[{\"id\":\"1011\"}],\"center\":[{\"id\":\"1014\"},{\"id\":\"1018\"}],\"left\":[{\"id\":\"1015\"}],\"renderers\":[{\"id\":\"1036\"}],\"title\":{\"id\":\"1038\"},\"toolbar\":{\"id\":\"1026\"},\"x_range\":{\"id\":\"1003\"},\"x_scale\":{\"id\":\"1007\"},\"y_range\":{\"id\":\"1005\"},\"y_scale\":{\"id\":\"1009\"}},\"id\":\"1002\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{},\"id\":\"1024\",\"type\":\"HelpTool\"},{\"attributes\":{},\"id\":\"1016\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1047\",\"type\":\"Selection\"},{\"attributes\":{},\"id\":\"1009\",\"type\":\"LinearScale\"},{\"attributes\":{\"axis\":{\"id\":\"1011\"},\"ticker\":null},\"id\":\"1014\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1045\",\"type\":\"AllLabels\"},{\"attributes\":{},\"id\":\"1012\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1046\",\"type\":\"UnionRenderers\"},{\"attributes\":{\"axis\":{\"id\":\"1015\"},\"dimension\":1,\"ticker\":null},\"id\":\"1018\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1041\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"formatter\":{\"id\":\"1041\"},\"major_label_policy\":{\"id\":\"1042\"},\"ticker\":{\"id\":\"1016\"}},\"id\":\"1015\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1044\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1042\",\"type\":\"AllLabels\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":0.5,\"fill_color\":\"lightgrey\",\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":1.0,\"line_color\":\"black\",\"line_dash\":[4,4],\"line_width\":2,\"right_units\":\"screen\",\"syncable\":false,\"top_units\":\"screen\"},\"id\":\"1025\",\"type\":\"BoxAnnotation\"},{\"attributes\":{\"active_multi\":null,\"tools\":[{\"id\":\"1019\"},{\"id\":\"1020\"},{\"id\":\"1021\"},{\"id\":\"1022\"},{\"id\":\"1023\"},{\"id\":\"1024\"}]},\"id\":\"1026\",\"type\":\"Toolbar\"},{\"attributes\":{\"data\":{\"x\":[0,1,2,3,4,5,6,7,8,9],\"y\":[0,1,2,3,4,5,6,7,8,9]},\"selected\":{\"id\":\"1047\"},\"selection_policy\":{\"id\":\"1046\"}},\"id\":\"1033\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"line_alpha\":0.1,\"line_color\":\"#1f77b4\",\"x\":{\"field\":\"x\"},\"y\":{\"field\":\"y\"}},\"id\":\"1035\",\"type\":\"Line\"},{\"attributes\":{},\"id\":\"1003\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1019\",\"type\":\"PanTool\"},{\"attributes\":{\"formatter\":{\"id\":\"1044\"},\"major_label_policy\":{\"id\":\"1045\"},\"ticker\":{\"id\":\"1012\"}},\"id\":\"1011\",\"type\":\"LinearAxis\"},{\"attributes\":{\"line_color\":\"#1f77b4\",\"x\":{\"field\":\"x\"},\"y\":{\"field\":\"y\"}},\"id\":\"1034\",\"type\":\"Line\"},{\"attributes\":{},\"id\":\"1020\",\"type\":\"WheelZoomTool\"},{\"attributes\":{\"overlay\":{\"id\":\"1025\"}},\"id\":\"1021\",\"type\":\"BoxZoomTool\"},{\"attributes\":{\"source\":{\"id\":\"1033\"}},\"id\":\"1037\",\"type\":\"CDSView\"},{\"attributes\":{},\"id\":\"1022\",\"type\":\"SaveTool\"},{\"attributes\":{},\"id\":\"1005\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1038\",\"type\":\"Title\"},{\"attributes\":{\"data_source\":{\"id\":\"1033\"},\"glyph\":{\"id\":\"1034\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1035\"},\"view\":{\"id\":\"1037\"}},\"id\":\"1036\",\"type\":\"GlyphRenderer\"},{\"attributes\":{},\"id\":\"1023\",\"type\":\"ResetTool\"},{\"attributes\":{},\"id\":\"1007\",\"type\":\"LinearScale\"}],\"root_ids\":[\"1002\"]},\"title\":\"Bokeh Application\",\"version\":\"2.3.3\"}};\n",
              "  var render_items = [{\"docid\":\"f6cf3866-bcbf-451a-b051-66b20345a722\",\"root_ids\":[\"1002\"],\"roots\":{\"1002\":\"784b1521-ebc9-4659-a62b-97e59d3785f2\"}}];\n",
              "  root.Bokeh.embed.embed_items_notebook(docs_json, render_items);\n",
              "\n",
              "  }\n",
              "  if (root.Bokeh !== undefined) {\n",
              "    embed_document(root);\n",
              "  } else {\n",
              "    var attempts = 0;\n",
              "    var timer = setInterval(function(root) {\n",
              "      if (root.Bokeh !== undefined) {\n",
              "        clearInterval(timer);\n",
              "        embed_document(root);\n",
              "      } else {\n",
              "        attempts++;\n",
              "        if (attempts \u003e 100) {\n",
              "          clearInterval(timer);\n",
              "          console.log(\"Bokeh: ERROR: Unable to run BokehJS code because BokehJS library is missing\");\n",
              "        }\n",
              "      }\n",
              "    }, 10, root)\n",
              "  }\n",
              "})(window);"
            ],
            "application/vnd.bokehjs_exec.v0+json": ""
          },
          "metadata": {
            "application/vnd.bokehjs_exec.v0+json": {
              "id": "1002"
            }
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Plot numbers as a line.\n",
        "numbers = range(10)\n",
        "\n",
        "p = figure()\n",
        "p.line(x=numbers, y=numbers)\n",
        "show(p)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BeOSfRY5IgaW"
      },
      "source": [
        "Notice that you can already interact with this plot by panning, zooming, saving, etc. (check out the row tools on the upper right hand side)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ifJ5Ft8WHmLc"
      },
      "source": [
        "The default figure size is a bit large, so let's shrink this down. We can also customise the line plot to be a red dashed line:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6gps35AsQYzK"
      },
      "outputs": [
        {
          "data": {
            "application/javascript": [
              "\n",
              "(function(root) {\n",
              "  function now() {\n",
              "    return new Date();\n",
              "  }\n",
              "\n",
              "  var force = true;\n",
              "\n",
              "  if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n",
              "    root._bokeh_onload_callbacks = [];\n",
              "    root._bokeh_is_loading = undefined;\n",
              "  }\n",
              "\n",
              "  var JS_MIME_TYPE = 'application/javascript';\n",
              "  var HTML_MIME_TYPE = 'text/html';\n",
              "  var EXEC_MIME_TYPE = 'application/vnd.bokehjs_exec.v0+json';\n",
              "  var CLASS_NAME = 'output_bokeh rendered_html';\n",
              "\n",
              "  /**\n",
              "   * Render data to the DOM node\n",
              "   */\n",
              "  function render(props, node) {\n",
              "    var script = document.createElement(\"script\");\n",
              "    node.appendChild(script);\n",
              "  }\n",
              "\n",
              "  /**\n",
              "   * Handle when an output is cleared or removed\n",
              "   */\n",
              "  function handleClearOutput(event, handle) {\n",
              "    var cell = handle.cell;\n",
              "\n",
              "    var id = cell.output_area._bokeh_element_id;\n",
              "    var server_id = cell.output_area._bokeh_server_id;\n",
              "    // Clean up Bokeh references\n",
              "    if (id != null \u0026\u0026 id in Bokeh.index) {\n",
              "      Bokeh.index[id].model.document.clear();\n",
              "      delete Bokeh.index[id];\n",
              "    }\n",
              "\n",
              "    if (server_id !== undefined) {\n",
              "      // Clean up Bokeh references\n",
              "      var cmd = \"from bokeh.io.state import curstate; print(curstate().uuid_to_server['\" + server_id + \"'].get_sessions()[0].document.roots[0]._id)\";\n",
              "      cell.notebook.kernel.execute(cmd, {\n",
              "        iopub: {\n",
              "          output: function(msg) {\n",
              "            var id = msg.content.text.trim();\n",
              "            if (id in Bokeh.index) {\n",
              "              Bokeh.index[id].model.document.clear();\n",
              "              delete Bokeh.index[id];\n",
              "            }\n",
              "          }\n",
              "        }\n",
              "      });\n",
              "      // Destroy server and session\n",
              "      var cmd = \"import bokeh.io.notebook as ion; ion.destroy_server('\" + server_id + \"')\";\n",
              "      cell.notebook.kernel.execute(cmd);\n",
              "    }\n",
              "  }\n",
              "\n",
              "  /**\n",
              "   * Handle when a new output is added\n",
              "   */\n",
              "  function handleAddOutput(event, handle) {\n",
              "    var output_area = handle.output_area;\n",
              "    var output = handle.output;\n",
              "\n",
              "    // limit handleAddOutput to display_data with EXEC_MIME_TYPE content only\n",
              "    if ((output.output_type != \"display_data\") || (!Object.prototype.hasOwnProperty.call(output.data, EXEC_MIME_TYPE))) {\n",
              "      return\n",
              "    }\n",
              "\n",
              "    var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n",
              "\n",
              "    if (output.metadata[EXEC_MIME_TYPE][\"id\"] !== undefined) {\n",
              "      toinsert[toinsert.length - 1].firstChild.textContent = output.data[JS_MIME_TYPE];\n",
              "      // store reference to embed id on output_area\n",
              "      output_area._bokeh_element_id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n",
              "    }\n",
              "    if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n",
              "      var bk_div = document.createElement(\"div\");\n",
              "      bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n",
              "      var script_attrs = bk_div.children[0].attributes;\n",
              "      for (var i = 0; i \u003c script_attrs.length; i++) {\n",
              "        toinsert[toinsert.length - 1].firstChild.setAttribute(script_attrs[i].name, script_attrs[i].value);\n",
              "        toinsert[toinsert.length - 1].firstChild.textContent = bk_div.children[0].textContent\n",
              "      }\n",
              "      // store reference to server id on output_area\n",
              "      output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n",
              "    }\n",
              "  }\n",
              "\n",
              "  function register_renderer(events, OutputArea) {\n",
              "\n",
              "    function append_mime(data, metadata, element) {\n",
              "      // create a DOM node to render to\n",
              "      var toinsert = this.create_output_subarea(\n",
              "        metadata,\n",
              "        CLASS_NAME,\n",
              "        EXEC_MIME_TYPE\n",
              "      );\n",
              "      this.keyboard_manager.register_events(toinsert);\n",
              "      // Render to node\n",
              "      var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n",
              "      render(props, toinsert[toinsert.length - 1]);\n",
              "      element.append(toinsert);\n",
              "      return toinsert\n",
              "    }\n",
              "\n",
              "    /* Handle when an output is cleared or removed */\n",
              "    events.on('clear_output.CodeCell', handleClearOutput);\n",
              "    events.on('delete.Cell', handleClearOutput);\n",
              "\n",
              "    /* Handle when a new output is added */\n",
              "    events.on('output_added.OutputArea', handleAddOutput);\n",
              "\n",
              "    /**\n",
              "     * Register the mime type and append_mime function with output_area\n",
              "     */\n",
              "    OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n",
              "      /* Is output safe? */\n",
              "      safe: true,\n",
              "      /* Index of renderer in `output_area.display_order` */\n",
              "      index: 0\n",
              "    });\n",
              "  }\n",
              "\n",
              "  // register the mime type if in Jupyter Notebook environment and previously unregistered\n",
              "  if (root.Jupyter !== undefined) {\n",
              "    var events = require('base/js/events');\n",
              "    var OutputArea = require('notebook/js/outputarea').OutputArea;\n",
              "\n",
              "    if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n",
              "      register_renderer(events, OutputArea);\n",
              "    }\n",
              "  }\n",
              "\n",
              "  \n",
              "  if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n",
              "    root._bokeh_timeout = Date.now() + 5000;\n",
              "    root._bokeh_failed_load = false;\n",
              "  }\n",
              "\n",
              "  var NB_LOAD_WARNING = {'data': {'text/html':\n",
              "     \"\u003cdiv style='background-color: #fdd'\u003e\\n\"+\n",
              "     \"\u003cp\u003e\\n\"+\n",
              "     \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n",
              "     \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n",
              "     \"\u003c/p\u003e\\n\"+\n",
              "     \"\u003cul\u003e\\n\"+\n",
              "     \"\u003cli\u003ere-rerun `output_notebook()` to attempt to load from CDN again, or\u003c/li\u003e\\n\"+\n",
              "     \"\u003cli\u003euse INLINE resources instead, as so:\u003c/li\u003e\\n\"+\n",
              "     \"\u003c/ul\u003e\\n\"+\n",
              "     \"\u003ccode\u003e\\n\"+\n",
              "     \"from bokeh.resources import INLINE\\n\"+\n",
              "     \"output_notebook(resources=INLINE)\\n\"+\n",
              "     \"\u003c/code\u003e\\n\"+\n",
              "     \"\u003c/div\u003e\"}};\n",
              "\n",
              "  function display_loaded() {\n",
              "    var el = document.getElementById(null);\n",
              "    if (el != null) {\n",
              "      el.textContent = \"BokehJS is loading...\";\n",
              "    }\n",
              "    if (root.Bokeh !== undefined) {\n",
              "      if (el != null) {\n",
              "        el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n",
              "      }\n",
              "    } else if (Date.now() \u003c root._bokeh_timeout) {\n",
              "      setTimeout(display_loaded, 100)\n",
              "    }\n",
              "  }\n",
              "\n",
              "\n",
              "  function run_callbacks() {\n",
              "    try {\n",
              "      root._bokeh_onload_callbacks.forEach(function(callback) {\n",
              "        if (callback != null)\n",
              "          callback();\n",
              "      });\n",
              "    } finally {\n",
              "      delete root._bokeh_onload_callbacks\n",
              "    }\n",
              "    console.debug(\"Bokeh: all callbacks have finished\");\n",
              "  }\n",
              "\n",
              "  function load_libs(css_urls, js_urls, callback) {\n",
              "    if (css_urls == null) css_urls = [];\n",
              "    if (js_urls == null) js_urls = [];\n",
              "\n",
              "    root._bokeh_onload_callbacks.push(callback);\n",
              "    if (root._bokeh_is_loading \u003e 0) {\n",
              "      console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n",
              "      return null;\n",
              "    }\n",
              "    if (js_urls == null || js_urls.length === 0) {\n",
              "      run_callbacks();\n",
              "      return null;\n",
              "    }\n",
              "    console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n",
              "    root._bokeh_is_loading = css_urls.length + js_urls.length;\n",
              "\n",
              "    function on_load() {\n",
              "      root._bokeh_is_loading--;\n",
              "      if (root._bokeh_is_loading === 0) {\n",
              "        console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n",
              "        run_callbacks()\n",
              "      }\n",
              "    }\n",
              "\n",
              "    function on_error(url) {\n",
              "      console.error(\"failed to load \" + url);\n",
              "    }\n",
              "\n",
              "    for (let i = 0; i \u003c css_urls.length; i++) {\n",
              "      const url = css_urls[i];\n",
              "      const element = document.createElement(\"link\");\n",
              "      element.onload = on_load;\n",
              "      element.onerror = on_error.bind(null, url);\n",
              "      element.rel = \"stylesheet\";\n",
              "      element.type = \"text/css\";\n",
              "      element.href = url;\n",
              "      console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n",
              "      document.body.appendChild(element);\n",
              "    }\n",
              "\n",
              "    const hashes = {\"https://cdn.bokeh.org/bokeh/release/bokeh-2.3.3.min.js\": \"dM3QQsP+wXdHg42wTqW85BjZQdLNNIXqlPw/BgKoExPmTG7ZLML4EGqLMfqHT6ON\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.3.3.min.js\": \"8x57I4YuIfu8XyZfFo0XVr2WAT8EK4rh/uDe3wF7YuW2FNUSNEpJbsPaB1nJ2fz2\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.3.3.min.js\": \"3QTqdz9LyAm2i0sG5XTePsHec3UHWwVsrOL68SYRoAXsafvfAyqtQ+h440+qIBhS\"};\n",
              "\n",
              "    for (let i = 0; i \u003c js_urls.length; i++) {\n",
              "      const url = js_urls[i];\n",
              "      const element = document.createElement('script');\n",
              "      element.onload = on_load;\n",
              "      element.onerror = on_error.bind(null, url);\n",
              "      element.async = false;\n",
              "      element.src = url;\n",
              "      if (url in hashes) {\n",
              "        element.crossOrigin = \"anonymous\";\n",
              "        element.integrity = \"sha384-\" + hashes[url];\n",
              "      }\n",
              "      console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n",
              "      document.head.appendChild(element);\n",
              "    }\n",
              "  };\n",
              "\n",
              "  function inject_raw_css(css) {\n",
              "    const element = document.createElement(\"style\");\n",
              "    element.appendChild(document.createTextNode(css));\n",
              "    document.body.appendChild(element);\n",
              "  }\n",
              "\n",
              "  \n",
              "  var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.3.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.3.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.3.3.min.js\"];\n",
              "  var css_urls = [];\n",
              "  \n",
              "\n",
              "  var inline_js = [\n",
              "    function(Bokeh) {\n",
              "      Bokeh.set_log_level(\"info\");\n",
              "    },\n",
              "    function(Bokeh) {\n",
              "    \n",
              "    \n",
              "    }\n",
              "  ];\n",
              "\n",
              "  function run_inline_js() {\n",
              "    \n",
              "    if (root.Bokeh !== undefined || force === true) {\n",
              "      \n",
              "    for (var i = 0; i \u003c inline_js.length; i++) {\n",
              "      inline_js[i].call(root, root.Bokeh);\n",
              "    }\n",
              "    } else if (Date.now() \u003c root._bokeh_timeout) {\n",
              "      setTimeout(run_inline_js, 100);\n",
              "    } else if (!root._bokeh_failed_load) {\n",
              "      console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n",
              "      root._bokeh_failed_load = true;\n",
              "    } else if (force !== true) {\n",
              "      var cell = $(document.getElementById(null)).parents('.cell').data().cell;\n",
              "      cell.output_area.append_execute_result(NB_LOAD_WARNING)\n",
              "    }\n",
              "\n",
              "  }\n",
              "\n",
              "  if (root._bokeh_is_loading === 0) {\n",
              "    console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n",
              "    run_inline_js();\n",
              "  } else {\n",
              "    load_libs(css_urls, js_urls, function() {\n",
              "      console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n",
              "      run_inline_js();\n",
              "    });\n",
              "  }\n",
              "}(window));"
            ],
            "application/vnd.bokehjs_load.v0+json": "\n(function(root) {\n  function now() {\n    return new Date();\n  }\n\n  var force = true;\n\n  if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n    root._bokeh_onload_callbacks = [];\n    root._bokeh_is_loading = undefined;\n  }\n\n  \n\n  \n  if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n    root._bokeh_timeout = Date.now() + 5000;\n    root._bokeh_failed_load = false;\n  }\n\n  var NB_LOAD_WARNING = {'data': {'text/html':\n     \"\u003cdiv style='background-color: #fdd'\u003e\\n\"+\n     \"\u003cp\u003e\\n\"+\n     \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n     \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n     \"\u003c/p\u003e\\n\"+\n     \"\u003cul\u003e\\n\"+\n     \"\u003cli\u003ere-rerun `output_notebook()` to attempt to load from CDN again, or\u003c/li\u003e\\n\"+\n     \"\u003cli\u003euse INLINE resources instead, as so:\u003c/li\u003e\\n\"+\n     \"\u003c/ul\u003e\\n\"+\n     \"\u003ccode\u003e\\n\"+\n     \"from bokeh.resources import INLINE\\n\"+\n     \"output_notebook(resources=INLINE)\\n\"+\n     \"\u003c/code\u003e\\n\"+\n     \"\u003c/div\u003e\"}};\n\n  function display_loaded() {\n    var el = document.getElementById(null);\n    if (el != null) {\n      el.textContent = \"BokehJS is loading...\";\n    }\n    if (root.Bokeh !== undefined) {\n      if (el != null) {\n        el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n      }\n    } else if (Date.now() \u003c root._bokeh_timeout) {\n      setTimeout(display_loaded, 100)\n    }\n  }\n\n\n  function run_callbacks() {\n    try {\n      root._bokeh_onload_callbacks.forEach(function(callback) {\n        if (callback != null)\n          callback();\n      });\n    } finally {\n      delete root._bokeh_onload_callbacks\n    }\n    console.debug(\"Bokeh: all callbacks have finished\");\n  }\n\n  function load_libs(css_urls, js_urls, callback) {\n    if (css_urls == null) css_urls = [];\n    if (js_urls == null) js_urls = [];\n\n    root._bokeh_onload_callbacks.push(callback);\n    if (root._bokeh_is_loading \u003e 0) {\n      console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n      return null;\n    }\n    if (js_urls == null || js_urls.length === 0) {\n      run_callbacks();\n      return null;\n    }\n    console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n    root._bokeh_is_loading = css_urls.length + js_urls.length;\n\n    function on_load() {\n      root._bokeh_is_loading--;\n      if (root._bokeh_is_loading === 0) {\n        console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n        run_callbacks()\n      }\n    }\n\n    function on_error(url) {\n      console.error(\"failed to load \" + url);\n    }\n\n    for (let i = 0; i \u003c css_urls.length; i++) {\n      const url = css_urls[i];\n      const element = document.createElement(\"link\");\n      element.onload = on_load;\n      element.onerror = on_error.bind(null, url);\n      element.rel = \"stylesheet\";\n      element.type = \"text/css\";\n      element.href = url;\n      console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n      document.body.appendChild(element);\n    }\n\n    const hashes = {\"https://cdn.bokeh.org/bokeh/release/bokeh-2.3.3.min.js\": \"dM3QQsP+wXdHg42wTqW85BjZQdLNNIXqlPw/BgKoExPmTG7ZLML4EGqLMfqHT6ON\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.3.3.min.js\": \"8x57I4YuIfu8XyZfFo0XVr2WAT8EK4rh/uDe3wF7YuW2FNUSNEpJbsPaB1nJ2fz2\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.3.3.min.js\": \"3QTqdz9LyAm2i0sG5XTePsHec3UHWwVsrOL68SYRoAXsafvfAyqtQ+h440+qIBhS\"};\n\n    for (let i = 0; i \u003c js_urls.length; i++) {\n      const url = js_urls[i];\n      const element = document.createElement('script');\n      element.onload = on_load;\n      element.onerror = on_error.bind(null, url);\n      element.async = false;\n      element.src = url;\n      if (url in hashes) {\n        element.crossOrigin = \"anonymous\";\n        element.integrity = \"sha384-\" + hashes[url];\n      }\n      console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n      document.head.appendChild(element);\n    }\n  };\n\n  function inject_raw_css(css) {\n    const element = document.createElement(\"style\");\n    element.appendChild(document.createTextNode(css));\n    document.body.appendChild(element);\n  }\n\n  \n  var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.3.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.3.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.3.3.min.js\"];\n  var css_urls = [];\n  \n\n  var inline_js = [\n    function(Bokeh) {\n      Bokeh.set_log_level(\"info\");\n    },\n    function(Bokeh) {\n    \n    \n    }\n  ];\n\n  function run_inline_js() {\n    \n    if (root.Bokeh !== undefined || force === true) {\n      \n    for (var i = 0; i \u003c inline_js.length; i++) {\n      inline_js[i].call(root, root.Bokeh);\n    }\n    } else if (Date.now() \u003c root._bokeh_timeout) {\n      setTimeout(run_inline_js, 100);\n    } else if (!root._bokeh_failed_load) {\n      console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n      root._bokeh_failed_load = true;\n    } else if (force !== true) {\n      var cell = $(document.getElementById(null)).parents('.cell').data().cell;\n      cell.output_area.append_execute_result(NB_LOAD_WARNING)\n    }\n\n  }\n\n  if (root._bokeh_is_loading === 0) {\n    console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n    run_inline_js();\n  } else {\n    load_libs(css_urls, js_urls, function() {\n      console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n      run_inline_js();\n    });\n  }\n}(window));"
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/html": [
              "\n",
              "\n",
              "\n",
              "\n",
              "\n",
              "\n",
              "  \u003cdiv class=\"bk-root\" id=\"01160b38-2c09-46cd-9d36-ec07fd637063\" data-root-id=\"1104\"\u003e\u003c/div\u003e\n"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "application/javascript": [
              "(function(root) {\n",
              "  function embed_document(root) {\n",
              "    \n",
              "  var docs_json = {\"1de6ba42-b891-4791-a48c-4b98cdd3cfa2\":{\"defs\":[],\"roots\":{\"references\":[{\"attributes\":{\"below\":[{\"id\":\"1113\"}],\"center\":[{\"id\":\"1116\"},{\"id\":\"1120\"}],\"height\":300,\"left\":[{\"id\":\"1117\"}],\"renderers\":[{\"id\":\"1138\"}],\"title\":{\"id\":\"1151\"},\"toolbar\":{\"id\":\"1128\"},\"width\":300,\"x_range\":{\"id\":\"1105\"},\"x_scale\":{\"id\":\"1109\"},\"y_range\":{\"id\":\"1107\"},\"y_scale\":{\"id\":\"1111\"}},\"id\":\"1104\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{\"data_source\":{\"id\":\"1135\"},\"glyph\":{\"id\":\"1136\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1137\"},\"view\":{\"id\":\"1139\"}},\"id\":\"1138\",\"type\":\"GlyphRenderer\"},{\"attributes\":{\"formatter\":{\"id\":\"1154\"},\"major_label_policy\":{\"id\":\"1155\"},\"ticker\":{\"id\":\"1118\"}},\"id\":\"1117\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1160\",\"type\":\"Selection\"},{\"attributes\":{\"source\":{\"id\":\"1135\"}},\"id\":\"1139\",\"type\":\"CDSView\"},{\"attributes\":{},\"id\":\"1151\",\"type\":\"Title\"},{\"attributes\":{\"axis\":{\"id\":\"1113\"},\"ticker\":null},\"id\":\"1116\",\"type\":\"Grid\"},{\"attributes\":{\"active_multi\":null,\"tools\":[{\"id\":\"1121\"},{\"id\":\"1122\"},{\"id\":\"1123\"},{\"id\":\"1124\"},{\"id\":\"1125\"},{\"id\":\"1126\"}]},\"id\":\"1128\",\"type\":\"Toolbar\"},{\"attributes\":{\"line_alpha\":0.1,\"line_color\":\"red\",\"line_dash\":[6],\"x\":{\"field\":\"x\"},\"y\":{\"field\":\"y\"}},\"id\":\"1137\",\"type\":\"Line\"},{\"attributes\":{},\"id\":\"1125\",\"type\":\"ResetTool\"},{\"attributes\":{},\"id\":\"1105\",\"type\":\"DataRange1d\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":0.5,\"fill_color\":\"lightgrey\",\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":1.0,\"line_color\":\"black\",\"line_dash\":[4,4],\"line_width\":2,\"right_units\":\"screen\",\"syncable\":false,\"top_units\":\"screen\"},\"id\":\"1127\",\"type\":\"BoxAnnotation\"},{\"attributes\":{},\"id\":\"1157\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1124\",\"type\":\"SaveTool\"},{\"attributes\":{},\"id\":\"1154\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"data\":{\"x\":[0,1,2,3,4,5,6,7,8,9],\"y\":[0,1,2,3,4,5,6,7,8,9]},\"selected\":{\"id\":\"1160\"},\"selection_policy\":{\"id\":\"1159\"}},\"id\":\"1135\",\"type\":\"ColumnDataSource\"},{\"attributes\":{},\"id\":\"1109\",\"type\":\"LinearScale\"},{\"attributes\":{\"overlay\":{\"id\":\"1127\"}},\"id\":\"1123\",\"type\":\"BoxZoomTool\"},{\"attributes\":{},\"id\":\"1107\",\"type\":\"DataRange1d\"},{\"attributes\":{\"line_color\":\"red\",\"line_dash\":[6],\"x\":{\"field\":\"x\"},\"y\":{\"field\":\"y\"}},\"id\":\"1136\",\"type\":\"Line\"},{\"attributes\":{},\"id\":\"1122\",\"type\":\"WheelZoomTool\"},{\"attributes\":{},\"id\":\"1121\",\"type\":\"PanTool\"},{\"attributes\":{},\"id\":\"1111\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1158\",\"type\":\"AllLabels\"},{\"attributes\":{},\"id\":\"1126\",\"type\":\"HelpTool\"},{\"attributes\":{},\"id\":\"1159\",\"type\":\"UnionRenderers\"},{\"attributes\":{\"axis\":{\"id\":\"1117\"},\"dimension\":1,\"ticker\":null},\"id\":\"1120\",\"type\":\"Grid\"},{\"attributes\":{\"formatter\":{\"id\":\"1157\"},\"major_label_policy\":{\"id\":\"1158\"},\"ticker\":{\"id\":\"1114\"}},\"id\":\"1113\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1155\",\"type\":\"AllLabels\"},{\"attributes\":{},\"id\":\"1118\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1114\",\"type\":\"BasicTicker\"}],\"root_ids\":[\"1104\"]},\"title\":\"Bokeh Application\",\"version\":\"2.3.3\"}};\n",
              "  var render_items = [{\"docid\":\"1de6ba42-b891-4791-a48c-4b98cdd3cfa2\",\"root_ids\":[\"1104\"],\"roots\":{\"1104\":\"01160b38-2c09-46cd-9d36-ec07fd637063\"}}];\n",
              "  root.Bokeh.embed.embed_items_notebook(docs_json, render_items);\n",
              "\n",
              "  }\n",
              "  if (root.Bokeh !== undefined) {\n",
              "    embed_document(root);\n",
              "  } else {\n",
              "    var attempts = 0;\n",
              "    var timer = setInterval(function(root) {\n",
              "      if (root.Bokeh !== undefined) {\n",
              "        clearInterval(timer);\n",
              "        embed_document(root);\n",
              "      } else {\n",
              "        attempts++;\n",
              "        if (attempts \u003e 100) {\n",
              "          clearInterval(timer);\n",
              "          console.log(\"Bokeh: ERROR: Unable to run BokehJS code because BokehJS library is missing\");\n",
              "        }\n",
              "      }\n",
              "    }, 10, root)\n",
              "  }\n",
              "})(window);"
            ],
            "application/vnd.bokehjs_exec.v0+json": ""
          },
          "metadata": {
            "application/vnd.bokehjs_exec.v0+json": {
              "id": "1104"
            }
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Plot numbers as a line.\n",
        "numbers = range(10)\n",
        "\n",
        "p = figure(plot_width=300, plot_height=300)\n",
        "p.line(x=numbers, y=numbers, line_color='red', line_dash='dashed')\n",
        "show(p)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "619sylvOHrUW"
      },
      "source": [
        "Remaking our scatter plot:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nInMesbUQzAR"
      },
      "outputs": [
        {
          "data": {
            "application/javascript": [
              "\n",
              "(function(root) {\n",
              "  function now() {\n",
              "    return new Date();\n",
              "  }\n",
              "\n",
              "  var force = true;\n",
              "\n",
              "  if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n",
              "    root._bokeh_onload_callbacks = [];\n",
              "    root._bokeh_is_loading = undefined;\n",
              "  }\n",
              "\n",
              "  var JS_MIME_TYPE = 'application/javascript';\n",
              "  var HTML_MIME_TYPE = 'text/html';\n",
              "  var EXEC_MIME_TYPE = 'application/vnd.bokehjs_exec.v0+json';\n",
              "  var CLASS_NAME = 'output_bokeh rendered_html';\n",
              "\n",
              "  /**\n",
              "   * Render data to the DOM node\n",
              "   */\n",
              "  function render(props, node) {\n",
              "    var script = document.createElement(\"script\");\n",
              "    node.appendChild(script);\n",
              "  }\n",
              "\n",
              "  /**\n",
              "   * Handle when an output is cleared or removed\n",
              "   */\n",
              "  function handleClearOutput(event, handle) {\n",
              "    var cell = handle.cell;\n",
              "\n",
              "    var id = cell.output_area._bokeh_element_id;\n",
              "    var server_id = cell.output_area._bokeh_server_id;\n",
              "    // Clean up Bokeh references\n",
              "    if (id != null \u0026\u0026 id in Bokeh.index) {\n",
              "      Bokeh.index[id].model.document.clear();\n",
              "      delete Bokeh.index[id];\n",
              "    }\n",
              "\n",
              "    if (server_id !== undefined) {\n",
              "      // Clean up Bokeh references\n",
              "      var cmd = \"from bokeh.io.state import curstate; print(curstate().uuid_to_server['\" + server_id + \"'].get_sessions()[0].document.roots[0]._id)\";\n",
              "      cell.notebook.kernel.execute(cmd, {\n",
              "        iopub: {\n",
              "          output: function(msg) {\n",
              "            var id = msg.content.text.trim();\n",
              "            if (id in Bokeh.index) {\n",
              "              Bokeh.index[id].model.document.clear();\n",
              "              delete Bokeh.index[id];\n",
              "            }\n",
              "          }\n",
              "        }\n",
              "      });\n",
              "      // Destroy server and session\n",
              "      var cmd = \"import bokeh.io.notebook as ion; ion.destroy_server('\" + server_id + \"')\";\n",
              "      cell.notebook.kernel.execute(cmd);\n",
              "    }\n",
              "  }\n",
              "\n",
              "  /**\n",
              "   * Handle when a new output is added\n",
              "   */\n",
              "  function handleAddOutput(event, handle) {\n",
              "    var output_area = handle.output_area;\n",
              "    var output = handle.output;\n",
              "\n",
              "    // limit handleAddOutput to display_data with EXEC_MIME_TYPE content only\n",
              "    if ((output.output_type != \"display_data\") || (!Object.prototype.hasOwnProperty.call(output.data, EXEC_MIME_TYPE))) {\n",
              "      return\n",
              "    }\n",
              "\n",
              "    var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n",
              "\n",
              "    if (output.metadata[EXEC_MIME_TYPE][\"id\"] !== undefined) {\n",
              "      toinsert[toinsert.length - 1].firstChild.textContent = output.data[JS_MIME_TYPE];\n",
              "      // store reference to embed id on output_area\n",
              "      output_area._bokeh_element_id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n",
              "    }\n",
              "    if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n",
              "      var bk_div = document.createElement(\"div\");\n",
              "      bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n",
              "      var script_attrs = bk_div.children[0].attributes;\n",
              "      for (var i = 0; i \u003c script_attrs.length; i++) {\n",
              "        toinsert[toinsert.length - 1].firstChild.setAttribute(script_attrs[i].name, script_attrs[i].value);\n",
              "        toinsert[toinsert.length - 1].firstChild.textContent = bk_div.children[0].textContent\n",
              "      }\n",
              "      // store reference to server id on output_area\n",
              "      output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n",
              "    }\n",
              "  }\n",
              "\n",
              "  function register_renderer(events, OutputArea) {\n",
              "\n",
              "    function append_mime(data, metadata, element) {\n",
              "      // create a DOM node to render to\n",
              "      var toinsert = this.create_output_subarea(\n",
              "        metadata,\n",
              "        CLASS_NAME,\n",
              "        EXEC_MIME_TYPE\n",
              "      );\n",
              "      this.keyboard_manager.register_events(toinsert);\n",
              "      // Render to node\n",
              "      var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n",
              "      render(props, toinsert[toinsert.length - 1]);\n",
              "      element.append(toinsert);\n",
              "      return toinsert\n",
              "    }\n",
              "\n",
              "    /* Handle when an output is cleared or removed */\n",
              "    events.on('clear_output.CodeCell', handleClearOutput);\n",
              "    events.on('delete.Cell', handleClearOutput);\n",
              "\n",
              "    /* Handle when a new output is added */\n",
              "    events.on('output_added.OutputArea', handleAddOutput);\n",
              "\n",
              "    /**\n",
              "     * Register the mime type and append_mime function with output_area\n",
              "     */\n",
              "    OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n",
              "      /* Is output safe? */\n",
              "      safe: true,\n",
              "      /* Index of renderer in `output_area.display_order` */\n",
              "      index: 0\n",
              "    });\n",
              "  }\n",
              "\n",
              "  // register the mime type if in Jupyter Notebook environment and previously unregistered\n",
              "  if (root.Jupyter !== undefined) {\n",
              "    var events = require('base/js/events');\n",
              "    var OutputArea = require('notebook/js/outputarea').OutputArea;\n",
              "\n",
              "    if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n",
              "      register_renderer(events, OutputArea);\n",
              "    }\n",
              "  }\n",
              "\n",
              "  \n",
              "  if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n",
              "    root._bokeh_timeout = Date.now() + 5000;\n",
              "    root._bokeh_failed_load = false;\n",
              "  }\n",
              "\n",
              "  var NB_LOAD_WARNING = {'data': {'text/html':\n",
              "     \"\u003cdiv style='background-color: #fdd'\u003e\\n\"+\n",
              "     \"\u003cp\u003e\\n\"+\n",
              "     \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n",
              "     \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n",
              "     \"\u003c/p\u003e\\n\"+\n",
              "     \"\u003cul\u003e\\n\"+\n",
              "     \"\u003cli\u003ere-rerun `output_notebook()` to attempt to load from CDN again, or\u003c/li\u003e\\n\"+\n",
              "     \"\u003cli\u003euse INLINE resources instead, as so:\u003c/li\u003e\\n\"+\n",
              "     \"\u003c/ul\u003e\\n\"+\n",
              "     \"\u003ccode\u003e\\n\"+\n",
              "     \"from bokeh.resources import INLINE\\n\"+\n",
              "     \"output_notebook(resources=INLINE)\\n\"+\n",
              "     \"\u003c/code\u003e\\n\"+\n",
              "     \"\u003c/div\u003e\"}};\n",
              "\n",
              "  function display_loaded() {\n",
              "    var el = document.getElementById(null);\n",
              "    if (el != null) {\n",
              "      el.textContent = \"BokehJS is loading...\";\n",
              "    }\n",
              "    if (root.Bokeh !== undefined) {\n",
              "      if (el != null) {\n",
              "        el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n",
              "      }\n",
              "    } else if (Date.now() \u003c root._bokeh_timeout) {\n",
              "      setTimeout(display_loaded, 100)\n",
              "    }\n",
              "  }\n",
              "\n",
              "\n",
              "  function run_callbacks() {\n",
              "    try {\n",
              "      root._bokeh_onload_callbacks.forEach(function(callback) {\n",
              "        if (callback != null)\n",
              "          callback();\n",
              "      });\n",
              "    } finally {\n",
              "      delete root._bokeh_onload_callbacks\n",
              "    }\n",
              "    console.debug(\"Bokeh: all callbacks have finished\");\n",
              "  }\n",
              "\n",
              "  function load_libs(css_urls, js_urls, callback) {\n",
              "    if (css_urls == null) css_urls = [];\n",
              "    if (js_urls == null) js_urls = [];\n",
              "\n",
              "    root._bokeh_onload_callbacks.push(callback);\n",
              "    if (root._bokeh_is_loading \u003e 0) {\n",
              "      console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n",
              "      return null;\n",
              "    }\n",
              "    if (js_urls == null || js_urls.length === 0) {\n",
              "      run_callbacks();\n",
              "      return null;\n",
              "    }\n",
              "    console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n",
              "    root._bokeh_is_loading = css_urls.length + js_urls.length;\n",
              "\n",
              "    function on_load() {\n",
              "      root._bokeh_is_loading--;\n",
              "      if (root._bokeh_is_loading === 0) {\n",
              "        console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n",
              "        run_callbacks()\n",
              "      }\n",
              "    }\n",
              "\n",
              "    function on_error(url) {\n",
              "      console.error(\"failed to load \" + url);\n",
              "    }\n",
              "\n",
              "    for (let i = 0; i \u003c css_urls.length; i++) {\n",
              "      const url = css_urls[i];\n",
              "      const element = document.createElement(\"link\");\n",
              "      element.onload = on_load;\n",
              "      element.onerror = on_error.bind(null, url);\n",
              "      element.rel = \"stylesheet\";\n",
              "      element.type = \"text/css\";\n",
              "      element.href = url;\n",
              "      console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n",
              "      document.body.appendChild(element);\n",
              "    }\n",
              "\n",
              "    const hashes = {\"https://cdn.bokeh.org/bokeh/release/bokeh-2.3.3.min.js\": \"dM3QQsP+wXdHg42wTqW85BjZQdLNNIXqlPw/BgKoExPmTG7ZLML4EGqLMfqHT6ON\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.3.3.min.js\": \"8x57I4YuIfu8XyZfFo0XVr2WAT8EK4rh/uDe3wF7YuW2FNUSNEpJbsPaB1nJ2fz2\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.3.3.min.js\": \"3QTqdz9LyAm2i0sG5XTePsHec3UHWwVsrOL68SYRoAXsafvfAyqtQ+h440+qIBhS\"};\n",
              "\n",
              "    for (let i = 0; i \u003c js_urls.length; i++) {\n",
              "      const url = js_urls[i];\n",
              "      const element = document.createElement('script');\n",
              "      element.onload = on_load;\n",
              "      element.onerror = on_error.bind(null, url);\n",
              "      element.async = false;\n",
              "      element.src = url;\n",
              "      if (url in hashes) {\n",
              "        element.crossOrigin = \"anonymous\";\n",
              "        element.integrity = \"sha384-\" + hashes[url];\n",
              "      }\n",
              "      console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n",
              "      document.head.appendChild(element);\n",
              "    }\n",
              "  };\n",
              "\n",
              "  function inject_raw_css(css) {\n",
              "    const element = document.createElement(\"style\");\n",
              "    element.appendChild(document.createTextNode(css));\n",
              "    document.body.appendChild(element);\n",
              "  }\n",
              "\n",
              "  \n",
              "  var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.3.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.3.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.3.3.min.js\"];\n",
              "  var css_urls = [];\n",
              "  \n",
              "\n",
              "  var inline_js = [\n",
              "    function(Bokeh) {\n",
              "      Bokeh.set_log_level(\"info\");\n",
              "    },\n",
              "    function(Bokeh) {\n",
              "    \n",
              "    \n",
              "    }\n",
              "  ];\n",
              "\n",
              "  function run_inline_js() {\n",
              "    \n",
              "    if (root.Bokeh !== undefined || force === true) {\n",
              "      \n",
              "    for (var i = 0; i \u003c inline_js.length; i++) {\n",
              "      inline_js[i].call(root, root.Bokeh);\n",
              "    }\n",
              "    } else if (Date.now() \u003c root._bokeh_timeout) {\n",
              "      setTimeout(run_inline_js, 100);\n",
              "    } else if (!root._bokeh_failed_load) {\n",
              "      console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n",
              "      root._bokeh_failed_load = true;\n",
              "    } else if (force !== true) {\n",
              "      var cell = $(document.getElementById(null)).parents('.cell').data().cell;\n",
              "      cell.output_area.append_execute_result(NB_LOAD_WARNING)\n",
              "    }\n",
              "\n",
              "  }\n",
              "\n",
              "  if (root._bokeh_is_loading === 0) {\n",
              "    console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n",
              "    run_inline_js();\n",
              "  } else {\n",
              "    load_libs(css_urls, js_urls, function() {\n",
              "      console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n",
              "      run_inline_js();\n",
              "    });\n",
              "  }\n",
              "}(window));"
            ],
            "application/vnd.bokehjs_load.v0+json": "\n(function(root) {\n  function now() {\n    return new Date();\n  }\n\n  var force = true;\n\n  if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n    root._bokeh_onload_callbacks = [];\n    root._bokeh_is_loading = undefined;\n  }\n\n  \n\n  \n  if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n    root._bokeh_timeout = Date.now() + 5000;\n    root._bokeh_failed_load = false;\n  }\n\n  var NB_LOAD_WARNING = {'data': {'text/html':\n     \"\u003cdiv style='background-color: #fdd'\u003e\\n\"+\n     \"\u003cp\u003e\\n\"+\n     \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n     \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n     \"\u003c/p\u003e\\n\"+\n     \"\u003cul\u003e\\n\"+\n     \"\u003cli\u003ere-rerun `output_notebook()` to attempt to load from CDN again, or\u003c/li\u003e\\n\"+\n     \"\u003cli\u003euse INLINE resources instead, as so:\u003c/li\u003e\\n\"+\n     \"\u003c/ul\u003e\\n\"+\n     \"\u003ccode\u003e\\n\"+\n     \"from bokeh.resources import INLINE\\n\"+\n     \"output_notebook(resources=INLINE)\\n\"+\n     \"\u003c/code\u003e\\n\"+\n     \"\u003c/div\u003e\"}};\n\n  function display_loaded() {\n    var el = document.getElementById(null);\n    if (el != null) {\n      el.textContent = \"BokehJS is loading...\";\n    }\n    if (root.Bokeh !== undefined) {\n      if (el != null) {\n        el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n      }\n    } else if (Date.now() \u003c root._bokeh_timeout) {\n      setTimeout(display_loaded, 100)\n    }\n  }\n\n\n  function run_callbacks() {\n    try {\n      root._bokeh_onload_callbacks.forEach(function(callback) {\n        if (callback != null)\n          callback();\n      });\n    } finally {\n      delete root._bokeh_onload_callbacks\n    }\n    console.debug(\"Bokeh: all callbacks have finished\");\n  }\n\n  function load_libs(css_urls, js_urls, callback) {\n    if (css_urls == null) css_urls = [];\n    if (js_urls == null) js_urls = [];\n\n    root._bokeh_onload_callbacks.push(callback);\n    if (root._bokeh_is_loading \u003e 0) {\n      console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n      return null;\n    }\n    if (js_urls == null || js_urls.length === 0) {\n      run_callbacks();\n      return null;\n    }\n    console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n    root._bokeh_is_loading = css_urls.length + js_urls.length;\n\n    function on_load() {\n      root._bokeh_is_loading--;\n      if (root._bokeh_is_loading === 0) {\n        console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n        run_callbacks()\n      }\n    }\n\n    function on_error(url) {\n      console.error(\"failed to load \" + url);\n    }\n\n    for (let i = 0; i \u003c css_urls.length; i++) {\n      const url = css_urls[i];\n      const element = document.createElement(\"link\");\n      element.onload = on_load;\n      element.onerror = on_error.bind(null, url);\n      element.rel = \"stylesheet\";\n      element.type = \"text/css\";\n      element.href = url;\n      console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n      document.body.appendChild(element);\n    }\n\n    const hashes = {\"https://cdn.bokeh.org/bokeh/release/bokeh-2.3.3.min.js\": \"dM3QQsP+wXdHg42wTqW85BjZQdLNNIXqlPw/BgKoExPmTG7ZLML4EGqLMfqHT6ON\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.3.3.min.js\": \"8x57I4YuIfu8XyZfFo0XVr2WAT8EK4rh/uDe3wF7YuW2FNUSNEpJbsPaB1nJ2fz2\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.3.3.min.js\": \"3QTqdz9LyAm2i0sG5XTePsHec3UHWwVsrOL68SYRoAXsafvfAyqtQ+h440+qIBhS\"};\n\n    for (let i = 0; i \u003c js_urls.length; i++) {\n      const url = js_urls[i];\n      const element = document.createElement('script');\n      element.onload = on_load;\n      element.onerror = on_error.bind(null, url);\n      element.async = false;\n      element.src = url;\n      if (url in hashes) {\n        element.crossOrigin = \"anonymous\";\n        element.integrity = \"sha384-\" + hashes[url];\n      }\n      console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n      document.head.appendChild(element);\n    }\n  };\n\n  function inject_raw_css(css) {\n    const element = document.createElement(\"style\");\n    element.appendChild(document.createTextNode(css));\n    document.body.appendChild(element);\n  }\n\n  \n  var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.3.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.3.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.3.3.min.js\"];\n  var css_urls = [];\n  \n\n  var inline_js = [\n    function(Bokeh) {\n      Bokeh.set_log_level(\"info\");\n    },\n    function(Bokeh) {\n    \n    \n    }\n  ];\n\n  function run_inline_js() {\n    \n    if (root.Bokeh !== undefined || force === true) {\n      \n    for (var i = 0; i \u003c inline_js.length; i++) {\n      inline_js[i].call(root, root.Bokeh);\n    }\n    } else if (Date.now() \u003c root._bokeh_timeout) {\n      setTimeout(run_inline_js, 100);\n    } else if (!root._bokeh_failed_load) {\n      console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n      root._bokeh_failed_load = true;\n    } else if (force !== true) {\n      var cell = $(document.getElementById(null)).parents('.cell').data().cell;\n      cell.output_area.append_execute_result(NB_LOAD_WARNING)\n    }\n\n  }\n\n  if (root._bokeh_is_loading === 0) {\n    console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n    run_inline_js();\n  } else {\n    load_libs(css_urls, js_urls, function() {\n      console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n      run_inline_js();\n    });\n  }\n}(window));"
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/html": [
              "\n",
              "\n",
              "\n",
              "\n",
              "\n",
              "\n",
              "  \u003cdiv class=\"bk-root\" id=\"8971e9fc-aa5b-4aa9-aa69-4499ffea0786\" data-root-id=\"1217\"\u003e\u003c/div\u003e\n"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "application/javascript": [
              "(function(root) {\n",
              "  function embed_document(root) {\n",
              "    \n",
              "  var docs_json = {\"23f08d1f-61cb-4032-b5b6-44599312b788\":{\"defs\":[],\"roots\":{\"references\":[{\"attributes\":{\"below\":[{\"id\":\"1226\"}],\"center\":[{\"id\":\"1229\"},{\"id\":\"1233\"}],\"height\":300,\"left\":[{\"id\":\"1230\"}],\"renderers\":[{\"id\":\"1251\"}],\"title\":{\"id\":\"1275\"},\"toolbar\":{\"id\":\"1241\"},\"width\":300,\"x_range\":{\"id\":\"1218\"},\"x_scale\":{\"id\":\"1222\"},\"y_range\":{\"id\":\"1220\"},\"y_scale\":{\"id\":\"1224\"}},\"id\":\"1217\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{\"axis\":{\"id\":\"1230\"},\"dimension\":1,\"ticker\":null},\"id\":\"1233\",\"type\":\"Grid\"},{\"attributes\":{\"formatter\":{\"id\":\"1278\"},\"major_label_policy\":{\"id\":\"1279\"},\"ticker\":{\"id\":\"1231\"}},\"id\":\"1230\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1283\",\"type\":\"UnionRenderers\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":0.5,\"fill_color\":\"lightgrey\",\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":1.0,\"line_color\":\"black\",\"line_dash\":[4,4],\"line_width\":2,\"right_units\":\"screen\",\"syncable\":false,\"top_units\":\"screen\"},\"id\":\"1240\",\"type\":\"BoxAnnotation\"},{\"attributes\":{\"data\":{\"x\":[0,1,2,3,4,5,6,7,8,9],\"y\":[0,1,4,9,16,25,36,49,64,81]},\"selected\":{\"id\":\"1284\"},\"selection_policy\":{\"id\":\"1283\"}},\"id\":\"1248\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"source\":{\"id\":\"1248\"}},\"id\":\"1252\",\"type\":\"CDSView\"},{\"attributes\":{},\"id\":\"1234\",\"type\":\"PanTool\"},{\"attributes\":{},\"id\":\"1218\",\"type\":\"DataRange1d\"},{\"attributes\":{\"fill_color\":{\"value\":\"#1f77b4\"},\"line_color\":{\"value\":\"#1f77b4\"},\"x\":{\"field\":\"x\"},\"y\":{\"field\":\"y\"}},\"id\":\"1249\",\"type\":\"Scatter\"},{\"attributes\":{},\"id\":\"1235\",\"type\":\"WheelZoomTool\"},{\"attributes\":{},\"id\":\"1284\",\"type\":\"Selection\"},{\"attributes\":{\"overlay\":{\"id\":\"1240\"}},\"id\":\"1236\",\"type\":\"BoxZoomTool\"},{\"attributes\":{},\"id\":\"1222\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1237\",\"type\":\"SaveTool\"},{\"attributes\":{\"data_source\":{\"id\":\"1248\"},\"glyph\":{\"id\":\"1249\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1250\"},\"view\":{\"id\":\"1252\"}},\"id\":\"1251\",\"type\":\"GlyphRenderer\"},{\"attributes\":{},\"id\":\"1238\",\"type\":\"ResetTool\"},{\"attributes\":{},\"id\":\"1220\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1278\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1239\",\"type\":\"HelpTool\"},{\"attributes\":{},\"id\":\"1224\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1275\",\"type\":\"Title\"},{\"attributes\":{\"active_multi\":null,\"tools\":[{\"id\":\"1234\"},{\"id\":\"1235\"},{\"id\":\"1236\"},{\"id\":\"1237\"},{\"id\":\"1238\"},{\"id\":\"1239\"}]},\"id\":\"1241\",\"type\":\"Toolbar\"},{\"attributes\":{},\"id\":\"1282\",\"type\":\"AllLabels\"},{\"attributes\":{},\"id\":\"1281\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"formatter\":{\"id\":\"1281\"},\"major_label_policy\":{\"id\":\"1282\"},\"ticker\":{\"id\":\"1227\"}},\"id\":\"1226\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1231\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1279\",\"type\":\"AllLabels\"},{\"attributes\":{},\"id\":\"1227\",\"type\":\"BasicTicker\"},{\"attributes\":{\"axis\":{\"id\":\"1226\"},\"ticker\":null},\"id\":\"1229\",\"type\":\"Grid\"},{\"attributes\":{\"fill_alpha\":{\"value\":0.1},\"fill_color\":{\"value\":\"#1f77b4\"},\"line_alpha\":{\"value\":0.1},\"line_color\":{\"value\":\"#1f77b4\"},\"x\":{\"field\":\"x\"},\"y\":{\"field\":\"y\"}},\"id\":\"1250\",\"type\":\"Scatter\"}],\"root_ids\":[\"1217\"]},\"title\":\"Bokeh Application\",\"version\":\"2.3.3\"}};\n",
              "  var render_items = [{\"docid\":\"23f08d1f-61cb-4032-b5b6-44599312b788\",\"root_ids\":[\"1217\"],\"roots\":{\"1217\":\"8971e9fc-aa5b-4aa9-aa69-4499ffea0786\"}}];\n",
              "  root.Bokeh.embed.embed_items_notebook(docs_json, render_items);\n",
              "\n",
              "  }\n",
              "  if (root.Bokeh !== undefined) {\n",
              "    embed_document(root);\n",
              "  } else {\n",
              "    var attempts = 0;\n",
              "    var timer = setInterval(function(root) {\n",
              "      if (root.Bokeh !== undefined) {\n",
              "        clearInterval(timer);\n",
              "        embed_document(root);\n",
              "      } else {\n",
              "        attempts++;\n",
              "        if (attempts \u003e 100) {\n",
              "          clearInterval(timer);\n",
              "          console.log(\"Bokeh: ERROR: Unable to run BokehJS code because BokehJS library is missing\");\n",
              "        }\n",
              "      }\n",
              "    }, 10, root)\n",
              "  }\n",
              "})(window);"
            ],
            "application/vnd.bokehjs_exec.v0+json": ""
          },
          "metadata": {
            "application/vnd.bokehjs_exec.v0+json": {
              "id": "1217"
            }
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Plot a list of numbers as a scatter plot.\n",
        "x = range(10)\n",
        "y = [v ** 2 for v in x]\n",
        "\n",
        "p = figure(plot_width=300, plot_height=300)\n",
        "p.scatter(x=x, y=y)\n",
        "show(p)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "anq_RDHQRCvn"
      },
      "outputs": [
        {
          "data": {
            "application/javascript": [
              "\n",
              "(function(root) {\n",
              "  function now() {\n",
              "    return new Date();\n",
              "  }\n",
              "\n",
              "  var force = true;\n",
              "\n",
              "  if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n",
              "    root._bokeh_onload_callbacks = [];\n",
              "    root._bokeh_is_loading = undefined;\n",
              "  }\n",
              "\n",
              "  var JS_MIME_TYPE = 'application/javascript';\n",
              "  var HTML_MIME_TYPE = 'text/html';\n",
              "  var EXEC_MIME_TYPE = 'application/vnd.bokehjs_exec.v0+json';\n",
              "  var CLASS_NAME = 'output_bokeh rendered_html';\n",
              "\n",
              "  /**\n",
              "   * Render data to the DOM node\n",
              "   */\n",
              "  function render(props, node) {\n",
              "    var script = document.createElement(\"script\");\n",
              "    node.appendChild(script);\n",
              "  }\n",
              "\n",
              "  /**\n",
              "   * Handle when an output is cleared or removed\n",
              "   */\n",
              "  function handleClearOutput(event, handle) {\n",
              "    var cell = handle.cell;\n",
              "\n",
              "    var id = cell.output_area._bokeh_element_id;\n",
              "    var server_id = cell.output_area._bokeh_server_id;\n",
              "    // Clean up Bokeh references\n",
              "    if (id != null \u0026\u0026 id in Bokeh.index) {\n",
              "      Bokeh.index[id].model.document.clear();\n",
              "      delete Bokeh.index[id];\n",
              "    }\n",
              "\n",
              "    if (server_id !== undefined) {\n",
              "      // Clean up Bokeh references\n",
              "      var cmd = \"from bokeh.io.state import curstate; print(curstate().uuid_to_server['\" + server_id + \"'].get_sessions()[0].document.roots[0]._id)\";\n",
              "      cell.notebook.kernel.execute(cmd, {\n",
              "        iopub: {\n",
              "          output: function(msg) {\n",
              "            var id = msg.content.text.trim();\n",
              "            if (id in Bokeh.index) {\n",
              "              Bokeh.index[id].model.document.clear();\n",
              "              delete Bokeh.index[id];\n",
              "            }\n",
              "          }\n",
              "        }\n",
              "      });\n",
              "      // Destroy server and session\n",
              "      var cmd = \"import bokeh.io.notebook as ion; ion.destroy_server('\" + server_id + \"')\";\n",
              "      cell.notebook.kernel.execute(cmd);\n",
              "    }\n",
              "  }\n",
              "\n",
              "  /**\n",
              "   * Handle when a new output is added\n",
              "   */\n",
              "  function handleAddOutput(event, handle) {\n",
              "    var output_area = handle.output_area;\n",
              "    var output = handle.output;\n",
              "\n",
              "    // limit handleAddOutput to display_data with EXEC_MIME_TYPE content only\n",
              "    if ((output.output_type != \"display_data\") || (!Object.prototype.hasOwnProperty.call(output.data, EXEC_MIME_TYPE))) {\n",
              "      return\n",
              "    }\n",
              "\n",
              "    var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n",
              "\n",
              "    if (output.metadata[EXEC_MIME_TYPE][\"id\"] !== undefined) {\n",
              "      toinsert[toinsert.length - 1].firstChild.textContent = output.data[JS_MIME_TYPE];\n",
              "      // store reference to embed id on output_area\n",
              "      output_area._bokeh_element_id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n",
              "    }\n",
              "    if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n",
              "      var bk_div = document.createElement(\"div\");\n",
              "      bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n",
              "      var script_attrs = bk_div.children[0].attributes;\n",
              "      for (var i = 0; i \u003c script_attrs.length; i++) {\n",
              "        toinsert[toinsert.length - 1].firstChild.setAttribute(script_attrs[i].name, script_attrs[i].value);\n",
              "        toinsert[toinsert.length - 1].firstChild.textContent = bk_div.children[0].textContent\n",
              "      }\n",
              "      // store reference to server id on output_area\n",
              "      output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n",
              "    }\n",
              "  }\n",
              "\n",
              "  function register_renderer(events, OutputArea) {\n",
              "\n",
              "    function append_mime(data, metadata, element) {\n",
              "      // create a DOM node to render to\n",
              "      var toinsert = this.create_output_subarea(\n",
              "        metadata,\n",
              "        CLASS_NAME,\n",
              "        EXEC_MIME_TYPE\n",
              "      );\n",
              "      this.keyboard_manager.register_events(toinsert);\n",
              "      // Render to node\n",
              "      var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n",
              "      render(props, toinsert[toinsert.length - 1]);\n",
              "      element.append(toinsert);\n",
              "      return toinsert\n",
              "    }\n",
              "\n",
              "    /* Handle when an output is cleared or removed */\n",
              "    events.on('clear_output.CodeCell', handleClearOutput);\n",
              "    events.on('delete.Cell', handleClearOutput);\n",
              "\n",
              "    /* Handle when a new output is added */\n",
              "    events.on('output_added.OutputArea', handleAddOutput);\n",
              "\n",
              "    /**\n",
              "     * Register the mime type and append_mime function with output_area\n",
              "     */\n",
              "    OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n",
              "      /* Is output safe? */\n",
              "      safe: true,\n",
              "      /* Index of renderer in `output_area.display_order` */\n",
              "      index: 0\n",
              "    });\n",
              "  }\n",
              "\n",
              "  // register the mime type if in Jupyter Notebook environment and previously unregistered\n",
              "  if (root.Jupyter !== undefined) {\n",
              "    var events = require('base/js/events');\n",
              "    var OutputArea = require('notebook/js/outputarea').OutputArea;\n",
              "\n",
              "    if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n",
              "      register_renderer(events, OutputArea);\n",
              "    }\n",
              "  }\n",
              "\n",
              "  \n",
              "  if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n",
              "    root._bokeh_timeout = Date.now() + 5000;\n",
              "    root._bokeh_failed_load = false;\n",
              "  }\n",
              "\n",
              "  var NB_LOAD_WARNING = {'data': {'text/html':\n",
              "     \"\u003cdiv style='background-color: #fdd'\u003e\\n\"+\n",
              "     \"\u003cp\u003e\\n\"+\n",
              "     \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n",
              "     \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n",
              "     \"\u003c/p\u003e\\n\"+\n",
              "     \"\u003cul\u003e\\n\"+\n",
              "     \"\u003cli\u003ere-rerun `output_notebook()` to attempt to load from CDN again, or\u003c/li\u003e\\n\"+\n",
              "     \"\u003cli\u003euse INLINE resources instead, as so:\u003c/li\u003e\\n\"+\n",
              "     \"\u003c/ul\u003e\\n\"+\n",
              "     \"\u003ccode\u003e\\n\"+\n",
              "     \"from bokeh.resources import INLINE\\n\"+\n",
              "     \"output_notebook(resources=INLINE)\\n\"+\n",
              "     \"\u003c/code\u003e\\n\"+\n",
              "     \"\u003c/div\u003e\"}};\n",
              "\n",
              "  function display_loaded() {\n",
              "    var el = document.getElementById(null);\n",
              "    if (el != null) {\n",
              "      el.textContent = \"BokehJS is loading...\";\n",
              "    }\n",
              "    if (root.Bokeh !== undefined) {\n",
              "      if (el != null) {\n",
              "        el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n",
              "      }\n",
              "    } else if (Date.now() \u003c root._bokeh_timeout) {\n",
              "      setTimeout(display_loaded, 100)\n",
              "    }\n",
              "  }\n",
              "\n",
              "\n",
              "  function run_callbacks() {\n",
              "    try {\n",
              "      root._bokeh_onload_callbacks.forEach(function(callback) {\n",
              "        if (callback != null)\n",
              "          callback();\n",
              "      });\n",
              "    } finally {\n",
              "      delete root._bokeh_onload_callbacks\n",
              "    }\n",
              "    console.debug(\"Bokeh: all callbacks have finished\");\n",
              "  }\n",
              "\n",
              "  function load_libs(css_urls, js_urls, callback) {\n",
              "    if (css_urls == null) css_urls = [];\n",
              "    if (js_urls == null) js_urls = [];\n",
              "\n",
              "    root._bokeh_onload_callbacks.push(callback);\n",
              "    if (root._bokeh_is_loading \u003e 0) {\n",
              "      console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n",
              "      return null;\n",
              "    }\n",
              "    if (js_urls == null || js_urls.length === 0) {\n",
              "      run_callbacks();\n",
              "      return null;\n",
              "    }\n",
              "    console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n",
              "    root._bokeh_is_loading = css_urls.length + js_urls.length;\n",
              "\n",
              "    function on_load() {\n",
              "      root._bokeh_is_loading--;\n",
              "      if (root._bokeh_is_loading === 0) {\n",
              "        console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n",
              "        run_callbacks()\n",
              "      }\n",
              "    }\n",
              "\n",
              "    function on_error(url) {\n",
              "      console.error(\"failed to load \" + url);\n",
              "    }\n",
              "\n",
              "    for (let i = 0; i \u003c css_urls.length; i++) {\n",
              "      const url = css_urls[i];\n",
              "      const element = document.createElement(\"link\");\n",
              "      element.onload = on_load;\n",
              "      element.onerror = on_error.bind(null, url);\n",
              "      element.rel = \"stylesheet\";\n",
              "      element.type = \"text/css\";\n",
              "      element.href = url;\n",
              "      console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n",
              "      document.body.appendChild(element);\n",
              "    }\n",
              "\n",
              "    const hashes = {\"https://cdn.bokeh.org/bokeh/release/bokeh-2.3.3.min.js\": \"dM3QQsP+wXdHg42wTqW85BjZQdLNNIXqlPw/BgKoExPmTG7ZLML4EGqLMfqHT6ON\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.3.3.min.js\": \"8x57I4YuIfu8XyZfFo0XVr2WAT8EK4rh/uDe3wF7YuW2FNUSNEpJbsPaB1nJ2fz2\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.3.3.min.js\": \"3QTqdz9LyAm2i0sG5XTePsHec3UHWwVsrOL68SYRoAXsafvfAyqtQ+h440+qIBhS\"};\n",
              "\n",
              "    for (let i = 0; i \u003c js_urls.length; i++) {\n",
              "      const url = js_urls[i];\n",
              "      const element = document.createElement('script');\n",
              "      element.onload = on_load;\n",
              "      element.onerror = on_error.bind(null, url);\n",
              "      element.async = false;\n",
              "      element.src = url;\n",
              "      if (url in hashes) {\n",
              "        element.crossOrigin = \"anonymous\";\n",
              "        element.integrity = \"sha384-\" + hashes[url];\n",
              "      }\n",
              "      console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n",
              "      document.head.appendChild(element);\n",
              "    }\n",
              "  };\n",
              "\n",
              "  function inject_raw_css(css) {\n",
              "    const element = document.createElement(\"style\");\n",
              "    element.appendChild(document.createTextNode(css));\n",
              "    document.body.appendChild(element);\n",
              "  }\n",
              "\n",
              "  \n",
              "  var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.3.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.3.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.3.3.min.js\"];\n",
              "  var css_urls = [];\n",
              "  \n",
              "\n",
              "  var inline_js = [\n",
              "    function(Bokeh) {\n",
              "      Bokeh.set_log_level(\"info\");\n",
              "    },\n",
              "    function(Bokeh) {\n",
              "    \n",
              "    \n",
              "    }\n",
              "  ];\n",
              "\n",
              "  function run_inline_js() {\n",
              "    \n",
              "    if (root.Bokeh !== undefined || force === true) {\n",
              "      \n",
              "    for (var i = 0; i \u003c inline_js.length; i++) {\n",
              "      inline_js[i].call(root, root.Bokeh);\n",
              "    }\n",
              "    } else if (Date.now() \u003c root._bokeh_timeout) {\n",
              "      setTimeout(run_inline_js, 100);\n",
              "    } else if (!root._bokeh_failed_load) {\n",
              "      console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n",
              "      root._bokeh_failed_load = true;\n",
              "    } else if (force !== true) {\n",
              "      var cell = $(document.getElementById(null)).parents('.cell').data().cell;\n",
              "      cell.output_area.append_execute_result(NB_LOAD_WARNING)\n",
              "    }\n",
              "\n",
              "  }\n",
              "\n",
              "  if (root._bokeh_is_loading === 0) {\n",
              "    console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n",
              "    run_inline_js();\n",
              "  } else {\n",
              "    load_libs(css_urls, js_urls, function() {\n",
              "      console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n",
              "      run_inline_js();\n",
              "    });\n",
              "  }\n",
              "}(window));"
            ],
            "application/vnd.bokehjs_load.v0+json": "\n(function(root) {\n  function now() {\n    return new Date();\n  }\n\n  var force = true;\n\n  if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n    root._bokeh_onload_callbacks = [];\n    root._bokeh_is_loading = undefined;\n  }\n\n  \n\n  \n  if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n    root._bokeh_timeout = Date.now() + 5000;\n    root._bokeh_failed_load = false;\n  }\n\n  var NB_LOAD_WARNING = {'data': {'text/html':\n     \"\u003cdiv style='background-color: #fdd'\u003e\\n\"+\n     \"\u003cp\u003e\\n\"+\n     \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n     \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n     \"\u003c/p\u003e\\n\"+\n     \"\u003cul\u003e\\n\"+\n     \"\u003cli\u003ere-rerun `output_notebook()` to attempt to load from CDN again, or\u003c/li\u003e\\n\"+\n     \"\u003cli\u003euse INLINE resources instead, as so:\u003c/li\u003e\\n\"+\n     \"\u003c/ul\u003e\\n\"+\n     \"\u003ccode\u003e\\n\"+\n     \"from bokeh.resources import INLINE\\n\"+\n     \"output_notebook(resources=INLINE)\\n\"+\n     \"\u003c/code\u003e\\n\"+\n     \"\u003c/div\u003e\"}};\n\n  function display_loaded() {\n    var el = document.getElementById(null);\n    if (el != null) {\n      el.textContent = \"BokehJS is loading...\";\n    }\n    if (root.Bokeh !== undefined) {\n      if (el != null) {\n        el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n      }\n    } else if (Date.now() \u003c root._bokeh_timeout) {\n      setTimeout(display_loaded, 100)\n    }\n  }\n\n\n  function run_callbacks() {\n    try {\n      root._bokeh_onload_callbacks.forEach(function(callback) {\n        if (callback != null)\n          callback();\n      });\n    } finally {\n      delete root._bokeh_onload_callbacks\n    }\n    console.debug(\"Bokeh: all callbacks have finished\");\n  }\n\n  function load_libs(css_urls, js_urls, callback) {\n    if (css_urls == null) css_urls = [];\n    if (js_urls == null) js_urls = [];\n\n    root._bokeh_onload_callbacks.push(callback);\n    if (root._bokeh_is_loading \u003e 0) {\n      console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n      return null;\n    }\n    if (js_urls == null || js_urls.length === 0) {\n      run_callbacks();\n      return null;\n    }\n    console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n    root._bokeh_is_loading = css_urls.length + js_urls.length;\n\n    function on_load() {\n      root._bokeh_is_loading--;\n      if (root._bokeh_is_loading === 0) {\n        console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n        run_callbacks()\n      }\n    }\n\n    function on_error(url) {\n      console.error(\"failed to load \" + url);\n    }\n\n    for (let i = 0; i \u003c css_urls.length; i++) {\n      const url = css_urls[i];\n      const element = document.createElement(\"link\");\n      element.onload = on_load;\n      element.onerror = on_error.bind(null, url);\n      element.rel = \"stylesheet\";\n      element.type = \"text/css\";\n      element.href = url;\n      console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n      document.body.appendChild(element);\n    }\n\n    const hashes = {\"https://cdn.bokeh.org/bokeh/release/bokeh-2.3.3.min.js\": \"dM3QQsP+wXdHg42wTqW85BjZQdLNNIXqlPw/BgKoExPmTG7ZLML4EGqLMfqHT6ON\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.3.3.min.js\": \"8x57I4YuIfu8XyZfFo0XVr2WAT8EK4rh/uDe3wF7YuW2FNUSNEpJbsPaB1nJ2fz2\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.3.3.min.js\": \"3QTqdz9LyAm2i0sG5XTePsHec3UHWwVsrOL68SYRoAXsafvfAyqtQ+h440+qIBhS\"};\n\n    for (let i = 0; i \u003c js_urls.length; i++) {\n      const url = js_urls[i];\n      const element = document.createElement('script');\n      element.onload = on_load;\n      element.onerror = on_error.bind(null, url);\n      element.async = false;\n      element.src = url;\n      if (url in hashes) {\n        element.crossOrigin = \"anonymous\";\n        element.integrity = \"sha384-\" + hashes[url];\n      }\n      console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n      document.head.appendChild(element);\n    }\n  };\n\n  function inject_raw_css(css) {\n    const element = document.createElement(\"style\");\n    element.appendChild(document.createTextNode(css));\n    document.body.appendChild(element);\n  }\n\n  \n  var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.3.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.3.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.3.3.min.js\"];\n  var css_urls = [];\n  \n\n  var inline_js = [\n    function(Bokeh) {\n      Bokeh.set_log_level(\"info\");\n    },\n    function(Bokeh) {\n    \n    \n    }\n  ];\n\n  function run_inline_js() {\n    \n    if (root.Bokeh !== undefined || force === true) {\n      \n    for (var i = 0; i \u003c inline_js.length; i++) {\n      inline_js[i].call(root, root.Bokeh);\n    }\n    } else if (Date.now() \u003c root._bokeh_timeout) {\n      setTimeout(run_inline_js, 100);\n    } else if (!root._bokeh_failed_load) {\n      console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n      root._bokeh_failed_load = true;\n    } else if (force !== true) {\n      var cell = $(document.getElementById(null)).parents('.cell').data().cell;\n      cell.output_area.append_execute_result(NB_LOAD_WARNING)\n    }\n\n  }\n\n  if (root._bokeh_is_loading === 0) {\n    console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n    run_inline_js();\n  } else {\n    load_libs(css_urls, js_urls, function() {\n      console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n      run_inline_js();\n    });\n  }\n}(window));"
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/html": [
              "\n",
              "\n",
              "\n",
              "\n",
              "\n",
              "\n",
              "  \u003cdiv class=\"bk-root\" id=\"5ad4d6c9-0680-41f9-b0bc-fa26e7ee849d\" data-root-id=\"1449\"\u003e\u003c/div\u003e\n"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "application/javascript": [
              "(function(root) {\n",
              "  function embed_document(root) {\n",
              "    \n",
              "  var docs_json = {\"9201038d-23f0-40a0-929c-aed743de7c80\":{\"defs\":[],\"roots\":{\"references\":[{\"attributes\":{\"children\":[{\"id\":\"1341\"},{\"id\":\"1377\"},{\"id\":\"1413\"}]},\"id\":\"1449\",\"type\":\"Row\"},{\"attributes\":{},\"id\":\"1384\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1487\",\"type\":\"Title\"},{\"attributes\":{},\"id\":\"1483\",\"type\":\"Title\"},{\"attributes\":{},\"id\":\"1508\",\"type\":\"Selection\"},{\"attributes\":{\"formatter\":{\"id\":\"1499\"},\"major_label_policy\":{\"id\":\"1500\"},\"ticker\":{\"id\":\"1387\"}},\"id\":\"1386\",\"type\":\"LinearAxis\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":0.5,\"fill_color\":\"lightgrey\",\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":1.0,\"line_color\":\"black\",\"line_dash\":[4,4],\"line_width\":2,\"right_units\":\"screen\",\"syncable\":false,\"top_units\":\"screen\"},\"id\":\"1400\",\"type\":\"BoxAnnotation\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":0.5,\"fill_color\":\"lightgrey\",\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":1.0,\"line_color\":\"black\",\"line_dash\":[4,4],\"line_width\":2,\"right_units\":\"screen\",\"syncable\":false,\"top_units\":\"screen\"},\"id\":\"1364\",\"type\":\"BoxAnnotation\"},{\"attributes\":{},\"id\":\"1496\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1414\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1494\",\"type\":\"AllLabels\"},{\"attributes\":{\"fill_color\":{\"value\":\"red\"},\"line_color\":{\"value\":\"red\"},\"x\":{\"field\":\"x\"},\"y\":{\"field\":\"y\"}},\"id\":\"1445\",\"type\":\"Scatter\"},{\"attributes\":{\"data\":{\"x\":[0,1,2,3,4,5,6,7,8,9],\"y\":[0,1,4,9,16,25,36,49,64,81]},\"selected\":{\"id\":\"1514\"},\"selection_policy\":{\"id\":\"1513\"}},\"id\":\"1444\",\"type\":\"ColumnDataSource\"},{\"attributes\":{},\"id\":\"1418\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1348\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1416\",\"type\":\"DataRange1d\"},{\"attributes\":{\"below\":[{\"id\":\"1386\"}],\"center\":[{\"id\":\"1389\"},{\"id\":\"1393\"}],\"height\":300,\"left\":[{\"id\":\"1390\"}],\"renderers\":[{\"id\":\"1411\"}],\"title\":{\"id\":\"1485\"},\"toolbar\":{\"id\":\"1401\"},\"width\":300,\"x_range\":{\"id\":\"1378\"},\"x_scale\":{\"id\":\"1382\"},\"y_range\":{\"id\":\"1380\"},\"y_scale\":{\"id\":\"1384\"}},\"id\":\"1377\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{\"axis\":{\"id\":\"1354\"},\"dimension\":1,\"ticker\":null},\"id\":\"1357\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1420\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1355\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1344\",\"type\":\"DataRange1d\"},{\"attributes\":{\"formatter\":{\"id\":\"1505\"},\"major_label_policy\":{\"id\":\"1506\"},\"ticker\":{\"id\":\"1423\"}},\"id\":\"1422\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1497\",\"type\":\"AllLabels\"},{\"attributes\":{},\"id\":\"1427\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1423\",\"type\":\"BasicTicker\"},{\"attributes\":{\"axis\":{\"id\":\"1422\"},\"ticker\":null},\"id\":\"1425\",\"type\":\"Grid\"},{\"attributes\":{\"fill_alpha\":{\"value\":0.1},\"fill_color\":{\"value\":\"red\"},\"line_alpha\":{\"value\":0.1},\"line_color\":{\"value\":\"red\"},\"x\":{\"field\":\"x\"},\"y\":{\"field\":\"y\"}},\"id\":\"1446\",\"type\":\"Scatter\"},{\"attributes\":{\"axis\":{\"id\":\"1426\"},\"dimension\":1,\"ticker\":null},\"id\":\"1429\",\"type\":\"Grid\"},{\"attributes\":{},\"id\":\"1503\",\"type\":\"AllLabels\"},{\"attributes\":{\"formatter\":{\"id\":\"1502\"},\"major_label_policy\":{\"id\":\"1503\"},\"ticker\":{\"id\":\"1427\"}},\"id\":\"1426\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1342\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1346\",\"type\":\"LinearScale\"},{\"attributes\":{\"axis\":{\"id\":\"1350\"},\"ticker\":null},\"id\":\"1353\",\"type\":\"Grid\"},{\"attributes\":{\"data\":{\"x\":[0,1,2,3,4,5,6,7,8,9],\"y\":[0,1,2,3,4,5,6,7,8,9]},\"selected\":{\"id\":\"1508\"},\"selection_policy\":{\"id\":\"1507\"}},\"id\":\"1372\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"formatter\":{\"id\":\"1490\"},\"major_label_policy\":{\"id\":\"1491\"},\"ticker\":{\"id\":\"1355\"}},\"id\":\"1354\",\"type\":\"LinearAxis\"},{\"attributes\":{\"below\":[{\"id\":\"1350\"}],\"center\":[{\"id\":\"1353\"},{\"id\":\"1357\"}],\"height\":300,\"left\":[{\"id\":\"1354\"}],\"renderers\":[{\"id\":\"1375\"}],\"title\":{\"id\":\"1483\"},\"toolbar\":{\"id\":\"1365\"},\"width\":300,\"x_range\":{\"id\":\"1342\"},\"x_scale\":{\"id\":\"1346\"},\"y_range\":{\"id\":\"1344\"},\"y_scale\":{\"id\":\"1348\"}},\"id\":\"1341\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{},\"id\":\"1505\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{\"source\":{\"id\":\"1444\"}},\"id\":\"1448\",\"type\":\"CDSView\"},{\"attributes\":{},\"id\":\"1430\",\"type\":\"PanTool\"},{\"attributes\":{},\"id\":\"1431\",\"type\":\"WheelZoomTool\"},{\"attributes\":{\"line_alpha\":0.1,\"line_color\":\"#1f77b4\",\"x\":{\"field\":\"x\"},\"y\":{\"field\":\"y\"}},\"id\":\"1374\",\"type\":\"Line\"},{\"attributes\":{\"overlay\":{\"id\":\"1436\"}},\"id\":\"1432\",\"type\":\"BoxZoomTool\"},{\"attributes\":{},\"id\":\"1433\",\"type\":\"SaveTool\"},{\"attributes\":{\"formatter\":{\"id\":\"1493\"},\"major_label_policy\":{\"id\":\"1494\"},\"ticker\":{\"id\":\"1351\"}},\"id\":\"1350\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1434\",\"type\":\"ResetTool\"},{\"attributes\":{\"data_source\":{\"id\":\"1444\"},\"glyph\":{\"id\":\"1445\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1446\"},\"view\":{\"id\":\"1448\"}},\"id\":\"1447\",\"type\":\"GlyphRenderer\"},{\"attributes\":{},\"id\":\"1435\",\"type\":\"HelpTool\"},{\"attributes\":{\"active_multi\":null,\"tools\":[{\"id\":\"1430\"},{\"id\":\"1431\"},{\"id\":\"1432\"},{\"id\":\"1433\"},{\"id\":\"1434\"},{\"id\":\"1435\"}]},\"id\":\"1437\",\"type\":\"Toolbar\"},{\"attributes\":{\"data_source\":{\"id\":\"1372\"},\"glyph\":{\"id\":\"1373\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1374\"},\"view\":{\"id\":\"1376\"}},\"id\":\"1375\",\"type\":\"GlyphRenderer\"},{\"attributes\":{},\"id\":\"1499\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1500\",\"type\":\"AllLabels\"},{\"attributes\":{},\"id\":\"1351\",\"type\":\"BasicTicker\"},{\"attributes\":{\"source\":{\"id\":\"1372\"}},\"id\":\"1376\",\"type\":\"CDSView\"},{\"attributes\":{},\"id\":\"1506\",\"type\":\"AllLabels\"},{\"attributes\":{},\"id\":\"1502\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1485\",\"type\":\"Title\"},{\"attributes\":{\"data\":{\"x\":[0,1,2,3,4,5,6,7,8,9],\"y\":[0,1,4,9,16,25,36,49,64,81]},\"selected\":{\"id\":\"1511\"},\"selection_policy\":{\"id\":\"1510\"}},\"id\":\"1408\",\"type\":\"ColumnDataSource\"},{\"attributes\":{\"fill_color\":{\"value\":\"#1f77b4\"},\"line_color\":{\"value\":\"#1f77b4\"},\"x\":{\"field\":\"x\"},\"y\":{\"field\":\"y\"}},\"id\":\"1409\",\"type\":\"Scatter\"},{\"attributes\":{},\"id\":\"1358\",\"type\":\"PanTool\"},{\"attributes\":{},\"id\":\"1511\",\"type\":\"Selection\"},{\"attributes\":{\"active_multi\":null,\"tools\":[{\"id\":\"1358\"},{\"id\":\"1359\"},{\"id\":\"1360\"},{\"id\":\"1361\"},{\"id\":\"1362\"},{\"id\":\"1363\"}]},\"id\":\"1365\",\"type\":\"Toolbar\"},{\"attributes\":{},\"id\":\"1359\",\"type\":\"WheelZoomTool\"},{\"attributes\":{\"bottom_units\":\"screen\",\"fill_alpha\":0.5,\"fill_color\":\"lightgrey\",\"left_units\":\"screen\",\"level\":\"overlay\",\"line_alpha\":1.0,\"line_color\":\"black\",\"line_dash\":[4,4],\"line_width\":2,\"right_units\":\"screen\",\"syncable\":false,\"top_units\":\"screen\"},\"id\":\"1436\",\"type\":\"BoxAnnotation\"},{\"attributes\":{\"overlay\":{\"id\":\"1364\"}},\"id\":\"1360\",\"type\":\"BoxZoomTool\"},{\"attributes\":{},\"id\":\"1361\",\"type\":\"SaveTool\"},{\"attributes\":{},\"id\":\"1362\",\"type\":\"ResetTool\"},{\"attributes\":{},\"id\":\"1363\",\"type\":\"HelpTool\"},{\"attributes\":{},\"id\":\"1378\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1382\",\"type\":\"LinearScale\"},{\"attributes\":{},\"id\":\"1380\",\"type\":\"DataRange1d\"},{\"attributes\":{},\"id\":\"1387\",\"type\":\"BasicTicker\"},{\"attributes\":{},\"id\":\"1391\",\"type\":\"BasicTicker\"},{\"attributes\":{\"axis\":{\"id\":\"1386\"},\"ticker\":null},\"id\":\"1389\",\"type\":\"Grid\"},{\"attributes\":{\"fill_alpha\":{\"value\":0.1},\"fill_color\":{\"value\":\"#1f77b4\"},\"line_alpha\":{\"value\":0.1},\"line_color\":{\"value\":\"#1f77b4\"},\"x\":{\"field\":\"x\"},\"y\":{\"field\":\"y\"}},\"id\":\"1410\",\"type\":\"Scatter\"},{\"attributes\":{},\"id\":\"1507\",\"type\":\"UnionRenderers\"},{\"attributes\":{\"axis\":{\"id\":\"1390\"},\"dimension\":1,\"ticker\":null},\"id\":\"1393\",\"type\":\"Grid\"},{\"attributes\":{\"formatter\":{\"id\":\"1496\"},\"major_label_policy\":{\"id\":\"1497\"},\"ticker\":{\"id\":\"1391\"}},\"id\":\"1390\",\"type\":\"LinearAxis\"},{\"attributes\":{},\"id\":\"1514\",\"type\":\"Selection\"},{\"attributes\":{\"below\":[{\"id\":\"1422\"}],\"center\":[{\"id\":\"1425\"},{\"id\":\"1429\"}],\"height\":300,\"left\":[{\"id\":\"1426\"}],\"renderers\":[{\"id\":\"1447\"}],\"title\":{\"id\":\"1487\"},\"toolbar\":{\"id\":\"1437\"},\"width\":300,\"x_range\":{\"id\":\"1414\"},\"x_scale\":{\"id\":\"1418\"},\"y_range\":{\"id\":\"1416\"},\"y_scale\":{\"id\":\"1420\"}},\"id\":\"1413\",\"subtype\":\"Figure\",\"type\":\"Plot\"},{\"attributes\":{\"line_color\":\"#1f77b4\",\"x\":{\"field\":\"x\"},\"y\":{\"field\":\"y\"}},\"id\":\"1373\",\"type\":\"Line\"},{\"attributes\":{\"source\":{\"id\":\"1408\"}},\"id\":\"1412\",\"type\":\"CDSView\"},{\"attributes\":{},\"id\":\"1394\",\"type\":\"PanTool\"},{\"attributes\":{},\"id\":\"1395\",\"type\":\"WheelZoomTool\"},{\"attributes\":{\"overlay\":{\"id\":\"1400\"}},\"id\":\"1396\",\"type\":\"BoxZoomTool\"},{\"attributes\":{},\"id\":\"1397\",\"type\":\"SaveTool\"},{\"attributes\":{},\"id\":\"1398\",\"type\":\"ResetTool\"},{\"attributes\":{\"data_source\":{\"id\":\"1408\"},\"glyph\":{\"id\":\"1409\"},\"hover_glyph\":null,\"muted_glyph\":null,\"nonselection_glyph\":{\"id\":\"1410\"},\"view\":{\"id\":\"1412\"}},\"id\":\"1411\",\"type\":\"GlyphRenderer\"},{\"attributes\":{},\"id\":\"1513\",\"type\":\"UnionRenderers\"},{\"attributes\":{},\"id\":\"1399\",\"type\":\"HelpTool\"},{\"attributes\":{},\"id\":\"1510\",\"type\":\"UnionRenderers\"},{\"attributes\":{\"active_multi\":null,\"tools\":[{\"id\":\"1394\"},{\"id\":\"1395\"},{\"id\":\"1396\"},{\"id\":\"1397\"},{\"id\":\"1398\"},{\"id\":\"1399\"}]},\"id\":\"1401\",\"type\":\"Toolbar\"},{\"attributes\":{},\"id\":\"1493\",\"type\":\"BasicTickFormatter\"},{\"attributes\":{},\"id\":\"1491\",\"type\":\"AllLabels\"},{\"attributes\":{},\"id\":\"1490\",\"type\":\"BasicTickFormatter\"}],\"root_ids\":[\"1449\"]},\"title\":\"Bokeh Application\",\"version\":\"2.3.3\"}};\n",
              "  var render_items = [{\"docid\":\"9201038d-23f0-40a0-929c-aed743de7c80\",\"root_ids\":[\"1449\"],\"roots\":{\"1449\":\"5ad4d6c9-0680-41f9-b0bc-fa26e7ee849d\"}}];\n",
              "  root.Bokeh.embed.embed_items_notebook(docs_json, render_items);\n",
              "\n",
              "  }\n",
              "  if (root.Bokeh !== undefined) {\n",
              "    embed_document(root);\n",
              "  } else {\n",
              "    var attempts = 0;\n",
              "    var timer = setInterval(function(root) {\n",
              "      if (root.Bokeh !== undefined) {\n",
              "        clearInterval(timer);\n",
              "        embed_document(root);\n",
              "      } else {\n",
              "        attempts++;\n",
              "        if (attempts \u003e 100) {\n",
              "          clearInterval(timer);\n",
              "          console.log(\"Bokeh: ERROR: Unable to run BokehJS code because BokehJS library is missing\");\n",
              "        }\n",
              "      }\n",
              "    }, 10, root)\n",
              "  }\n",
              "})(window);"
            ],
            "application/vnd.bokehjs_exec.v0+json": ""
          },
          "metadata": {
            "application/vnd.bokehjs_exec.v0+json": {
              "id": "1449"
            }
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Present plots side by side.\n",
        "from bokeh.layouts import row\n",
        "\n",
        "# Create plots.\n",
        "f1 = figure(plot_width=300, plot_height=300)\n",
        "f1.line(numbers, numbers)\n",
        "\n",
        "f2 = figure(plot_width=300, plot_height=300)\n",
        "f2.scatter(x, y)\n",
        "\n",
        "f3 = figure(plot_width=300, plot_height=300)\n",
        "f3.scatter(x, y, color='red')\n",
        "\n",
        "# Put the results in a row and show the figure.\n",
        "show(row(f1, f2, f3))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GnVsNr3LI0HB"
      },
      "source": [
        "**Exercise**: Can you figure out how to remake the fruit bar plot from above in Bokeh?\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h_sdCi-pgBVZ"
      },
      "source": [
        "\n",
        "# Part II: Introduction to NumPy\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pcLDBdl-ZaXE"
      },
      "source": [
        "[NumPy](https://numpy.org/) is a high-performance Python library that enables us to work with multidimensional arrays. We care about arrays as they are the core building blocks of Deep Learning (DL), and indeed machine learning in general. \n",
        "\n",
        "Specific DL frameworks, such as JAX, TensorFlow, and PyTorch enable us to write models that heavily rely on array computing, with the added benefit of additional dedicated hardware acceleration (for example, JAX makes it easy to write code for training and evaluating models on multiple GPUs or TPUs).\n",
        "\n",
        "Still, despite the existence of these DL frameworks, NumPy is often used both for quick experimentation and small data processing. NumPy has also been a great source of influence on DL frameworks – you will often find same-named and same-behaving functions across NumPy and various DL frameworks.\n",
        "\n",
        "Links:\n",
        "- [Installing NumPy](https://numpy.org/install/)\n",
        "- [NumPy documentation](https://numpy.org/doc/stable/contents.html)\n",
        "- [NumPy for MATLAB users](https://numpy.org/doc/stable/user/numpy-for-matlab-users.html)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vG3FvljfgBVf"
      },
      "source": [
        "### Import NumPy\n",
        "\n",
        "This is how we import NumPy in Python programmes:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VMuPW798gBVf"
      },
      "outputs": [],
      "source": [
        "import numpy as np"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NJU-TmMqZfeq"
      },
      "source": [
        "### NumPy arrays and their creation\n",
        "\n",
        "In general, **arrays** are multidimensional \"tables\" of values of the same type. Arrays are described by their **rank** (the number of dimensions) and their **shape** (the size of each of the array dimensions). Often, we call each dimension an **axis**.\n",
        "\n",
        "We use specific words to denote arrays of different dimensions:\n",
        "\n",
        "- **scalar** (single number) -- rank 0 (0-dimensional) array\n",
        "- **vector** (sequence of numbers) -- rank 1 array\n",
        "- **matrix** (rectangular table of values) -- rank 2 array\n",
        "- **tensor** -- rank 3 (and above) array, but can also refer to any rank arrays. So, we could say that a vector is a tensor, and an 8-dimensional array is a tensor.\n",
        "\n",
        "![picture](https://storage.googleapis.com/dm-educational/assets/intro-to-python-and-numpy/arrays.svg)\n",
        "\n",
        "\n",
        "\n",
        "Let's create some NumPy arrays, starting with a scalar:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RjbKVzodEsBT"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n"
          ]
        }
      ],
      "source": [
        "# Creating a scalar.\n",
        "a = np.array(1)  # A rank 0 array is simply a scalar.\n",
        "print(a)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kV0a32VsE9xl"
      },
      "source": [
        "We can create arrays from (potentially nested) lists of numbers:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VghvTts2ZeaT"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3 4]\n"
          ]
        }
      ],
      "source": [
        "b = np.array([1, 2, 3, 4])  # Vector.\n",
        "print(b)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "svjVHa68EzmY"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 1  2  3  4]\n",
            " [ 5  6  7  8]\n",
            " [ 9 10 11 12]]\n"
          ]
        }
      ],
      "source": [
        "c = np.array([[1, 2, 3, 4],\n",
        "              [5, 6, 7, 8],\n",
        "              [9, 10, 11, 12]])  # Matrix.\n",
        "print(c)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q10DIwmbKY8C"
      },
      "source": [
        "Accessing specific values within the numpy array works using indexing in the same way as described above for native Python lists:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "w239F8djjh0I"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "execution_count": 114,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "c[1, 0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "E6sJr5mWKnuZ"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([ 3,  7, 11])"
            ]
          },
          "execution_count": 115,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "c[:, 2]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yzvYBPodKsSF"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([4, 8])"
            ]
          },
          "execution_count": 116,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "c[0:2, -1]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BuC3t7PSEzgg"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[[ 1  2  3  4]\n",
            "  [ 5  6  7  8]\n",
            "  [ 9 10 11 12]]\n",
            "\n",
            " [[13 14 15 16]\n",
            "  [17 18 19 20]\n",
            "  [21 22 23 24]]]\n"
          ]
        }
      ],
      "source": [
        "# Rank 3 tensor.\n",
        "d = np.array([[[1, 2, 3, 4],\n",
        "               [5, 6, 7, 8],\n",
        "               [9, 10, 11, 12]],\n",
        "              [[13, 14, 15, 16],\n",
        "               [17, 18, 19, 20],\n",
        "               [21, 22, 23, 24]]])\n",
        "print(d)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ltl0I1LrF2xG"
      },
      "source": [
        "#### Array size and type\n",
        "\n",
        "We mentioned that array sizes are characterised by the rank and the shape of the array.\n",
        "A rank is just a number, denoting the number of dimensions (axes), whereas the shape is a tuple of integers representing the size of each of the axes:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LG6otDPSF2O3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 1  2  3  4]\n",
            " [ 5  6  7  8]\n",
            " [ 9 10 11 12]] \n",
            "\n",
            "Rank: 2\n",
            "Shape: (3, 4)\n"
          ]
        }
      ],
      "source": [
        "a = np.array([[1, 2, 3, 4],\n",
        "              [5, 6, 7, 8],\n",
        "              [9, 10, 11, 12]])\n",
        "print(a, '\\n')\n",
        "\n",
        "print('Rank:', np.ndim(a))    # Rank.\n",
        "print('Shape:', np.shape(a))  # Shape."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_6oinBNnF4Jt"
      },
      "source": [
        "We also mentioned that arrays contain values of the *same type*. We can get that type by calling the `dtype` property:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Uqp_UD6SuaqB"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Type of variable a: \u003cclass 'numpy.ndarray'\u003e\n",
            "Type of values in the array: int64\n"
          ]
        }
      ],
      "source": [
        "print('Type of variable a:', type(a))       # Type of the variable a.\n",
        "print('Type of values in the array:', a.dtype)  # Type of the array element."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xfn-ywi8u4R6"
      },
      "source": [
        "Since NumPy arrays contain elements of the same type, when creating an array, NumPy will try to guess the [data type](https://numpy.org/devdocs/user/basics.types.html), unless you specify the data type manually:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NiYSHpK6HBFL"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3]\n",
            "Data type: int64\n"
          ]
        }
      ],
      "source": [
        "a = np.array([1, 2, 3])\n",
        "print(a)\n",
        "print('Data type:', a.dtype)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9tgXnQfJHC6Q"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1. 2. 3.]\n",
            "Data type: float64\n"
          ]
        }
      ],
      "source": [
        "a = np.array([1.0, 2.0, 3.0])\n",
        "print(a)\n",
        "print('Data type:', a.dtype)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rJoG6uR_LWbn"
      },
      "source": [
        "We can manually set the data type:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6WSFpyVUHOvK"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1. 2. 3.]\n",
            "Data type: float32\n"
          ]
        }
      ],
      "source": [
        "a = np.array([1, 2, 3], dtype=np.float32)\n",
        "print(a)\n",
        "print('Data type:', a.dtype)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uA3Edmw6Lfwn"
      },
      "source": [
        "In the following case, NumPy will guess that the input should be `float` in order to not lose precision:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "thYDNXbAtRok"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1.  2.  3.1]\n",
            "Data type: float64\n"
          ]
        }
      ],
      "source": [
        "a = np.array([1, 2, 3.1])\n",
        "print(a)\n",
        "print('Data type:', a.dtype)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ua9Pn6nfKj1E"
      },
      "source": [
        "Be careful when specifying the data type manually, especially when creating integers from floats:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BoGxS1tmucAS"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3]\n",
            "Data type: int32\n"
          ]
        }
      ],
      "source": [
        "# Be careful with casting the data type – you may lose precision.\n",
        "a = np.array([1.0, 2.0, 3.1], dtype=np.int32)\n",
        "print(a)\n",
        "print('Data type:', a.dtype)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9g16HJj9L8OM"
      },
      "source": [
        "Notice that the `3.1` is now `3` - that's precision loss."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qVT4nSyOF-zQ"
      },
      "source": [
        "#### Useful creation functions\n",
        "\n",
        "NumPy supports many convenient ways of [creating arrays](https://numpy.org/doc/stable/user/basics.creation.html). Here are a few that you are likely to frequently encounter:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rsCCFWtmHynf"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0. 0. 0.]\n",
            " [0. 0. 0.]]\n"
          ]
        }
      ],
      "source": [
        "a = np.zeros((2, 3))  # Array of zeros of shape (2, 3).\n",
        "print(a)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tI94uAgpHzOe"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1. 1.]]\n"
          ]
        }
      ],
      "source": [
        "b = np.ones((1, 2))  # Array of ones of shape (1, 2).\n",
        "print(b)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JuzRrEfAHzz2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1. 0. 0. 0. 0.]\n",
            " [0. 1. 0. 0. 0.]\n",
            " [0. 0. 1. 0. 0.]\n",
            " [0. 0. 0. 1. 0.]\n",
            " [0. 0. 0. 0. 1.]]\n"
          ]
        }
      ],
      "source": [
        "c = np.eye(5)  # Identity matrix of shape (5, 5).\n",
        "print(c)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "T_qLCzaZH1P4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0.14588963 0.19837327]\n",
            " [0.23629504 0.54878177]]\n"
          ]
        }
      ],
      "source": [
        "# Array of random values from [0, 1] of shape (2, 2).\n",
        "d = np.random.random((2, 2))\n",
        "print(d)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8WBiyGa4H2k7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0 1 2 3 4 5 6 7 8 9]\n"
          ]
        }
      ],
      "source": [
        "e = np.arange(10)  # Array of length 10, containing numbers 0 to 9.\n",
        "print(e)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KbdiRL8gH5Uv"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[3 3 3]\n",
            " [3 3 3]\n",
            " [3 3 3]]\n"
          ]
        }
      ],
      "source": [
        "f = np.full((3, 3), 3)  # Array of shape (3, 4) containing the number 3.\n",
        "print(f)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FJBEHLztvrmn"
      },
      "source": [
        "You can also create arrays of zeros and ones of the same shape as other arrays:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4poyNqL_7GFl"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 1 1]\n",
            " [1 1 1]] \n",
            "\n",
            "[[0 0 0]\n",
            " [0 0 0]]\n"
          ]
        }
      ],
      "source": [
        "a = np.array([[1, 2, 3],\n",
        "              [4, 5, 6]])\n",
        "print(np.ones_like(a), '\\n')\n",
        "\n",
        "print(np.zeros_like(a))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oM7ieMJe_YY9"
      },
      "source": [
        "We can also create arrays of random numbers. Random numbers are implemented as [pseudo-random](https://www.random.org/randomness/), and as such require a starting number for generation called a [seed](https://numpy.org/doc/stable/reference/random/generated/numpy.random.seed.html). Given that a lot of deep learning research relies on (pseudo-)random numbers, as good experimental practice it is important to fix the random seed as that makes our experiments [reproducible](https://blog.ml.cmu.edu/2020/08/31/5-reproducibility/). If you don't explicitly set the seed, it will be set to a platform-dependent source of seed which is often the current time in milliseconds."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "z4V3Y5r3v8m1"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0.37454012 0.95071431]\n",
            " [0.73199394 0.59865848]] \n",
            "\n",
            "[[0.15601864 0.15599452]\n",
            " [0.05808361 0.86617615]]\n"
          ]
        }
      ],
      "source": [
        "np.random.seed(42)  # Setting the random seed.\n",
        "d = np.random.random([2, 2])  # Calling numpy random \"uses up\" the random seed.\n",
        "print(d, '\\n')\n",
        "\n",
        "d = np.random.random([2, 2])  # This will produce different numbers!\n",
        "print(d)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "D_Drj1_SAvC0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0.37454012 0.95071431]\n",
            " [0.73199394 0.59865848]] \n",
            "\n",
            "[[0.37454012 0.95071431]\n",
            " [0.73199394 0.59865848]]\n"
          ]
        }
      ],
      "source": [
        "np.random.seed(42)  # Setting the random seed.\n",
        "d = np.random.random([2, 2])\n",
        "print(d, '\\n')\n",
        "\n",
        "np.random.seed(42)  # Setting the random seed again.\n",
        "d = np.random.random([2, 2])\n",
        "print(d)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t03ZF09sVGNQ"
      },
      "source": [
        "### Slicing and indexing\n",
        "\n",
        "[Slicing and indexing](https://numpy.org/doc/stable/reference/arrays.indexing.html) in NumPy is very similar to slicing and indexing in Python, with the major differences being the syntax of indexing/slicing, and the support for boolean array indexing."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kDAeiEN7WdHQ"
      },
      "source": [
        "#### NumPy slicing and indexing syntax\n",
        "\n",
        "In Python, indexing of nested lists is written in the form of \n",
        "`lists[x][y][z][...]`.\n",
        "\n",
        "In NumPy, on the other hand, indexing is written in the form of `array[x, y, z, ...]`, where `x` specifies the number of a row (axis 0), `y` the number of a column (axis 1), and `z` and other numbers specify the number of other axes (axis 2 and more) of the array `array`.\n",
        "\n",
        "By indexing a numpy array, we obtain a result of a lower rank. For example, taking the 1st row of a 2x2 matrix results in a vector of size 2 (one rank less)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_LwWH4K-Xoaj"
      },
      "source": [
        "Let's now re-do some of the exercises from the Python indexing \u0026 slicing, showing a few more NumPy extras:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fQpZ9BT5WkIk"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "6\n"
          ]
        }
      ],
      "source": [
        "a = np.array([[1, 2, 3, 4],\n",
        "              [5, 6, 7, 8],\n",
        "              [9, 10, 11, 12]])\n",
        "\n",
        "print(a[1, 1])          # element in 2nd row and 2nd column"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "L6H1WApzXzcQ"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[5 6 7 8] \n",
            "\n",
            "[5 6 7 8] \n",
            "\n",
            "[5 6 7 8]\n"
          ]
        }
      ],
      "source": [
        "print(a[1], '\\n')       # 2nd row\n",
        "\n",
        "print(a[1, :], '\\n')    # the same as above (colon = full slice)\n",
        "\n",
        "print(a[1, ...])        # the same as above (ellipsis extends slicing with colons for all remaining dimensions)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "asZC1SfRXztt"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[6 7 8] \n",
            "\n",
            "[5 6 7] \n",
            "\n",
            "[6] \n",
            "\n"
          ]
        }
      ],
      "source": [
        "print(a[1, 1:], '\\n')   # elements in 2nd row, from 2nd column until the end\n",
        "\n",
        "print(a[1, :-1], '\\n')  # elements in 2nd row, until the last column (not inclusive)\n",
        "\n",
        "print(a[1, 1:2], '\\n')  # elements in 2nd row, from 2nd until 3rd element (not inclusive)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rL9L25kbXG46"
      },
      "source": [
        "As in Python, we can use array indexing and slicing for array modification too:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dTGahitUXDX6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Before the modification: [[ 1  2  3  4]\n",
            " [ 5  6  7  8]\n",
            " [ 9 10 11 12]] \n",
            "\n",
            "After the modification: [[100   2   3   4]\n",
            " [  5   6   7   8]\n",
            " [  9  10  11  12]]\n"
          ]
        }
      ],
      "source": [
        "a = np.array([[1, 2, 3, 4],\n",
        "              [5, 6, 7, 8],\n",
        "              [9, 10, 11, 12]])\n",
        "print('Before the modification:', a, '\\n')\n",
        "\n",
        "a[0, 0] = 100\n",
        "print('After the modification:', a)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XvZpSOXiXLov"
      },
      "source": [
        "We can also modify entire rows/columns/regions of arrays:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GrZdtoBHXDVA"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 1  2  3  4]\n",
            " [ 5  6  7  8]\n",
            " [ 9 10 11 12]] \n",
            "\n",
            "After the modification: [[  1 100   3   4]\n",
            " [  5 100   7   8]\n",
            " [  9 100  11  12]]\n"
          ]
        }
      ],
      "source": [
        "a = np.array([[1, 2, 3, 4],\n",
        "              [5, 6, 7, 8],\n",
        "              [9, 10, 11, 12]])\n",
        "print(a, '\\n')\n",
        "\n",
        "a[:, 1] = 100\n",
        "print('After the modification:', a)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sul6ZNCR72BR"
      },
      "source": [
        "#### Boolean array indexing\n",
        "\n",
        "Boolean array indexing is very handy when working with NumPy arrays: effectively, each element of the boolean array is used to either select or drop the corresponding element in the array being indexed. This is often used in conjunction with conditions - conditions on arrays return a boolean valued array.\n",
        "\n",
        "For example:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "T7D8E6BWCK_V"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 1  2  3  4]\n",
            " [ 5  6  7  8]\n",
            " [ 9 10 11 12]]\n",
            "Boolean array:\n",
            "[[False False False  True]\n",
            " [ True  True  True  True]\n",
            " [ True  True  True  True]]\n"
          ]
        }
      ],
      "source": [
        "a = np.array([[1, 2, 3, 4],\n",
        "              [5, 6, 7, 8],\n",
        "              [9, 10, 11, 12]])\n",
        "print(a)\n",
        "print('Boolean array:')\n",
        "# Boolean array, same shape as a, where each element corresponds to\n",
        "# whether the corresponding element in a meets the condition of being \u003e 3.\n",
        "print(a \u003e 3)  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "b4mHuJiPuJ0W"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 4  5  6  7  8  9 10 11 12]\n",
            "[ 4  5  6  7  8  9 10 11 12]\n"
          ]
        }
      ],
      "source": [
        "bool_index = a \u003e 3\n",
        "print(a[bool_index])\n",
        "print(a[a \u003e 3])  # Shorthand."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OEVJ30COZhPP"
      },
      "source": [
        "### Array operations and vectorisation\n",
        "\n",
        "NumPy contains a large set of familiar mathematical functions such as addition, subtraction, multiplication and division, square root, powers, and trigonometric functions. All these NumPy functions are **vectorised**, in that they operate elementwise – each operation is applied on each element of the array (or two corresponding elements in the case of binary operations).\n",
        "\n",
        "Here is an example of vectorised addition:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RxQZrDXBZemb"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "a:\t\t [0 1 2 3 4]\n",
            "b:\t\t [1 1 1 1 1]\n",
            "np.add(a, b):\t [1 2 3 4 5]\n",
            "a + b:\t\t [1 2 3 4 5]\n"
          ]
        }
      ],
      "source": [
        "a = np.arange(5, dtype=np.int32)\n",
        "b = np.ones(5, dtype=np.int32)\n",
        "print('a:\\t\\t', a)\n",
        "print('b:\\t\\t', b)\n",
        "\n",
        "print('np.add(a, b):\\t', np.add(a, b))\n",
        "print('a + b:\\t\\t', a + b)  # Shorthand via operator overloading."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-RuuMWXCqF3V"
      },
      "source": [
        "Subtraction:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Hz9n7ELBO1tZ"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[-1  0  1  2  3]\n",
            "[-1  0  1  2  3]\n"
          ]
        }
      ],
      "source": [
        "print(np.subtract(a, b))\n",
        "print(a - b)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AfSuNB8ZPwSk"
      },
      "source": [
        "Note that `*` is an elementwise multiplication (also called a [Hadamard product](https://en.wikipedia.org/wiki/Hadamard_product_(matrices))) and not a matrix multiplication!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2Db_6Vm5O1zy"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0 1 2 3 4]\n",
            "[0 1 2 3 4]\n"
          ]
        }
      ],
      "source": [
        "print(np.multiply(a, b))\n",
        "print(a * b)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jXOF2DPIqXoq"
      },
      "source": [
        "Division:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4KtAmSiTO16K"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.  0.5 1.  1.5 2. ]\n",
            "[0.  0.5 1.  1.5 2. ]\n"
          ]
        }
      ],
      "source": [
        "c = b + b\n",
        "print(np.divide(a, c))\n",
        "print(a / c)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YD4PN_29w0VL"
      },
      "source": [
        "Similarly, comparison operators are also elementwise operations:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jjpLltGWwl75"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[False  True False False False]\n",
            "[False False  True  True  True]\n"
          ]
        }
      ],
      "source": [
        "print(a == b)\n",
        "print(a \u003e b)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8wzVAC8mqccP"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1]\n",
            "[2 3 4]\n"
          ]
        }
      ],
      "source": [
        "# Remember boolean-based indexing!\n",
        "print(a[a == b])\n",
        "print(a[a \u003e b])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZEvDvAfXDA5O"
      },
      "source": [
        "#### Aggregations\n",
        "\n",
        "NumPy also contains functions that compute values over the whole array or subsets of arrays. We call these functions **aggregation functions**."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2r_3Ul6SDB_O"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(2, 3)\n"
          ]
        }
      ],
      "source": [
        "a = np.array([[1, 2, 3],\n",
        "              [4, 5, 6]])\n",
        "print(a.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ByQsIpK3QN0b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Sum of all elements:\n",
            "21\n",
            "\n",
            "Sum over rows (first axis):\n",
            "[5 7 9]\n",
            "\n",
            "Sum over columns (second axis):\n",
            "[ 6 15]\n",
            "\n",
            "Sum over the first and second axis:\n",
            "21\n"
          ]
        }
      ],
      "source": [
        "print(f'Sum of all elements:\\n{np.sum(a)}\\n')\n",
        "\n",
        "print(f'Sum over rows (first axis):\\n{np.sum(a, axis=0)}\\n')\n",
        "\n",
        "print(f'Sum over columns (second axis):\\n{np.sum(a, axis=1)}\\n')\n",
        "\n",
        "print(f'Sum over the first and second axis:\\n{np.sum(a, axis=(0, 1))}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ow68OnXKrpjt"
      },
      "source": [
        "Multiplication examples:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ySvxmhzFQOxp"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Multiply all elements:\n",
            "720\n",
            "\n",
            "Multiply over rows (first axis):\n",
            "[ 4 10 18]\n"
          ]
        }
      ],
      "source": [
        "print(f'Multiply all elements:\\n{np.prod(a)}\\n')\n",
        "\n",
        "print(f'Multiply over rows (first axis):\\n{np.prod(a, axis=0)}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N0teDiz7rvwE"
      },
      "source": [
        "Min and max:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1yyLUu8UQPgf"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Minimum of all elements:\n",
            "1\n",
            "\n",
            "Minimum over rows (first axis):\n",
            "[1 2 3]\n"
          ]
        }
      ],
      "source": [
        "print(f'Minimum of all elements:\\n{np.min(a)}\\n')\n",
        "\n",
        "print(f'Minimum over rows (first axis):\\n{np.min(a, axis=0)}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fqoGqnILQQSO"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Maximum of all elements:\n",
            "6\n",
            "\n",
            "Maximum over rows (first axis):\n",
            "[4 5 6]\n"
          ]
        }
      ],
      "source": [
        "print(f'Maximum of all elements:\\n{np.max(a)}\\n')\n",
        "\n",
        "print(f'Maximum over rows (first axis):\\n{np.max(a, axis=0)}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-mjEgoN6t5Uo"
      },
      "source": [
        "Mean:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FDqexTrHQRix"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Mean of all elements:\n",
            "3.5\n",
            "\n",
            "Mean over rows (first axis):\n",
            "[2.5 3.5 4.5]\n"
          ]
        }
      ],
      "source": [
        "print(f'Mean of all elements:\\n{np.mean(a)}\\n')\n",
        "\n",
        "print(f'Mean over rows (first axis):\\n{np.mean(a, axis=0)}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BojifU7tuCyJ"
      },
      "source": [
        "Standard deviation:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SlA1p-HnQQ4J"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Std of all elements:\n",
            "1.707825127659933\n",
            "\n",
            "Std over rows (first axis):\n",
            "[1.5 1.5 1.5]\n"
          ]
        }
      ],
      "source": [
        "print(f'Std of all elements:\\n{np.std(a)}\\n')\n",
        "\n",
        "print(f'Std over rows (first axis):\\n{np.std(a, axis=0)}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "efV-dFnbC9vQ"
      },
      "source": [
        "#### Linear algebra\n",
        "\n",
        "NumPy supports a large amount of linear algebra routines. Here, we will introduce the dot product, matrix multiplication, and einstein summation.\n",
        "\n",
        "If you would like to learn more about linear algebra, we recommend [this MIT course](https://ocw.mit.edu/courses/mathematics/18-06-linear-algebra-spring-2010/video-lectures/)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "--yKCEjGuT7w"
      },
      "source": [
        " Let's start by defining some matrices:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "r0a18-Z4xGIn"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(2, 2)\n",
            "(2, 2)\n"
          ]
        }
      ],
      "source": [
        "a = np.array([[1, 2],\n",
        "              [3, 4]])\n",
        "b = np.array([[5, 6],\n",
        "              [7, 8]])\n",
        "print(a.shape)\n",
        "print(b.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TkkFxrjaubS7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(1, 2)\n",
            "(2, 1)\n"
          ]
        }
      ],
      "source": [
        "v = np.array([[1, 0]])\n",
        "w = np.array([[2], [3]])\n",
        "print(v.shape)\n",
        "print(w.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vl1fcfTgNkdU"
      },
      "source": [
        "Let's do the following matrix-vector multiplication $\\begin{pmatrix}\n",
        "  1 \u0026 2  \\\\\n",
        "  3 \u0026 4  \\\\\n",
        " \\end{pmatrix}  \\begin{pmatrix}\n",
        "  2  \\\\\n",
        "  3  \\\\\n",
        " \\end{pmatrix}\n",
        "$:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f7Sfz-23xGme"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(2, 2) (2, 1) \n",
            "\n",
            "[[ 8]\n",
            " [18]]\n"
          ]
        }
      ],
      "source": [
        "print(a.shape, w.shape, '\\n')\n",
        "\n",
        "print(np.dot(a, w))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xCpMgJ3nOXR6"
      },
      "source": [
        "This is how we do the following dot product $\\begin{pmatrix}\n",
        "  1 \u0026 0  \\\\\n",
        " \\end{pmatrix}  \\begin{pmatrix}\n",
        "  2  \\\\\n",
        "  3  \\\\\n",
        " \\end{pmatrix}\n",
        "$:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xK7lUoJ6SWca"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(1, 2) (2, 1)\n",
            "[[2]]\n"
          ]
        }
      ],
      "source": [
        "print(v.shape, w.shape)\n",
        "print(np.dot(v, w))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m6QvL9I3OnIp"
      },
      "source": [
        "and we can use `np.matmul` to do this matrix-matrix multiplication $\\begin{pmatrix}\n",
        "  1 \u0026 2  \\\\\n",
        "  3 \u0026 4  \\\\\n",
        " \\end{pmatrix}  \\begin{pmatrix}\n",
        "  5 \u0026 6  \\\\\n",
        "  7 \u0026 8  \\\\\n",
        " \\end{pmatrix}\n",
        "$:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lQBlBmURRKQi"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(2, 2) (2, 2)\n",
            "[[19 22]\n",
            " [43 50]]\n"
          ]
        }
      ],
      "source": [
        "print(a.shape, b.shape)\n",
        "print(np.matmul(a, b))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cHf3VuJWvB0f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[19 22]\n",
            " [43 50]]\n"
          ]
        }
      ],
      "source": [
        "print(a @ b)  # @ is shorthand for matmul."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CgzSBUD2O2Uk"
      },
      "source": [
        "As in linear algebra, this operation $\\begin{pmatrix}\n",
        "  1 \u0026 2  \\\\\n",
        "  3 \u0026 4  \\\\\n",
        " \\end{pmatrix}  \\begin{pmatrix}\n",
        "  1 \u0026 0  \\\\\n",
        " \\end{pmatrix}\n",
        "$ is invalid because the inner dimensions of the matrix and the vector do not agree and will raise a `ValueError`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iPwJgKCESMFJ"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(2, 2) (1, 2)\n"
          ]
        },
        {
          "ename": "ValueError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m\u003cipython-input-160-4f62c64de40f\u003e\u001b[0m in \u001b[0;36m\u003cmodule\u003e\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# Inner dimensions of the two matrices must match, as per the requirement\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# of the dot product / matrix multiplication.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----\u003e 4\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatmul\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0;31m# ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;31m# with gufunc signature (n?,k),(k,m?)-\u003e(n?,m?) (size 1 is different from 2)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)-\u003e(n?,m?) (size 1 is different from 2)"
          ]
        }
      ],
      "source": [
        "print(a.shape, v.shape)\n",
        "# Inner dimensions of the two matrices must match, as per the requirement\n",
        "# of the dot product / matrix multiplication.\n",
        "print(np.matmul(a, v))\n",
        "# ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0,\n",
        "# with gufunc signature (n?,k),(k,m?)-\u003e(n?,m?) (size 1 is different from 2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "psZph4mOvGTt"
      },
      "source": [
        "#### Einsum notation"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fhubfc4BxrdD"
      },
      "source": [
        "If there is one piece of NumPy functionality you should master, it is **Einsum notation**. Since this will be a quick introduction, you might not get all the bits and bobs relating to it, so we highly recommend you check some of the links below.\n",
        "\n",
        "The [Einstein summation (notation)](https://en.wikipedia.org/wiki/Einstein_notation) is a convenient way to represent operations over a set of arrays simply by indicating the input and output indices.\n",
        "\n",
        "For example:\n",
        "`np.einsum('ij,jk-\u003eik', a, b)` is the einsum notation for matrix multiplication between matrices `a` and `b`. The crucial bit is in the `ij,jk-\u003eik` notation which does the following:\n",
        "- Everything before the `-\u003e` symbol represents the indices of the input, and everything after represents the indices of the resulting output.\n",
        "- Repeating indices in the input (e.g `j`) denote that the values along those axes will be multiplied together.\n",
        "- Missing indices in the output (again `j`) denote that values along that axes will be summed.\n",
        "\n",
        "Let's now draw a parallel between `ij,jk-\u003eik` and the mathematical notation that it seeks to simplify:\n",
        "\u003ccenter\u003e\n",
        "$result_{ik} = \\sum_j A_{ij} B_{jk}$\n",
        "\u003c/center\u003e\n",
        "We can see that:\n",
        "- The elements on the right hand side of the expression will be multiplied by iterating over the shared index `j`\n",
        "- We're summing over the index `j`, and since that index is missing on the left hand side, we can omit the summation and abbreviate the notation like this:\n",
        "\u003ccenter\u003e\n",
        "$result_{ik} = A_{ij} B_{jk}$\n",
        "\u003c/center\u003e\n",
        "Now we have a direct relationship between the mathematical notation and the operation string `ij,jk-\u003eik`!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rjCl8CBg5u_c"
      },
      "source": [
        "Let's see what we can do with einsum next..."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dtZTBvBdyOFA"
      },
      "outputs": [],
      "source": [
        "a = np.array([[1, 2],\n",
        "              [3, 4]])\n",
        "b = np.array([[5, 6],\n",
        "              [7, 8]])\n",
        "\n",
        "v = np.array([[1, 0]])\n",
        "w = np.array([[2], [3]])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "L96tKA0iTcX6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 2]\n",
            " [3 4]] \n",
            "\n",
            "[[5 6]\n",
            " [7 8]] \n",
            "\n",
            "Matrix multiplication:\n",
            "[[19 22]\n",
            " [43 50]]\n"
          ]
        }
      ],
      "source": [
        "print(a, '\\n')\n",
        "\n",
        "print(b, '\\n')\n",
        "\n",
        "print('Matrix multiplication:')\n",
        "print(np.einsum('ij,jk-\u003eik', a, b))  # Equivalent to np.matmul(a, b)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PADLTZSH2Coy"
      },
      "source": [
        "We can easily do transposition with einsum too, as:\n",
        "\n",
        "\u003ccenter\u003e\n",
        "$result_{ij} = A_{ji}$\n",
        "\u003c/center\u003e"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QRd9KRB2zWmQ"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 2]\n",
            " [3 4]] \n",
            "\n",
            "[[5 6]\n",
            " [7 8]] \n",
            "\n",
            "Transposition:\n",
            "[[1 3]\n",
            " [2 4]]\n"
          ]
        }
      ],
      "source": [
        "print(a, '\\n')\n",
        "\n",
        "print(b, '\\n')\n",
        "\n",
        "print('Transposition:')\n",
        "print(np.einsum('ij-\u003eji', a))  # Transposition."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cD-UPpAJ2Qch"
      },
      "source": [
        "Summing over the columns is one index away:\n",
        "\u003ccenter\u003e\n",
        "$result_{j} = \\sum_{i} A_{ij}$\n",
        "\u003c/center\u003e"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pcXlHqgszW8u"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[4 6]\n"
          ]
        }
      ],
      "source": [
        "print(np.einsum('ij-\u003ej', a))  # Row sum."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sjGAeRH02dFf"
      },
      "source": [
        "We can also sum over the whole matrix:\n",
        "\u003ccenter\u003e\n",
        "$result = \\sum_{i} \\sum_{j} A_{ij}$\n",
        "\u003c/center\u003e"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-jSq1MrSzXPQ"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10\n"
          ]
        }
      ],
      "source": [
        "print(np.einsum('ij-\u003e', a))  # Sum over all axes."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CUNBKVMF26ET"
      },
      "source": [
        "Elementwise multiplication:\n",
        "\u003ccenter\u003e\n",
        "$result_{ij} = A_{ij} * B_{ij}$\n",
        "\u003c/center\u003e"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qEl19udD227D"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 5 12]\n",
            " [21 32]]\n"
          ]
        }
      ],
      "source": [
        "print(np.einsum('ij,ij-\u003eij', a, b))  # Sum over all axes."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q2eT-KfC3Mfw"
      },
      "source": [
        "We can also do operations with multiple arrays/tensors at the same time:\n",
        "\u003ccenter\u003e\n",
        "$result_{ij} = \\sum_{j} \\sum_{k} A_{ij} * B_{jk} * C_{kl}$\n",
        "\u003c/center\u003e"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uV7keb5I23Jp"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[19 22]\n",
            " [43 50]]\n"
          ]
        }
      ],
      "source": [
        "c = np.eye(2, dtype=np.int32)\n",
        "\n",
        "print(np.einsum('ij,jk,kl-\u003eil', a, b, c))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NQvMULowxrB4"
      },
      "source": [
        "Additional einsum resources:\n",
        "- https://ajcr.net/Basic-guide-to-einsum/\n",
        "- https://rockt.github.io/2018/04/30/einsum\n",
        "- https://obilaniu6266h16.wordpress.com/2016/02/04/einstein-summation-in-numpy/\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FJKn0MsQaO9x"
      },
      "source": [
        "### Broadcasting\n",
        "\n",
        "**Broadcasting** is the mechanism that enables using arrays of different shapes during binary arithmetic operations.\n",
        "What broadcasting does can be thought of as repeating a smaller array so that it fits the size of the larger array, thereby making their shapes compatible.\n",
        "Broadcasting is at the essence of vectorising array operations and it makes certain operations much more efficient because it does not copy data.\n",
        "\n",
        "Broadcasting is easiest to understand visually. In each case below (each row is a separate case), see if you can follow along how NumPy will \"repeat\" the smaller array on the right to make it \"fit\" with the larger array on the left:\n",
        "\n",
        "![picture](https://storage.googleapis.com/dm-educational/assets/intro-to-python-and-numpy/broadcasting.svg)\n",
        "\n",
        "Note also that a `ValueError` will be thrown if it's not possible to make broadcasting work.\n",
        "\n",
        "\n",
        "\n",
        "Concretely, broadcasting works like this:\n",
        "- NumPy compares shapes of two arrays elementwise\n",
        "- if their shapes are of different sizes, prepend ones to the shape of the shorter array until they're the same size\n",
        "- start the comparison with the trailing (rightmost, last) axis, and works towards the leading (leftmost, first) axis\n",
        "- the dimensions are compatible when:\n",
        "  - they are equal\n",
        "  - one of them equals 1\n",
        "- if there's a mismatch, an exception is thrown\n",
        "\n",
        "Let's see this on an example:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E1-FMXx2l5DV"
      },
      "source": [
        "Let's check the examples from above:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MUyc2jDDmZ2E"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[2 3 4 5]]\n"
          ]
        }
      ],
      "source": [
        "a = np.array([[1, 2, 3, 4]])\n",
        "b = np.array([1])\n",
        "print(a + b)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Uh7K28I2l3XP"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 2  4  6  8]\n",
            " [ 6  8 10 12]]\n"
          ]
        }
      ],
      "source": [
        "a = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
        "b = np.array([1, 2, 3, 4])\n",
        "print(a + b)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BHXGnJhOmjtt"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 2  3  4  5]\n",
            " [ 7  8  9 10]]\n"
          ]
        }
      ],
      "source": [
        "a = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
        "b = np.array([[1], [2]])\n",
        "print(a + b)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1JfCUh-GmnOG"
      },
      "outputs": [
        {
          "ename": "ValueError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m\u003cipython-input-171-c7ea0051c13a\u003e\u001b[0m in \u001b[0;36m\u003cmodule\u003e\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# ValueError: operands could not be broadcast together with shapes (2,4) (1,2).\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----\u003e 4\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (2,4) (1,2) "
          ]
        }
      ],
      "source": [
        "a = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
        "b = np.array([[1, 2]])\n",
        "# ValueError: operands could not be broadcast together with shapes (2,4) (1,2).\n",
        "print(a + b)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a1puUfecxJCu"
      },
      "source": [
        "Broadcasting is efficient and often used. However, you need to be careful with your tensor sizes – broadcasting can be a source of difficult-to-detect bugs in your code in the case where you don't want the broadcast to be done, but because of the compatible tensor sizes, it will still be executed.\n",
        "\n",
        "For example, if you erroneously removed the leading axis of a tensor, broadcasting will still work when operating to the original tensor because of the shape compatibility – the leading dimension will simply be repeated). You can guard against such errors by using **defensive programming**, which can involve frequently checking that your tensors are the shape you expect them to be.\n",
        "\n",
        "Some further resources on broadcasting:\n",
        "- [NumPy docs](https://numpy.org/doc/stable/user/basics.broadcasting.html)\n",
        "- [SciPy docs](http://scipy.github.io/old-wiki/pages/EricsBroadcastingDoc)\n",
        "- [Python Data Science Handbook](https://jakevdp.github.io/PythonDataScienceHandbook/02.05-computation-on-arrays-broadcasting.html)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gmRMn56oZiGI"
      },
      "source": [
        "### Array manipulation\n",
        "\n",
        "NumPy supports a large array of array manipulation functions. Here, we focus on a small number of them that are frequently used in deep learning."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XR_6Hmb3GRx_"
      },
      "source": [
        "#### Shape changers\n",
        "\n",
        "Shape changing functions change the shape of the array without changing the underlying data."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9jeAPJyzoNN7"
      },
      "source": [
        "`np.reshape` will reshape the existing data. The result will be the same data with the new shape. Note that the old shape and the new requested shape need to be compatible – they must contain the same number of elements across the old and the new shape):"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Qe541BsJ0WAi"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 0  1  2  3  4  5  6  7  8  9 10 11]\n",
            "Shape: (12,) \n",
            "\n",
            "[[ 0  1  2  3]\n",
            " [ 4  5  6  7]\n",
            " [ 8  9 10 11]]\n",
            "Shape: (3, 4) \n",
            "\n",
            "[[ 0  1  2  3  4  5]\n",
            " [ 6  7  8  9 10 11]]\n",
            "Shape: (2, 6)\n"
          ]
        }
      ],
      "source": [
        "a = np.arange(12)\n",
        "print(a)\n",
        "print('Shape:', a.shape, '\\n')\n",
        "\n",
        "b = np.reshape(a, [3, 4])\n",
        "print(b)\n",
        "print('Shape:', b.shape, '\\n')\n",
        "c = np.reshape(a, [2, 6])  # Gives a new shape to the data.\n",
        "\n",
        "print(c)\n",
        "print('Shape:', c.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xyw_vj1ix_Ja"
      },
      "source": [
        "For example, the following won't work because the old and the new shapes do not agree:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CmfQPTMqoiLB"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Shape: (3, 4)\n"
          ]
        },
        {
          "ename": "ValueError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m\u003cipython-input-173-4ca7200aa702\u003e\u001b[0m in \u001b[0;36m\u003cmodule\u003e\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Shape:'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# ValueError: cannot reshape array of size 12 into shape (2,7)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----\u003e 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m7\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m\u003c__array_function__ internals\u003e\u001b[0m in \u001b[0;36mreshape\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numpy/core/fromnumeric.py\u001b[0m in \u001b[0;36mreshape\u001b[0;34m(a, newshape, order)\u001b[0m\n\u001b[1;32m    296\u001b[0m            [5, 6]])\n\u001b[1;32m    297\u001b[0m     \"\"\"\n\u001b[0;32m--\u003e 298\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0m_wrapfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'reshape'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnewshape\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morder\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0morder\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    299\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    300\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numpy/core/fromnumeric.py\u001b[0m in \u001b[0;36m_wrapfunc\u001b[0;34m(obj, method, *args, **kwds)\u001b[0m\n\u001b[1;32m     55\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     56\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---\u003e 57\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mbound\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     58\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     59\u001b[0m         \u001b[0;31m# A TypeError occurs if the object does have such a method in its\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: cannot reshape array of size 12 into shape (2,7)"
          ]
        }
      ],
      "source": [
        "print('Shape:', b.shape)\n",
        "# ValueError: cannot reshape array of size 12 into shape (2,7)\n",
        "print(np.reshape(a, [2, 7]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xf8cj798oZY9"
      },
      "source": [
        "`np.transpose` does transposition on vectors and matrices:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8CABQprj0YYH"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 0  1  2  3]\n",
            " [ 4  5  6  7]\n",
            " [ 8  9 10 11]]\n",
            "Shape: (3, 4) \n",
            "\n",
            "[[ 0  4  8]\n",
            " [ 1  5  9]\n",
            " [ 2  6 10]\n",
            " [ 3  7 11]]\n",
            "Shape: (4, 3)\n"
          ]
        }
      ],
      "source": [
        "c = np.transpose(b)  # Permutes the axes of the data.\n",
        "print(b)\n",
        "print('Shape:', b.shape, '\\n')\n",
        "\n",
        "print(c)\n",
        "print('Shape:', c.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Co1-kGluoelU"
      },
      "source": [
        "`np.expand_dims` expands the number of dimensions (axes) by creating a new dimension of size `1`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "am6sGS5G0e8_"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 0  1  2  3  4  5  6  7  8  9 10 11]\n",
            "Shape: (12,) \n",
            "\n",
            "[[ 0  1  2  3  4  5  6  7  8  9 10 11]]\n",
            "Shape: (1, 12) \n",
            "\n",
            "[[ 0]\n",
            " [ 1]\n",
            " [ 2]\n",
            " [ 3]\n",
            " [ 4]\n",
            " [ 5]\n",
            " [ 6]\n",
            " [ 7]\n",
            " [ 8]\n",
            " [ 9]\n",
            " [10]\n",
            " [11]]\n",
            "Shape: (12, 1)\n"
          ]
        }
      ],
      "source": [
        "print(a)\n",
        "print('Shape:', a.shape, '\\n')\n",
        "\n",
        "d = np.expand_dims(a, axis=0)   # Expand the number of axes.\n",
        "print(d)\n",
        "print('Shape:', d.shape, '\\n')\n",
        "\n",
        "e = np.expand_dims(a, axis=-1)  # Expand the number of axes.\n",
        "print(e)\n",
        "print('Shape:', e.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gdYyS7fCogJD"
      },
      "source": [
        "`np.squeeze` removes any axes of size `1`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XpZAt7yGGj5q"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 0]\n",
            " [ 1]\n",
            " [ 2]\n",
            " [ 3]\n",
            " [ 4]\n",
            " [ 5]\n",
            " [ 6]\n",
            " [ 7]\n",
            " [ 8]\n",
            " [ 9]\n",
            " [10]\n",
            " [11]]\n",
            "Shape: (12, 1) \n",
            "\n",
            "[ 0  1  2  3  4  5  6  7  8  9 10 11]\n",
            "Shape: (12,)\n"
          ]
        }
      ],
      "source": [
        "print(e)\n",
        "print('Shape:', e.shape, '\\n')\n",
        "f = np.squeeze(e)     # remove axes of size 1\n",
        "\n",
        "print(f)\n",
        "print('Shape:', f.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oGcrcuogGZ3P"
      },
      "source": [
        "#### Joining and splitting\n",
        "\n",
        "Often it is useful to join multiple vectors/matrices/tensors into a bigger one, or to split a bigger one into smaller ones. For this, we use joining and splitting functions:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dx0ZJkUaGkMC"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0 0]\n",
            " [0 0]\n",
            " [0 0]] \n",
            "\n",
            "[[1 1]\n",
            " [1 1]\n",
            " [1 1]]\n"
          ]
        }
      ],
      "source": [
        "a = np.zeros([3, 2], dtype=np.int32)\n",
        "b = np.ones([3, 2], dtype=np.int32)\n",
        "print(a, '\\n')\n",
        "\n",
        "print(b)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VB3DZwHpHIR1"
      },
      "source": [
        "`np.concatenate` will concatenate along an existing axis. Depending on which axes we concatenate along, we will get a different result:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DXBwRhYTG1ih"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0 0]\n",
            " [0 0]\n",
            " [0 0]\n",
            " [1 1]\n",
            " [1 1]\n",
            " [1 1]]\n",
            "\n",
            "Shape: (6, 2)\n"
          ]
        }
      ],
      "source": [
        "c = np.concatenate([a, b], axis=0)\n",
        "print(c)\n",
        "print('\\nShape:', c.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bpax5Q9F0xb6"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0 0 1 1]\n",
            " [0 0 1 1]\n",
            " [0 0 1 1]]\n",
            "\n",
            "Shape: (3, 4)\n"
          ]
        }
      ],
      "source": [
        "d = np.concatenate([a, b], axis=1)\n",
        "print(d)\n",
        "print('\\nShape:', d.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rtui7aVUHbnu"
      },
      "source": [
        "`np.stack`, on the other hand, will stack our matrices along a new axis – it will create a tensor with a rank larger by 1, which contains our matrices as slices:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Akmihl350_6k"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[[0 0]\n",
            "  [0 0]\n",
            "  [0 0]]\n",
            "\n",
            " [[1 1]\n",
            "  [1 1]\n",
            "  [1 1]]]\n",
            "\n",
            "Shape: (2, 3, 2)\n"
          ]
        }
      ],
      "source": [
        "e = np.stack([a, b], axis=0)\n",
        "print(e)\n",
        "print('\\nShape:', e.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "poV0HL5SH1mK"
      },
      "source": [
        "Let's slice the new tensor `e` tp check where the matrix `a` is:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hoHosUkwzC46"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[0, 0],\n",
              "       [0, 0],\n",
              "       [0, 0]], dtype=int32)"
            ]
          },
          "execution_count": 181,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "e[0]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zokkzUERzD7S"
      },
      "source": [
        "This is equivalent to:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "U_nhjENwHz-t"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[0, 0],\n",
              "       [0, 0],\n",
              "       [0, 0]], dtype=int32)"
            ]
          },
          "execution_count": 182,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "e[0, :, :]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "enp-DrpHzF3q"
      },
      "source": [
        "And we can find the matrix `b` at index 1:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DEGIVCOkzJur"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "array([[1, 1],\n",
              "       [1, 1],\n",
              "       [1, 1]], dtype=int32)"
            ]
          },
          "execution_count": 183,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "e[1]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K6Y942PRp22h"
      },
      "source": [
        "`np.split` splits an array into subarrays.\n",
        "\n",
        "If we pass an integer `n` to `np.split`, it will try to split the axis into `n` equal parts:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VrKH43s91LAX"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Input: [0 1 2 3 4 5 6 7 8 9]\n",
            "\n",
            "Split into 2 parts along the first axis:\n",
            "[0 1 2 3 4]\n",
            "[5 6 7 8 9]\n",
            "\n",
            "Split into 5 parts along the first axis:\n",
            "[0 1]\n",
            "[2 3]\n",
            "[4 5]\n",
            "[6 7]\n",
            "[8 9]\n"
          ]
        }
      ],
      "source": [
        "a = np.arange(10)\n",
        "print('Input:', a)\n",
        "print('\\nSplit into 2 parts along the first axis:')\n",
        "split_res = np.split(a, 2, axis=0)\n",
        "for elem in split_res:\n",
        "  print(elem)\n",
        "\n",
        "print('\\nSplit into 5 parts along the first axis:')\n",
        "split_res = np.split(a, 5, axis=0)\n",
        "for elem in split_res:\n",
        "  print(elem)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "If1PHcBDqcec"
      },
      "source": [
        "If we pass `np.split` an array/list instead of a number of parts, it will split the NumPy array `a` in a way that each element of the array signifies a splitting point, e.g.:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2veyVKPzqzeS"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Input: [0 1 2 3 4 5 6 7 8 9]\n",
            "\n",
            "Split array into 4 parts using the split point indices [1, 5, 8] along the first axis:\n",
            "[0]\n",
            "[1 2 3 4]\n",
            "[5 6 7]\n",
            "[8 9]\n"
          ]
        }
      ],
      "source": [
        "print('Input:', a)\n",
        "print('\\nSplit array into 4 parts using the split point indices [1, 5, 8] '\n",
        "      'along the first axis:')\n",
        "split_res = np.split(a, [1, 5, 8], axis=0)\n",
        "for elem in split_res:\n",
        "  print(elem)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0CjaPtUyGaOU"
      },
      "source": [
        "#### Tiling\n",
        "\n",
        "Sometimes it is useful to be able to repeat the same array multiple times. This is reminiscent of broadcasting, but do not use tiling for broadcasting because broadcasting is simply more efficient."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "56DNQ9z9rpqX"
      },
      "source": [
        "`np.tile` repeats a given array. The second argument to `np.tile` can simply be a number:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q1sG5SSyGkdH"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0 1 2]\n",
            " [3 4 5]]\n",
            "\n",
            "Tiled array:\n",
            " [[0 1 2 0 1 2]\n",
            " [3 4 5 3 4 5]]\n"
          ]
        }
      ],
      "source": [
        "a = np.array([[0, 1, 2],\n",
        "              [3, 4, 5]])\n",
        "print(a)\n",
        "print('\\nTiled array:\\n', np.tile(a, 2))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y9qNcooFsyuC"
      },
      "source": [
        "or a list/tuple/array which defines repetition per dimension:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eyxDNLz0syNS"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0 1 2]\n",
            " [3 4 5]]\n",
            "\n",
            "Tiled array:\n",
            " [[0 1 2 0 1 2]\n",
            " [3 4 5 3 4 5]\n",
            " [0 1 2 0 1 2]\n",
            " [3 4 5 3 4 5]\n",
            " [0 1 2 0 1 2]\n",
            " [3 4 5 3 4 5]]\n"
          ]
        }
      ],
      "source": [
        "print(a)\n",
        "# Repeat 3 times in the row dimension, and twice in the column dimension.\n",
        "print('\\nTiled array:\\n', np.tile(a, (3, 2)))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NbH0ssJCrqx2"
      },
      "source": [
        "`np.repeat` repeats an array on a particular axis:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uxL3OYTyZer7"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0 1 2]\n",
            " [3 4 5]]\n",
            "\n",
            "Tiled array:\n",
            " [[0 1 2]\n",
            " [0 1 2]\n",
            " [3 4 5]\n",
            " [3 4 5]]\n"
          ]
        }
      ],
      "source": [
        "print(a)\n",
        "print('\\nTiled array:\\n', np.repeat(a, 2, axis=0))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IEn2xOhWtF09"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0 1 2]\n",
            " [3 4 5]]\n",
            "\n",
            "Tiled array:\n",
            " [[0 0 1 1 2 2]\n",
            " [3 3 4 4 5 5]]\n"
          ]
        }
      ],
      "source": [
        "print(a)\n",
        "print('\\nTiled array:\\n', np.repeat(a, 2, axis=1))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qjra-W519mjt"
      },
      "source": [
        "### Other\n",
        "\n",
        "NumPy contains a plethora of useful functions. We enumerate some of the more often used functions here:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "01l4m7CGtf-e"
      },
      "source": [
        "`np.argmax` or argument of the maximum are the indices of the maximum value (optionally along an axis):"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2jh2_gknzjhj"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 2 3 4]\n",
            " [5 6 7 8]\n",
            " [9 0 1 2]]\n",
            "\n",
            "Argmax along axis=0: [2 1 1 1]\n",
            "\n",
            "Argmax along axis=1: [3 3 0]\n"
          ]
        }
      ],
      "source": [
        "a = np.array([[1, 2, 3, 4],\n",
        "              [5, 6, 7, 8],\n",
        "              [9, 0, 1, 2]])\n",
        "print(a)\n",
        "print('\\nArgmax along axis=0:', np.argmax(a, axis=0))\n",
        "print('\\nArgmax along axis=1:', np.argmax(a, axis=1))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F7CGLkNwuDOM"
      },
      "source": [
        "Interestingly, if we run `np.argmax` on an array of rank \u003e 2, we might expect rank-dimensional indices (e.g. we might expect 2 indices for a matrix). However, we get an index of the flattened version of the array:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OTfK2G1OuB5E"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "8\n"
          ]
        }
      ],
      "source": [
        "print(np.argmax(a))   # We might expect [2, 0] as a result, but alas, no such luck!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jSjj_f4-uWCz"
      },
      "source": [
        "But then we can use `np.unravel_index` to get the indices in the original matrix:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "atVyxLzMuVpW"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(2, 0)\n"
          ]
        }
      ],
      "source": [
        "print(np.unravel_index(np.argmax(a), a.shape))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RpMz-6-Ytuu0"
      },
      "source": [
        "`np.where`, based on the condition, returns elements of either one or the other of its array arguments:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WY1AvRmX9iGk"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "a:\n",
            " [[0 1 2]\n",
            " [3 4 5]\n",
            " [6 7 8]]\n",
            "b:\n",
            " [[0 0 0]\n",
            " [0 0 0]\n",
            " [0 0 0]]\n",
            "\n",
            "Result of the `np.where`:\n",
            "[[0 0 2]\n",
            " [0 4 0]\n",
            " [6 0 8]]\n"
          ]
        }
      ],
      "source": [
        "a = np.reshape(np.arange(9), (3, 3))\n",
        "b = np.zeros_like(a)\n",
        "print('a:\\n', a)\n",
        "print('b:\\n', b)\n",
        "print('\\nResult of the `np.where`:')\n",
        "print(np.where(a % 2 == 0, a, b))  # All odd elements of `a` get zeroed-out."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QH0rnV2jutrK"
      },
      "source": [
        "### Suggested exercises\n",
        "\n",
        "- Can you reproduce the result of a `np.full` by using `np.ones`? Hint: broadcasting to the rescue?\n",
        "- Can you reproduce the result of `np.zeros_like` by using `np.zeros`? Hint: how would you provide the size information?\n",
        "- What is the difference between `a[1, 1:2]`, `a[1, [1]]` and `a[1, 1]`?\n",
        "- Can you create a matrix containing the integers 0 to 11 of the shape (4, 3) and (6, 2), starting from array creation using `np.arange`?\n",
        "- Can you count the total number of elements in an array by using some of the aggregation functions? Hint: try using the shape information, or `np.ones_like`.\n",
        "- Do the outer product of two vectors by calling `np.outer` and by broadcasting!\n",
        "- Do a bilinear product $a^T W b$ with einsum, where $a$ and $b$ are vectors, and $W$ is an appropriately shaped matrix."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rj7YrGVGutBE"
      },
      "source": [
        "Whew, thanks for sticking with us until the end of this tutorial!\n",
        "\n",
        "This tutorial was inspired by the [Introduction to Numpy tutorial](https://github.com/eemlcommunity/PracticalSessions2019/blob/master/introductory/Intro_Numpy.ipynb) from EEML, and all the other fantastic resources referenced within this colab! :)\n",
        "\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "Introduction to Python and NumPy for Deep Learning.ipynb",
      "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"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}