Fancy_Indexing.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "anaconda-cloud": {},
    "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.5.1"
    },
    "colab": {
      "name": "02.07-Fancy-Indexing.ipynb",
      "provenance": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DG1BBkbi1WGT",
        "colab_type": "text"
      },
      "source": [
        "# Fancy Indexing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6k8C3j341WGT",
        "colab_type": "text"
      },
      "source": [
        "In the previous sections, we saw how to access and modify portions of arrays using simple indices (e.g., ``arr[0]``), slices (e.g., ``arr[:5]``), and Boolean masks (e.g., ``arr[arr > 0]``).\n",
        "In this section, we'll look at another style of array indexing, known as *fancy indexing*.\n",
        "Fancy indexing is like the simple indexing we've already seen, but we pass arrays of indices in place of single scalars.\n",
        "This allows us to very quickly access and modify complicated subsets of an array's values."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vfnoWYi_1WGU",
        "colab_type": "text"
      },
      "source": [
        "## Exploring Fancy Indexing\n",
        "\n",
        "Fancy indexing is conceptually simple: it means passing an array of indices to access multiple array elements at once.\n",
        "For example, consider the following array:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LsitpJ_v1WGU",
        "colab_type": "code",
        "colab": {},
        "outputId": "1baaa671-2eff-4304-a8ab-80ea6ab67031"
      },
      "source": [
        "import numpy as np\n",
        "rand = np.random.RandomState(42)\n",
        "\n",
        "x = rand.randint(100, size=10)\n",
        "print(x)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[51 92 14 71 60 20 82 86 74 74]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i6bN1vvr1WGZ",
        "colab_type": "text"
      },
      "source": [
        "Suppose we want to access three different elements. We could do it like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zcvA19ba1WGZ",
        "colab_type": "code",
        "colab": {},
        "outputId": "c69c0b04-9be8-4050-800b-238945252b0a"
      },
      "source": [
        "[x[3], x[7], x[2]]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[71, 86, 14]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K6XO9uRv1WGb",
        "colab_type": "text"
      },
      "source": [
        "Alternatively, we can pass a single list or array of indices to obtain the same result:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0zm4RuUc1WGc",
        "colab_type": "code",
        "colab": {},
        "outputId": "2e2cca39-c4c5-4985-c774-00e48bed94eb"
      },
      "source": [
        "ind = [3, 7, 4]\n",
        "x[ind]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([71, 86, 60])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ho4Ort_61WGe",
        "colab_type": "text"
      },
      "source": [
        "When using fancy indexing, the shape of the result reflects the shape of the *index arrays* rather than the shape of the *array being indexed*:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_UJkwKWT1WGe",
        "colab_type": "code",
        "colab": {},
        "outputId": "1a77e42b-6818-4e87-fe65-07a06c9002ea"
      },
      "source": [
        "ind = np.array([[3, 7],\n",
        "                [4, 5]])\n",
        "x[ind]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[71, 86],\n",
              "       [60, 20]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JIGy7Ywj1WGh",
        "colab_type": "text"
      },
      "source": [
        "Fancy indexing also works in multiple dimensions. Consider the following array:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "90p0gOKP1WGh",
        "colab_type": "code",
        "colab": {},
        "outputId": "0220d257-9eb9-4188-b36c-b068397cf468"
      },
      "source": [
        "X = np.arange(12).reshape((3, 4))\n",
        "X"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0,  1,  2,  3],\n",
              "       [ 4,  5,  6,  7],\n",
              "       [ 8,  9, 10, 11]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KHgrceWL1WGl",
        "colab_type": "text"
      },
      "source": [
        "Like with standard indexing, the first index refers to the row, and the second to the column:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R0to0nka1WGl",
        "colab_type": "code",
        "colab": {},
        "outputId": "2f525463-8909-4546-8c40-8b89ace4bd01"
      },
      "source": [
        "row = np.array([0, 1, 2])\n",
        "col = np.array([2, 1, 3])\n",
        "X[row, col]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 2,  5, 11])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fLGTu6mx1WGo",
        "colab_type": "text"
      },
      "source": [
        "Notice that the first value in the result is ``X[0, 2]``, the second is ``X[1, 1]``, and the third is ``X[2, 3]``.\n",
        "The pairing of indices in fancy indexing follows all the broadcasting rules that were mentioned in [Computation on Arrays: Broadcasting](02.05-Computation-on-arrays-broadcasting.ipynb).\n",
        "So, for example, if we combine a column vector and a row vector within the indices, we get a two-dimensional result:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZWtVh2zW1WGp",
        "colab_type": "code",
        "colab": {},
        "outputId": "d75b536c-140a-480b-8752-fbae5a4ad915"
      },
      "source": [
        "X[row[:, np.newaxis], col]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 2,  1,  3],\n",
              "       [ 6,  5,  7],\n",
              "       [10,  9, 11]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L5Map4Cr1WGr",
        "colab_type": "text"
      },
      "source": [
        "Here, each row value is matched with each column vector, exactly as we saw in broadcasting of arithmetic operations.\n",
        "For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8_keUpFr1WGs",
        "colab_type": "code",
        "colab": {},
        "outputId": "7a9ed097-3a64-4893-ef10-6b5c83f16533"
      },
      "source": [
        "row[:, np.newaxis] * col"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 0, 0],\n",
              "       [2, 1, 3],\n",
              "       [4, 2, 6]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FZD9sImi1WGu",
        "colab_type": "text"
      },
      "source": [
        "It is always important to remember with fancy indexing that the return value reflects the *broadcasted shape of the indices*, rather than the shape of the array being indexed."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9mteqzjt1WGu",
        "colab_type": "text"
      },
      "source": [
        "## Combined Indexing\n",
        "\n",
        "For even more powerful operations, fancy indexing can be combined with the other indexing schemes we've seen:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WnH57wgK1WGv",
        "colab_type": "code",
        "colab": {},
        "outputId": "57050a04-8e8f-4bfa-e73b-1faab5d7f7c2"
      },
      "source": [
        "print(X)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 0  1  2  3]\n",
            " [ 4  5  6  7]\n",
            " [ 8  9 10 11]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qR6sX8TU1WGy",
        "colab_type": "text"
      },
      "source": [
        "We can combine fancy and simple indices:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eN2BO7Ij1WGy",
        "colab_type": "code",
        "colab": {},
        "outputId": "1048c5c3-5c34-4b90-f2d6-23489b5f55bc"
      },
      "source": [
        "X[2, [2, 0, 1]]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([10,  8,  9])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n-fxS1cg1WG1",
        "colab_type": "text"
      },
      "source": [
        "We can also combine fancy indexing with slicing:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "278HbEFk1WG1",
        "colab_type": "code",
        "colab": {},
        "outputId": "b2a80500-9b89-4ab5-caed-7ae655fc1c5f"
      },
      "source": [
        "X[1:, [2, 0, 1]]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 6,  4,  5],\n",
              "       [10,  8,  9]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q7JXoH7B1WG3",
        "colab_type": "text"
      },
      "source": [
        "And we can combine fancy indexing with masking:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vBzMRoF41WG3",
        "colab_type": "code",
        "colab": {},
        "outputId": "02a9a6df-d2d9-4063-93ad-94622527528e"
      },
      "source": [
        "mask = np.array([1, 0, 1, 0], dtype=bool)\n",
        "X[row[:, np.newaxis], mask]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0,  2],\n",
              "       [ 4,  6],\n",
              "       [ 8, 10]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-qmVYl8v1WG7",
        "colab_type": "text"
      },
      "source": [
        "All of these indexing options combined lead to a very flexible set of operations for accessing and modifying array values."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hw71i7QT1WG8",
        "colab_type": "text"
      },
      "source": [
        "## Example: Selecting Random Points\n",
        "\n",
        "One common use of fancy indexing is the selection of subsets of rows from a matrix.\n",
        "For example, we might have an $N$ by $D$ matrix representing $N$ points in $D$ dimensions, such as the following points drawn from a two-dimensional normal distribution:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YjGYPB-81WG8",
        "colab_type": "code",
        "colab": {},
        "outputId": "8c783f50-9259-46c7-c4ca-5252fca6c82e"
      },
      "source": [
        "mean = [0, 0]\n",
        "cov = [[1, 2],\n",
        "       [2, 5]]\n",
        "X = rand.multivariate_normal(mean, cov, 100)\n",
        "X.shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(100, 2)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZuaUAPGw1WG_",
        "colab_type": "text"
      },
      "source": [
        "Using the plotting tools we will discuss in [Introduction to Matplotlib](04.00-Introduction-To-Matplotlib.ipynb), we can visualize these points as a scatter-plot:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mHJua6nQ1WHA",
        "colab_type": "code",
        "colab": {},
        "outputId": "eca2a132-b40b-442c-e7ed-569f64825879"
      },
      "source": [
        "%matplotlib inline\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn; seaborn.set()  # for plot styling\n",
        "\n",
        "plt.scatter(X[:, 0], X[:, 1]);"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAecAAAFVCAYAAADVDycqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAASUVORK5CYII=\n",
            "text/plain": [
              "<matplotlib.figure.Figure at 0x10e332048>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CyHOEoV11WHC",
        "colab_type": "text"
      },
      "source": [
        "Let's use fancy indexing to select 20 random points. We'll do this by first choosing 20 random indices with no repeats, and use these indices to select a portion of the original array:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_PXPwavk1WHC",
        "colab_type": "code",
        "colab": {},
        "outputId": "d4888fd1-aec2-40a8-bb54-8f73f90c1a50"
      },
      "source": [
        "indices = np.random.choice(X.shape[0], 20, replace=False)\n",
        "indices"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([93, 45, 73, 81, 50, 10, 98, 94,  4, 64, 65, 89, 47, 84, 82, 80, 25,\n",
              "       90, 63, 20])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mOnTz3-N1WHF",
        "colab_type": "code",
        "colab": {},
        "outputId": "54faccb3-18a8-4799-ed03-0d7788252bd2"
      },
      "source": [
        "selection = X[indices]  # fancy indexing here\n",
        "selection.shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(20, 2)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JlZrjFo71WHG",
        "colab_type": "text"
      },
      "source": [
        "Now to see which points were selected, let's over-plot large circles at the locations of the selected points:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IcctRHMi1WHH",
        "colab_type": "code",
        "colab": {},
        "outputId": "9d047234-08c4-4c2d-fb48-e36264e0e1a2"
      },
      "source": [
        "plt.scatter(X[:, 0], X[:, 1], alpha=0.3)\n",
        "plt.scatter(selection[:, 0], selection[:, 1],\n",
        "            facecolor='none', s=200);"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAecAAAFVCAYAAADVDycqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABJRU5ErkJggg==\n",
            "text/plain": [
              "<matplotlib.figure.Figure at 0x118687240>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dL8tzfMe1WHI",
        "colab_type": "text"
      },
      "source": [
        "This sort of strategy is often used to quickly partition datasets, as is often needed in train/test splitting for validation of statistical models (see [Hyperparameters and Model Validation](05.03-Hyperparameters-and-Model-Validation.ipynb)), and in sampling approaches to answering statistical questions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AMvZC9hm1WHJ",
        "colab_type": "text"
      },
      "source": [
        "## Modifying Values with Fancy Indexing\n",
        "\n",
        "Just as fancy indexing can be used to access parts of an array, it can also be used to modify parts of an array.\n",
        "For example, imagine we have an array of indices and we'd like to set the corresponding items in an array to some value:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JdCsoEVh1WHJ",
        "colab_type": "code",
        "colab": {},
        "outputId": "ec8869ad-8b97-4157-b440-3e4c5ee7d4c4"
      },
      "source": [
        "x = np.arange(10)\n",
        "i = np.array([2, 1, 8, 4])\n",
        "x[i] = 99\n",
        "print(x)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 0 99 99  3 99  5  6  7 99  9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-4cHOI1h1WHL",
        "colab_type": "text"
      },
      "source": [
        "We can use any assignment-type operator for this. For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7UY8Xlr01WHL",
        "colab_type": "code",
        "colab": {},
        "outputId": "2cc9d5a9-18fa-41aa-9411-41f5c3b2533a"
      },
      "source": [
        "x[i] -= 10\n",
        "print(x)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 0 89 89  3 89  5  6  7 89  9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KMGmvupF1WHN",
        "colab_type": "text"
      },
      "source": [
        "Notice, though, that repeated indices with these operations can cause some potentially unexpected results. Consider the following:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v4-_xxfR1WHO",
        "colab_type": "code",
        "colab": {},
        "outputId": "c5221b1a-8e55-4211-885d-0df8aefe67ae"
      },
      "source": [
        "x = np.zeros(10)\n",
        "x[[0, 0]] = [4, 6]\n",
        "print(x)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 6.  0.  0.  0.  0.  0.  0.  0.  0.  0.]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2UQLOBoc1WHR",
        "colab_type": "text"
      },
      "source": [
        "Where did the 4 go? The result of this operation is to first assign ``x[0] = 4``, followed by ``x[0] = 6``.\n",
        "The result, of course, is that ``x[0]`` contains the value 6.\n",
        "\n",
        "Fair enough, but consider this operation:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WdA0JUzx1WHS",
        "colab_type": "code",
        "colab": {},
        "outputId": "7bdd0100-a0fb-4990-fd97-4305bba83e41"
      },
      "source": [
        "i = [2, 3, 3, 4, 4, 4]\n",
        "x[i] += 1\n",
        "x"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 6.,  0.,  1.,  1.,  1.,  0.,  0.,  0.,  0.,  0.])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rjfxJXac1WHU",
        "colab_type": "text"
      },
      "source": [
        "You might expect that ``x[3]`` would contain the value 2, and ``x[4]`` would contain the value 3, as this is how many times each index is repeated. Why is this not the case?\n",
        "Conceptually, this is because ``x[i] += 1`` is meant as a shorthand of ``x[i] = x[i] + 1``. ``x[i] + 1`` is evaluated, and then the result is assigned to the indices in x.\n",
        "With this in mind, it is not the augmentation that happens multiple times, but the assignment, which leads to the rather nonintuitive results.\n",
        "\n",
        "So what if you want the other behavior where the operation is repeated? For this, you can use the ``at()`` method of ufuncs (available since NumPy 1.8), and do the following:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xn_85eq71WHU",
        "colab_type": "code",
        "colab": {},
        "outputId": "e991df62-ad7f-46de-9738-dedb5f3a0caa"
      },
      "source": [
        "x = np.zeros(10)\n",
        "np.add.at(x, i, 1)\n",
        "print(x)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 0.  0.  1.  2.  3.  0.  0.  0.  0.  0.]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s5U7wA921WHW",
        "colab_type": "text"
      },
      "source": [
        "The ``at()`` method does an in-place application of the given operator at the specified indices (here, ``i``) with the specified value (here, 1).\n",
        "Another method that is similar in spirit is the ``reduceat()`` method of ufuncs, which you can read about in the NumPy documentation."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8KOWeSd61WHW",
        "colab_type": "text"
      },
      "source": [
        "## Example: Binning Data\n",
        "\n",
        "You can use these ideas to efficiently bin data to create a histogram by hand.\n",
        "For example, imagine we have 1,000 values and would like to quickly find where they fall within an array of bins.\n",
        "We could compute it using ``ufunc.at`` like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KQqGpo5T1WHW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "np.random.seed(42)\n",
        "x = np.random.randn(100)\n",
        "\n",
        "# compute a histogram by hand\n",
        "bins = np.linspace(-5, 5, 20)\n",
        "counts = np.zeros_like(bins)\n",
        "\n",
        "# find the appropriate bin for each x\n",
        "i = np.searchsorted(bins, x)\n",
        "\n",
        "# add 1 to each of these bins\n",
        "np.add.at(counts, i, 1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ajZS5bLL1WHY",
        "colab_type": "text"
      },
      "source": [
        "The counts now reflect the number of points within each bin–in other words, a histogram:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lWRsk3gc1WHY",
        "colab_type": "code",
        "colab": {},
        "outputId": "baab3506-631f-4d9a-ccd5-50430a60fe10"
      },
      "source": [
        "# plot the results\n",
        "plt.plot(bins, counts, linestyle='steps');"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeEAAAFVCAYAAADYEVdtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nwgCQRIQBIIkIA0ASEQaAJP8P7quNPHF17C4AAAAASUVORK5CYII=\n",
            "text/plain": [
              "<matplotlib.figure.Figure at 0x1186d90b8>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SZAGpVzd1WHb",
        "colab_type": "text"
      },
      "source": [
        "Of course, it would be silly to have to do this each time you want to plot a histogram.\n",
        "This is why Matplotlib provides the ``plt.hist()`` routine, which does the same in a single line:\n",
        "\n",
        "```python\n",
        "plt.hist(x, bins, histtype='step');\n",
        "```\n",
        "\n",
        "This function will create a nearly identical plot to the one seen here.\n",
        "To compute the binning, ``matplotlib`` uses the ``np.histogram`` function, which does a very similar computation to what we did before. Let's compare the two here:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zoLTIvCW1WHb",
        "colab_type": "code",
        "colab": {},
        "outputId": "74db09d3-bb0b-4ad5-a823-3e7a63f92594"
      },
      "source": [
        "print(\"NumPy routine:\")\n",
        "%timeit counts, edges = np.histogram(x, bins)\n",
        "\n",
        "print(\"Custom routine:\")\n",
        "%timeit np.add.at(counts, np.searchsorted(bins, x), 1)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "NumPy routine:\n",
            "10000 loops, best of 3: 97.6 µs per loop\n",
            "Custom routine:\n",
            "10000 loops, best of 3: 19.5 µs per loop\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5F3gZ23Z1WHd",
        "colab_type": "text"
      },
      "source": [
        "Our own one-line algorithm is several times faster than the optimized algorithm in NumPy! How can this be?\n",
        "If you dig into the ``np.histogram`` source code (you can do this in IPython by typing ``np.histogram??``), you'll see that it's quite a bit more involved than the simple search-and-count that we've done; this is because NumPy's algorithm is more flexible, and particularly is designed for better performance when the number of data points becomes large:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sXVUCVM71WHd",
        "colab_type": "code",
        "colab": {},
        "outputId": "438cb033-e874-49e7-e631-fe329174006e"
      },
      "source": [
        "x = np.random.randn(1000000)\n",
        "print(\"NumPy routine:\")\n",
        "%timeit counts, edges = np.histogram(x, bins)\n",
        "\n",
        "print(\"Custom routine:\")\n",
        "%timeit np.add.at(counts, np.searchsorted(bins, x), 1)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "NumPy routine:\n",
            "10 loops, best of 3: 68.7 ms per loop\n",
            "Custom routine:\n",
            "10 loops, best of 3: 135 ms per loop\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N6dbxyFD1WHf",
        "colab_type": "text"
      },
      "source": [
        "What this comparison shows is that algorithmic efficiency is almost never a simple question. An algorithm efficient for large datasets will not always be the best choice for small datasets, and vice versa (see [Big-O Notation](02.08-Sorting.ipynb#Aside:-Big-O-Notation)).\n",
        "But the advantage of coding this algorithm yourself is that with an understanding of these basic methods, you could use these building blocks to extend this to do some very interesting custom behaviors.\n",
        "The key to efficiently using Python in data-intensive applications is knowing about general convenience routines like ``np.histogram`` and when they're appropriate, but also knowing how to make use of lower-level functionality when you need more pointed behavior."
      ]
    }
  ]
}