introductory/Intro_Numpy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Intro: Numpy.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    }
  },
  "cells": [
    {
      "metadata": {
        "id": "TK_s931vVvwi",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Numpy\n",
        "\n",
        "\" NumPy is the fundamental package for scientific computing with Python.  It contains among other things:\n",
        "\n",
        "* a powerful N-dimensional array object\n",
        "* sophisticated (broadcasting) functions\n",
        "* useful linear algebra, Fourier transform, and random number capabilities \"\n",
        "\n",
        "\n",
        "-- From the [NumPy](http://www.numpy.org/) landing page.\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "kVwjoPsFGgbH",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Before learning about numpy, we introduce..\n",
        "\n",
        "### The NXOR Function\n",
        "\n",
        "Many of the exercises involve working with the  $\\mathrm{NXOR} \\colon \\; [-1, 1]^2  \\rightarrow \\{-1, +1\\}$ function defined as \n",
        "\n",
        "$$ (x_1, x_2) \\longmapsto \\mathrm{sgn}(x_1 \\cdot x_2) .$$\n",
        "\n",
        "where for $x_1 \\cdot x_2 = 0$ we let $\\mathrm{NXOR}(x_1, x_2) = -1$.\n",
        "\n",
        "We can visualize this function as\n",
        "\n",
        "![A set of points in \\[-1, +1\\]^2 with green and red markers denoting the value assigned to them by the NXOR function](https://github.com/tmlss2018/PracticalSessions/blob/master/assets/nxor_labels.png?raw=true)\n",
        "\n",
        "where each point in $ [-1, 1]^2$ is marked by green (+1) or red (-1) according to the value assigned to it by the NXOR function.\n",
        "\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "9HfKNF9JG3Sg",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "\n",
        "Over the course of the intro lab exercises we will\n",
        "\n",
        "1. Generate such data with numpy.\n",
        "2. Create the plot above with matplotlib.\n",
        "3. Train a model to learn this function.\n"
      ]
    },
    {
      "metadata": {
        "id": "psAhyeala4Qa",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Setup and imports. Run the following cell."
      ]
    },
    {
      "metadata": {
        "id": "jJmfT0IMa494",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "from __future__ import absolute_import\n",
        "from __future__ import division\n",
        "from __future__ import print_function\n",
        "\n",
        "import numpy as np\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "209T8819ws6R",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Random numbers in numpy"
      ]
    },
    {
      "metadata": {
        "id": "HPoRLRxdwyHs",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        },
        "outputId": "4d166286-cc6f-4221-a86e-4140a003044c"
      },
      "cell_type": "code",
      "source": [
        "np.random.random((3, 2))  # Array of shape (3, 2), entries uniform in [0, 1)."
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.60276338, 0.54488318],\n",
              "       [0.4236548 , 0.64589411],\n",
              "       [0.43758721, 0.891773  ]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "metadata": {
        "id": "d1xeqjN_eGrM",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Note that (as usual in computing) numpy produces pseudo-random numbers based on a seed, or more precisely a random state. In order to make random sequences and calculations based on reproducible, use\n",
        "\n",
        "* the [`np.random.seed()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.seed.html) function to set the default global seed, or\n",
        "* the [`np.random.RandomState`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.random.RandomState.html) class which is a container for a pseudo-random number generator and exposes methods for generating random numbers.\n"
      ]
    },
    {
      "metadata": {
        "id": "knUtcFWoFqK0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "outputId": "2676bd0a-898d-4c37-bc7e-4a67dc7da825"
      },
      "cell_type": "code",
      "source": [
        "np.random.seed(0)\n",
        "print(np.random.random(2))\n",
        "# Reset the global random state to the same state.\n",
        "np.random.seed(0)\n",
        "print(np.random.random(2))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0.5488135  0.71518937]\n",
            "[0.5488135  0.71518937]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "Tz435THaxePN",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Numpy Array Operations 1\n",
        "\n",
        "There are a large number of operations you can run on any numpy array. Here we showcase some common ones."
      ]
    },
    {
      "metadata": {
        "id": "YZbsqkyXxgUo",
        "colab_type": "code",
        "colab": {
          "height": 215
        },
        "outputId": "d8c7ecdf-2681-49e1-eb3f-c73d5c2793d3"
      },
      "cell_type": "code",
      "source": [
        "# Create one from hard-coded data:\n",
        "ar = np.array([\n",
        "    [0.0, 0.2],\n",
        "    [0.9, 0.5],\n",
        "    [0.3, 0.7],\n",
        "], dtype=np.float64)  # float64 is the default.\n",
        "\n",
        "print('The array:\\n', ar)\n",
        "print()\n",
        "\n",
        "print('data type', ar.dtype)\n",
        "print('transpose\\n', ar.T)\n",
        "print('shape', ar.shape)\n",
        "print('reshaping an array', ar.reshape((6)))\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The array:\n",
            " [[ 0.   0.2]\n",
            " [ 0.9  0.5]\n",
            " [ 0.3  0.7]]\n",
            "\n",
            "data type float64\n",
            "transpose\n",
            " [[ 0.   0.9  0.3]\n",
            " [ 0.2  0.5  0.7]]\n",
            "shape (3, 2)\n",
            "reshaping an array [ 0.   0.2  0.9  0.5  0.3  0.7]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "s5wC8i8_4WBf",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Many numpy operations are available both as np module functions as well as array methods. For example, we can also reshape as"
      ]
    },
    {
      "metadata": {
        "id": "AjGy5myl4jxo",
        "colab_type": "code",
        "colab": {
          "height": 125
        },
        "outputId": "3d93238b-0c6c-4998-c9d3-61ee84d73491"
      },
      "cell_type": "code",
      "source": [
        "print('reshape v2', np.reshape(ar, (6, 1)))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "reshape v2 [[ 0. ]\n",
            " [ 0.2]\n",
            " [ 0.9]\n",
            " [ 0.5]\n",
            " [ 0.3]\n",
            " [ 0.7]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "Tt4G37QAGWl4",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Numpy Indexing and selectors\n",
        "\n",
        "Here are some basic indexing examples from numpy."
      ]
    },
    {
      "metadata": {
        "id": "4Bbdmb0BGXPc",
        "colab_type": "code",
        "colab": {
          "height": 71
        },
        "outputId": "adb57a4d-5bbc-46c8-b8a3-8c28babcc526"
      },
      "cell_type": "code",
      "source": [
        "ar"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0. ,  0.2],\n",
              "       [ 0.9,  0.5],\n",
              "       [ 0.3,  0.7]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "metadata": {
        "id": "6lk0NQGGGpRK",
        "colab_type": "code",
        "colab": {
          "height": 35
        },
        "outputId": "cf7c88f2-5d23-45d7-dde5-069d1dacd0b6"
      },
      "cell_type": "code",
      "source": [
        "ar[0, 1]  # row, column"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.20000000000000001"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "metadata": {
        "id": "Eh1zKgqMGpa-",
        "colab_type": "code",
        "colab": {
          "height": 35
        },
        "outputId": "15e0c3d1-17cc-437c-915e-783e7f0ece82"
      },
      "cell_type": "code",
      "source": [
        "ar[:, 1]  # slices: select all elements across the first (0th) axis."
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0.2,  0.5,  0.7])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "metadata": {
        "id": "QVo9SdiWSZqn",
        "colab_type": "code",
        "colab": {
          "height": 35
        },
        "outputId": "f9ba4ed8-b2d8-4cf1-836a-2b0c1834cacd"
      },
      "cell_type": "code",
      "source": [
        "ar[1:2, 1]  # slices with syntax from:to, selecting [from, to)."
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0.5])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "metadata": {
        "id": "n64DQFr7Subs",
        "colab_type": "code",
        "colab": {
          "height": 35
        },
        "outputId": "3b07c5d9-2fdd-4756-df4f-61f8f56769b9"
      },
      "cell_type": "code",
      "source": [
        "ar[1:, 1]  # Omit `to` to go all the way to the end"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0.5,  0.7])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "metadata": {
        "id": "Uq7bmNPVTD2B",
        "colab_type": "code",
        "colab": {
          "height": 35
        },
        "outputId": "9906745e-425f-4bea-ba01-3fbceb8c5ccb"
      },
      "cell_type": "code",
      "source": [
        "ar[:2, 1]  # Omit `from` to start from the beginning"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0.2,  0.5])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "metadata": {
        "id": "uJ7A1vVWTKQc",
        "colab_type": "code",
        "colab": {
          "height": 35
        },
        "outputId": "b36388c7-15ed-4e05-8450-2af284c0d3e1"
      },
      "cell_type": "code",
      "source": [
        "ar[0:-1, 1]  # Use negative indexing to count elements from the back."
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0.2,  0.5])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "metadata": {
        "id": "CVizP583IolT",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We can also pass boolean arrays as indices. These will exactly define which elements to select."
      ]
    },
    {
      "metadata": {
        "id": "-91q2Si7IBGN",
        "colab_type": "code",
        "colab": {
          "height": 35
        },
        "outputId": "6527af01-583f-43dc-ecff-9a894689a25e"
      },
      "cell_type": "code",
      "source": [
        "ar[np.array([\n",
        "    [True, False],\n",
        "    [False, True],\n",
        "    [True, False],\n",
        "])]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0. ,  0.5,  0.3])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "metadata": {
        "id": "g9VttyKZI2aX",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Boolean arrays can be created with logical operations, then used as selectors. Logical operators apply elementwise."
      ]
    },
    {
      "metadata": {
        "id": "KyH_50JVIWOK",
        "colab_type": "code",
        "colab": {
          "height": 71
        },
        "outputId": "8317ec82-a6aa-46ec-fd2c-34016fb69cf7"
      },
      "cell_type": "code",
      "source": [
        "ar_2 = np.array([   # Nearly the same as ar\n",
        "    [0.0, 0.1],\n",
        "    [0.9, 0.5],\n",
        "    [0.0, 0.7],\n",
        "])\n",
        "\n",
        "# Where ar_2 is smaller than ar, let ar_2 be -inf.\n",
        "ar_2[ar_2 < ar] = -np.inf\n",
        "ar_2"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0. , -inf],\n",
              "       [ 0.9,  0.5],\n",
              "       [-inf,  0.7]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "metadata": {
        "id": "-GwBK4LJGpjK",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Numpy Operations 2"
      ]
    },
    {
      "metadata": {
        "id": "gHElhCDy4SrG",
        "colab_type": "code",
        "colab": {
          "height": 179
        },
        "outputId": "bd4ae4ac-e1d9-4dd8-80f7-96f6ed9b0425"
      },
      "cell_type": "code",
      "source": [
        "print('array:\\n', ar)\n",
        "print()\n",
        "\n",
        "print('sum across axis 0 (rows):', ar.sum(axis=0))\n",
        "print('mean', ar.mean())\n",
        "print('min', ar.min())\n",
        "print('row-wise min', ar.min(axis=1))\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "array:\n",
            " [[ 0.   0.2]\n",
            " [ 0.9  0.5]\n",
            " [ 0.3  0.7]]\n",
            "\n",
            "sum across axis 0 (rows): [ 1.2  1.4]\n",
            "mean 0.433333333333\n",
            "min 0.0\n",
            "row-wise min [ 0.   0.5  0.3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "bSNi0aLs03J1",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We can also take element-wise minimums between two arrays.\n",
        "\n",
        "We may want to do this when \"clipping\" values in a matrix, that is, setting any values larger than, say, 0.6, to 0.6. We would do this in numpy with..\n",
        "\n",
        "### Broadcasting (and selectors)"
      ]
    },
    {
      "metadata": {
        "id": "GLCN0umLxuLv",
        "colab_type": "code",
        "colab": {
          "height": 71
        },
        "outputId": "267a0ab2-0c11-4583-c198-9e6d8d886983"
      },
      "cell_type": "code",
      "source": [
        "np.minimum(ar, 0.6)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0. ,  0.2],\n",
              "       [ 0.6,  0.5],\n",
              "       [ 0.3,  0.6]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "metadata": {
        "id": "Kmq7Yf_73GgC",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Numpy automatically turns the scalar 0.6 into an array the same size as `ar` in order to take element-wise minimum.\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "vkM1cL-pBrEE",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Broadcasting can save us a lot of typing, but in complicated cases it may require a good understanding of the exact rules followed.\n",
        "\n",
        "Some references:\n",
        "\n",
        "* [Numpy page that explains broadcasting](https://docs.scipy.org/doc/numpy-1.13.0/user/basics.broadcasting.html)\n",
        "* [Similar content with some visualizations](http://scipy.github.io/old-wiki/pages/EricsBroadcastingDoc)\n",
        "\n",
        "Here we follow with a selection of other useful broadcasting examples.\n"
      ]
    },
    {
      "metadata": {
        "id": "S52hBSnG5JRa",
        "colab_type": "code",
        "colab": {
          "height": 89
        },
        "outputId": "37525b66-113a-43d1-e426-8176b0672ba1"
      },
      "cell_type": "code",
      "source": [
        "# Centering our array.\n",
        "print('centered array:\\n', ar - np.mean(ar)) "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "centered array:\n",
            " [[-0.43333333 -0.23333333]\n",
            " [ 0.46666667  0.06666667]\n",
            " [-0.13333333  0.26666667]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "id": "mS5IDFrA6ig3",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Note that `np.mean()` was a scalar, but it is automatically subtracted from every element.\n"
      ]
    },
    {
      "metadata": {
        "id": "KzlVmOY_FPhQ",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We can write the minimum function ourselves, as well."
      ]
    },
    {
      "metadata": {
        "id": "zatGgBsOFNdF",
        "colab_type": "code",
        "colab": {
          "height": 71
        },
        "outputId": "9cb31429-9ded-469c-f3ac-24bd331a549a"
      },
      "cell_type": "code",
      "source": [
        "clipped_ar = ar.copy()  # So that ar is not modified.\n",
        "clipped_ar[clipped_ar > 0.6] = 0.6\n",
        "clipped_ar"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0. ,  0.2],\n",
              "       [ 0.6,  0.5],\n",
              "       [ 0.3,  0.6]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "metadata": {
        "id": "SnDqUDgtFyF5",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "A few things happened here:\n",
        "\n",
        "1. 0.6 was broadcast in for the greater than (>) operation\n",
        "2. The greater than operation defined a selector, selecting a subset of the elements of the array\n",
        "3. 0.6 was broadcast to the right number of elements for assignment."
      ]
    },
    {
      "metadata": {
        "id": "QzLtiYXUFN5P",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Vectors may also be broadcast into matrices."
      ]
    },
    {
      "metadata": {
        "id": "n2gv3YVf5JZL",
        "colab_type": "code",
        "colab": {
          "height": 71
        },
        "outputId": "012fd424-9776-43c2-dc6a-8c845f1f6dc1"
      },
      "cell_type": "code",
      "source": [
        "vec = np.array([1, 2])\n",
        "ar + vec"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1. ,  2.2],\n",
              "       [ 1.9,  2.5],\n",
              "       [ 1.3,  2.7]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "metadata": {
        "id": "7ehzlV8J75ar",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Here the shapes of the involved arrays are:\n",
        "```\n",
        "ar     (2d array):  2 x 2\n",
        "vec    (1d array):      2\n",
        "Result (2d array):  2 x 2\n",
        "```\n",
        "\n",
        "When either of the dimensions compared is one (even implicitly, like in the case of `vec`), the other is used. In other words, dimensions with size 1 are stretched or “copied” to match the other.\n",
        "\n",
        "Here, this meant that the `[1, 2]` row was repeated to match the number of rows in `ar`, then added together.\n"
      ]
    },
    {
      "metadata": {
        "id": "bBLjzt84A2ZL",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "If there is a shape mismatch, you will be informed. To try, uncomment the line below and run it."
      ]
    },
    {
      "metadata": {
        "id": "sViqTRjXAWhN",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#ar + np.array([[1, 2, 3]])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "K4pvND75AWuG",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "#### Exercise\n",
        "\n",
        "Broadcast and add the vector `[10, 20, 30]` across the columns of `ar`. \n",
        "\n",
        "You should get \n",
        "```\n",
        "array([[10. , 10.2],\n",
        "       [20.9, 20.5],\n",
        "       [30.3, 30.7]])\n",
        " ```\n"
      ]
    },
    {
      "metadata": {
        "id": "AgnJiYHm_ENT",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        "#@title Code\n",
        "\n",
        "# Recall that you can use vec.shape to verify that your array has the\n",
        "# shape you expect.\n",
        "\n",
        "### Your code here ###"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "gS1X9kt6_pLW",
        "colab_type": "code",
        "colab": {
          "height": 71
        },
        "cellView": "form",
        "outputId": "fd0e55dd-2c98-4bb5-e3ee-8bb82bf7b0fc"
      },
      "cell_type": "code",
      "source": [
        "#@title Solution\n",
        "\n",
        "vec = np.array([[10], [20], [30]])\n",
        "ar + vec"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 10. ,  10.2],\n",
              "       [ 20.9,  20.5],\n",
              "       [ 30.3,  30.7]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "metadata": {
        "id": "ZHGWztEX99vd",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### `np.newaxis`\n",
        "\n",
        "We can use another numpy feature, `np.newaxis` to simply form the column vector that was required for the example above. It adds a singleton dimension to arrays at the desired location:"
      ]
    },
    {
      "metadata": {
        "id": "ac9tsc4e5JhA",
        "colab_type": "code",
        "colab": {
          "height": 35
        },
        "outputId": "0d3ee092-3142-444a-abcc-1addfe0b06ff"
      },
      "cell_type": "code",
      "source": [
        "vec = np.array([1, 2])\n",
        "vec.shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2,)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "metadata": {
        "id": "WpG-B92VCNAL",
        "colab_type": "code",
        "colab": {
          "height": 35
        },
        "outputId": "a5a0341b-5b81-4f74-f161-0fa14a0844ae"
      },
      "cell_type": "code",
      "source": [
        "vec[np.newaxis, :].shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 2)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "metadata": {
        "id": "YdbrkV1OCz8V",
        "colab_type": "code",
        "colab": {
          "height": 35
        },
        "outputId": "f86fdf30-1158-4c5c-9d08-421dca4d3c76"
      },
      "cell_type": "code",
      "source": [
        "vec[:, np.newaxis].shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2, 1)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 28
        }
      ]
    },
    {
      "metadata": {
        "id": "KQZcrYaJxOOR",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "Now you know more than enough to generate some example data for our `NXOR` function.\n",
        "\n",
        "\n",
        "### Exercise: Generate Data for NXOR\n",
        "\n",
        "Write a function `get_data(num_examples)` that returns two numpy arrays\n",
        "\n",
        "* `inputs` of shape  `num_examples x 2` with points selected uniformly from the $[-1, 1]^2$ domain.\n",
        "* `labels` of shape `num_examples` with the associated output of `NXOR`."
      ]
    },
    {
      "metadata": {
        "id": "SlZD-vcTVv-t",
        "colab_type": "code",
        "colab": {},
        "cellView": "both"
      },
      "cell_type": "code",
      "source": [
        "#@title Code\n",
        "\n",
        "def get_data(num_examples):\n",
        "  # Replace with your code.\n",
        "  return np.zeros((num_examples, 2)), np.zeros((num_examples))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "JWHBltJ7fimG",
        "colab_type": "code",
        "colab": {},
        "cellView": "form"
      },
      "cell_type": "code",
      "source": [
        "#@title Solution\n",
        "\n",
        "# Solution 1.\n",
        "def get_data(num_examples):\n",
        "  inputs = 2*np.random.random((num_examples, 2)) - 1\n",
        "  labels = np.prod(inputs, axis=1)\n",
        "  labels[labels <= 0] = -1 \n",
        "  labels[labels > 0] = 1 \n",
        "  return inputs, labels\n",
        "\n",
        "# Solution 1.\n",
        "# def get_data(num_examples):\n",
        "#   inputs = 2*np.random.random((num_examples, 2)) - 1\n",
        "#   labels = np.sign(np.prod(inputs, axis=1))\n",
        "#   labels[labels == 0] = -1 \n",
        "#   return inputs, labels\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "8HhjadmmvZyc",
        "colab_type": "code",
        "colab": {
          "height": 89
        },
        "outputId": "d0cf93b7-3136-4e77-cbfa-004118f7e6c0"
      },
      "cell_type": "code",
      "source": [
        "get_data(4)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([[ 0.08875228,  0.85639209],\n",
              "        [ 0.52213802,  0.48106992],\n",
              "        [-0.53564626, -0.99373936],\n",
              "        [-0.90605549, -0.02954708]]), array([ 1.,  1.,  1.,  1.]))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "metadata": {
        "id": "IQ0Ip-SVb3Nc",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## That's all, folks!\n",
        "\n",
        "For now."
      ]
    },
    {
      "metadata": {
        "id": "_tp8wOIpcJ9Y",
        "colab_type": "code",
        "colab": {}
      },
      "cell_type": "code",
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}