{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<img src=\"../../img/ods_stickers.jpg\" />\n",
    "    \n",
    "## [mlcourse.ai](https://mlcourse.ai) – Open Machine Learning Course \n",
    "### <center> Author: Kseniia Terekhova, ODS Slack Kseniia\n",
    "    \n",
    "## <center> Tutorial\n",
    "## <center> A little more info about NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Introduction/justification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Though NumPy was not denoted as prerequisite for mlcourse.ai, there is no doubt that most participants are familiar with it and have no difficulties in performing common actions. However, pieces of interesting information encountered here and there seem to be worth sharing. No one knows everything, NumPy was not covered in the course in details -  but it is a powerful scientific library that can make many mathematical calculations simpler and nicer.<br>\n",
    "Links to materials the tutorial is based on can be found in the end of the notebook, in the \"References\" section. And sure, I'm not going to retell NumPy <a href=\"https://docs.scipy.org/doc/numpy/user/quickstart.html\" target=__blank>quickstart tutorial</a>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. NumPy performance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is not only convenient API that makes NumPy so useful for scientific purposes, but also its performance characteristics. Python is not the most quick and memory-economical language. When you are often getting MemoryError while working with large ML datasets it does not look as a minor disadvantage.<br>\n",
    "Let's first compare amounts of bytes taken by standard Python list and identical NumPy array. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python list size: 8.583 MB\n",
      "Numpy array size: 7.629 MB\n",
      "ArraySize/ListSize ratio: 0.89\n"
     ]
    }
   ],
   "source": [
    "mb = 1024 * 1024\n",
    "\n",
    "python_list = list(range(0, 1000000))\n",
    "numpy_array = np.array(range(0, 1000000))\n",
    "\n",
    "print(\"Python list size: {0:.3f} MB\".format(sys.getsizeof(python_list) / mb))\n",
    "print(\"Numpy array size: {0:.3f} MB\".format(numpy_array.nbytes / mb, \"MB\"))\n",
    "print(\"ArraySize/ListSize ratio: {0:.2f}\".format(numpy_array.nbytes / sys.getsizeof(python_list)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "11% of gain is something noticeable. But were Python lists implemented so inefficiently? No, actually, they just were implemented differently."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<img src=\"../../img/kseniia_numpy_array_vs_python_list.png\" style=\"width: 600px;\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While NumPy contains data in a continious area in memory, a Python list stores only pointers to the real data. And yes, not only \"list in Python is more than just list\" but also \"an integer in Python is more than just integer\". "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<img src=\"../../img/kseniia_cint_vs_pyint.png\" style=\"width: 400px;\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Such way of storing data incurs additional metadata overhead, but gives more flexibility. There is no problems with having such mixed-type list in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "mixed_list = [1, 2, 3, 4.0, 5.0, 'abc', 'def', True, False]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, NumPy allows such notation too, but as its datastorage is continious, with equal strides, it has to convert all the data to one type. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating mixed int and string array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mixed numpy array size: 80.108642578125 MB\n"
     ]
    }
   ],
   "source": [
    "np_array_mixed = np.array([i if i % 2 == 0 else str(i) for i in range(0, 1000000)])\n",
    "np_array_mixed_size = np_array_mixed.nbytes\n",
    "print(\"Mixed numpy array size:\", np_array_mixed_size / mb, \"MB\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And when storing string only:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Strings-only numpy array size: 22.88818359375 MB\n"
     ]
    }
   ],
   "source": [
    "np_array_str = np.array([str(i) for i in range(0, 1000000)])\n",
    "np_array_str_size = np_array_str.nbytes\n",
    "print(\"Strings-only numpy array size:\", np_array_str_size / mb, \"MB\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What? Half-integer half-string array occupies four times more space than string-only one? In reality, there are no integers in the first array: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String array contains type: <U6\n",
      "\"Mixed\" array contains type: <U21\n",
      "\"Mixed\" array elements:\" ['0' '1' '2' '3' '4' '5']\n"
     ]
    }
   ],
   "source": [
    "print('String array contains type:', np_array_str.dtype)\n",
    "print('\"Mixed\" array contains type:', np_array_mixed.dtype)\n",
    "print('\"Mixed\" array elements:\"', np_array_mixed[:6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All the elements in the \"mixed\" array were converted to unicode string. And they were converted in very awkward way: \"mixed\" elements take more bytes than in string-only array. Not sure how did it work internally, but I can suppose that U21 was selected during int conversion in order to accommodate even large numbers, though string representations of all integers < 1000000 fit into 6-characters string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That allows to make a conclusion that NumPy was designed for high performance computing over large blocks of same-type numbers. Let's try to compare such computations made with NumPy and with Python intrinsics on the example of calculating reciprocals (1/x) of ten million integers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums_list = list(range(1, 10000000))\n",
    "numpy_nums = np.array(nums_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1.31 s, sys: 96.1 ms, total: 1.4 s\n",
      "Wall time: 1.4 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "reciprocal_list = []\n",
    "for num in nums_list:\n",
    "    reciprocal_list.append(1 / num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python loops shows as quite slow. Maybe list comprehension are quicker?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 608 ms, sys: 120 ms, total: 729 ms\n",
      "Wall time: 727 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "reciprocal_list = [1 / num for num in nums_list]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A little bit. What about NumPy?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 46.6 ms, sys: 58.6 ms, total: 105 ms\n",
      "Wall time: 103 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "reciprocal_array = 1 / numpy_nums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Much more better!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To be honest, there was a small deceit. The amounts of time spent creating list and array were not measured. They are different:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 227 ms, sys: 164 ms, total: 391 ms\n",
      "Wall time: 389 ms\n"
     ]
    }
   ],
   "source": [
    "%%time \n",
    "nums_list = list(range(1, 10000000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 664 ms, sys: 11.4 ms, total: 675 ms\n",
      "Wall time: 672 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "numpy_nums = np.array(nums_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1.38 s, sys: 461 ms, total: 1.84 s\n",
      "Wall time: 1.83 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "numpy_nums = np.array(range(1, 10000000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Does it mean that there was no gain in reality? No, only that it is better to create NumPy arrays using NumPy initialization functions. Numpy.arange in this case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 26.7 ms, sys: 56.3 ms, total: 83 ms\n",
      "Wall time: 78.4 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "numpy_nums = np.arange(1, 10000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 67.4 ms, sys: 52.9 ms, total: 120 ms\n",
      "Wall time: 118 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "reciprocal_array = 1 / numpy_nums"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One more example, slightly more complex. Calculating distances from a point to long sequence of other ones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 13.1 s, sys: 571 ms, total: 13.6 s\n",
      "Wall time: 13.6 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "point = [1.0, 1.0]\n",
    "other_points = list([float(x), x + 1.0] for x in range(10000000))\n",
    "dists = [((point[0] - op[0])**2 + (point[1] - op[1])**2)**0.5 for op in other_points]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0,\n",
       " 1.0,\n",
       " 2.23606797749979,\n",
       " 3.605551275463989,\n",
       " 5.0,\n",
       " 6.4031242374328485,\n",
       " 7.810249675906654,\n",
       " 9.219544457292887,\n",
       " 10.63014581273465,\n",
       " 12.041594578792296]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dists[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 236 ms, sys: 255 ms, total: 491 ms\n",
      "Wall time: 330 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "np_point = np.ones(2)\n",
    "np_other_points = np.vstack([np.arange(0.0, 10000000.0), np.arange(1.0, 10000001.0)]).T\n",
    "np_dists = np.sum((np_point - np_other_points)**2, axis=1)**0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.        ,  1.        ,  2.23606798,  3.60555128,  5.        ,\n",
       "        6.40312424,  7.81024968,  9.21954446, 10.63014581, 12.04159458])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np_dists[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results are the same, but the performance advantage is significant."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. NumPy matrix broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>One of the things that should be noticed about the example above is that it handles matrixes with different dimensions. The np_point has shape (2,) and np_other_points - (10000000, 2). Nevertheless, element-wise operations are performed with them, producing a matrix with shape (10000000,). That is possible by the virtue of <b><i>matrix broadcasting</i></b> mechanism.</p>\n",
    "<p>Matrix broadcasting in NumPy is a set of rules that allowes to expand two matrixes with different dimentions to  match shapes of each other, in order to perform element-by-element operations. What is important, this set of rules is a  \"virtual\" mechanism, that just allows to understand how matrixes will interact. No real expansion and memory allocation is performed.</p>\n",
    "<p>Its simplest case is summing a matrix with a scalar number, that will be added to each element of the matrix:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M:\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n",
      "\n",
      "M + 2 :\n",
      "[[3. 3. 3.]\n",
      " [3. 3. 3.]\n",
      " [3. 3. 3.]]\n"
     ]
    }
   ],
   "source": [
    "M = np.ones((3, 3))\n",
    "print(\"M:\")\n",
    "print(M)\n",
    "\n",
    "scalar = 2\n",
    "M_added = M + scalar\n",
    "\n",
    "print()\n",
    "print(\"M +\", scalar, \":\")\n",
    "print(M_added)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A matrix can be summed with a vector in the similar way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n",
      "\n",
      "[0 1 2]\n",
      "\n",
      "[[1. 2. 3.]\n",
      " [1. 2. 3.]\n",
      " [1. 2. 3.]]\n"
     ]
    }
   ],
   "source": [
    "M = np.ones((3, 3))\n",
    "print(M)\n",
    "\n",
    "v = np.array([0, 1, 2])\n",
    "print()\n",
    "print(v)\n",
    "\n",
    "M_added = M + v\n",
    "print()\n",
    "print(M_added)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a more complex case the both matrixes are broadcasted:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: [0 1 2]\n",
      "b:\n",
      " [[0]\n",
      " [1]\n",
      " [2]]\n",
      "\n",
      "Summed:\n",
      "[[0 1 2]\n",
      " [1 2 3]\n",
      " [2 3 4]]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(3)\n",
    "b = np.arange(3)[:, np.newaxis]\n",
    "\n",
    "print(\"a:\", a)\n",
    "print(\"b:\\n\", b)\n",
    "\n",
    "summed = a + b\n",
    "print(\"\\nSummed:\")\n",
    "print(summed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The rules of matrix broadcasting are this way:<br>\n",
    "<b>Rule 1:</b> If the two arrays differ in their number of dimensions, the shape of the one with fewer dimensions is padded with ones on its leading (left) side.<br>\n",
    "<b>Rule 2:</b> If the shape of the two arrays does not match in any dimension, the array with shape equal to 1 in that dimension is stretched to match the other shape.<br>\n",
    "<b>Rule 3:</b> If in any dimension the sizes disagree and neither is equal to 1, an error is raised.<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, adding a two-dimensional array to a one-dimensional array is performed this way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M: (2, 3)\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]]\n",
      "\n",
      "a: (3,)\n",
      "[0 1 2]\n"
     ]
    }
   ],
   "source": [
    "M = np.ones((2, 3))\n",
    "a = np.arange(3)\n",
    "print(\"M:\", M.shape)\n",
    "print(M)\n",
    "print()\n",
    "print(\"a:\", a.shape)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The shape of a is pad on the left, as it has fewer dimensions:<br>\n",
    "    M.shape -> (2, 3)<br>\n",
    "    a.shape -> (1, 3)<br><br>\n",
    "The the 1-dimension of a is stretched to match M:<br>\n",
    "    M.shape -> (2, 3)<br>\n",
    "    a.shape -> (2, 3)<br>\n",
    "\n",
    "Now the shapes match and matrixes can be summed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2., 3.],\n",
       "       [1., 2., 3.]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M + a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's what happens when both arrays need to be broadcasted:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: (3, 1)\n",
      "[[0]\n",
      " [1]\n",
      " [2]]\n",
      "\n",
      "b: (3,)\n",
      "[0 1 2]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(3).reshape((3, 1))\n",
    "b = np.arange(3)\n",
    "\n",
    "print(\"a:\", a.shape)\n",
    "print(a)\n",
    "print()\n",
    "print(\"b:\", b.shape)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The shape of b is pad left with ones:<br>\n",
    "a.shape -> (3, 1)<br>\n",
    "b.shape -> (1, 3)<br>\n",
    "<br>\n",
    "Then both matrixes has dimension to be expanded:<br>\n",
    "a.shape -> (3, 3)<br>\n",
    "b.shape -> (3, 3)<br>\n",
    "<br>\n",
    "Then the matrixes can be easily summed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [1, 2, 3],\n",
       "       [2, 3, 4]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, broadcasting is not always possible:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M: (3, 2)\n",
      "[[1. 1.]\n",
      " [1. 1.]\n",
      " [1. 1.]]\n",
      "\n",
      "a: (3,)\n",
      "[0 1 2]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "M = np.ones((3, 2))\n",
    "print(\"M:\", M.shape)\n",
    "print(M)\n",
    "print()\n",
    "\n",
    "a = np.arange(3)\n",
    "print(\"a:\", a.shape)\n",
    "print(a)\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "M.shape -> (3, 2) <br>\n",
    "a.shape -> (1, 3) <br>\n",
    "<br>\n",
    "M.shape -> (3, 2)<br>\n",
    "a.shape -> (3, 3)<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrixes shape does not match, the error is raised when trying to perform operations with them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (3,2) (3,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-33-8cac1d547906>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mM\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0ma\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 (3,2) (3,) "
     ]
    }
   ],
   "source": [
    "M + a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The possible solution in such situation is padding \"a\" with 1 dimention in the <i>right</i> manually. This way the Rule 1 will be skipped and according to the Rule 2 NumPy will just expand matrix to the needed size: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: (3, 1)\n",
      "[[0]\n",
      " [1]\n",
      " [2]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = a[:, np.newaxis]\n",
    "\n",
    "print(\"a:\", a.shape)\n",
    "print(a)\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1.],\n",
       "       [2., 2.],\n",
       "       [3., 3.]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M + a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. What is np.newaxis?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example in the previous section used a np.newaxis constant was used. What is it? Actually it is None."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.newaxis is None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, just a convenient alias. The <i>np.newaxis</i> constant is useful when converting a 1D array into a row vector or a column vector, by adding new dimensions from left or right side:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(3)\n",
    "arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 3)\n",
      "[[0 1 2]]\n"
     ]
    }
   ],
   "source": [
    "row_vec = arr[np.newaxis, :]\n",
    "print(row_vec.shape)\n",
    "print(row_vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 1)\n",
      "[[0]\n",
      " [1]\n",
      " [2]]\n"
     ]
    }
   ],
   "source": [
    "col_vec = arr[:, np.newaxis]\n",
    "print(col_vec.shape)\n",
    "print(col_vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact it is similar to <i>np.reshape(-1, 1)</i> and <i>np.reshape(1, -1)</i> down to minor implementation details. But the np.newaxis allows to stack dimentions using slice syntax, without specifying original shape: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = np.ones((5, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 5, 5, 1, 1)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[np.newaxis, :, :, np.newaxis, np.newaxis].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 5, 5, 1, 1)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[np.newaxis, ..., np.newaxis, np.newaxis].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And reshape allows to use -1 only once, requiring to explicitly pass original shape when working with multidimentional arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "can only specify one unknown dimension",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-69-92614bbd4d77>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mM\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: can only specify one unknown dimension"
     ]
    }
   ],
   "source": [
    "M.reshape(1, -1, -1, 1, 1 ).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will work:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 5, 5, 1, 1)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M.reshape(1, *M.shape, 1, 1 ).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but doesn't it look a little bit clumsy?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Adding several new dimensions is useful in ML when working with, for example, convolutional neural networks. Such frameworks as <b>Pytorch</b> allows to initialize its \"Tensors\" <a href=\"https://pytorch.org/docs/master/torch.html#torch.from_numpy\">from numpy arrays</a>, but often requires input in the form \"minibatch × in_channels × iW\" or \"minibatch × in_channels × iH × iW\" (<a href=\"https://pytorch.org/docs/master/nn.html#torch-nn-functional\" target=__blank>torch.nn.functional</a>). There, minibatch and in_channels can be equal to 1, but they must be  present. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. A quick note about matrix multiplication"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, summing is not the only operation that can be applied to matrixes; a number of arithmetic operations can be used, along with several “universal functions”. The operation that I would like to pay some attention is multiplication, i.e. '*'. As other arithmetic operations, in NumPy it is applied elementwise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A:\n",
      "[[2 2]\n",
      " [2 2]]\n",
      "\n",
      "B:\n",
      "[[3 3]\n",
      " [3 3]]\n",
      "\n",
      "A*B:\n",
      "[[6 6]\n",
      " [6 6]]\n"
     ]
    }
   ],
   "source": [
    "A = np.full((2, 2), 2)\n",
    "print(\"A:\")\n",
    "print(A)\n",
    "print()\n",
    "\n",
    "B = np.full((2, 2), 3)\n",
    "print(\"B:\")\n",
    "print(B)\n",
    "print()\n",
    "\n",
    "print(\"A*B:\")\n",
    "print(A*B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But when speaking about matrix multiplication, especially in linear algebra (and ML) another operation is often implied, the <i>matrix product</i>, that is defined this way (formula from <a href=\"https://en.wikipedia.org/wiki/Matrix_multiplication#Definition\" target=__blank>wikipedia</a>):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$ A = \\begin{pmatrix} a_{11}, a_{12} & \\cdots & a_{1m}\\\\a_{21}, a_{22} & \\cdots & a_{2m} \\\\ \\vdots & \\ddots & \\vdots \\\\ a_{n1}, a_{n2} & \\cdots & a_{nm} \\end{pmatrix},  B = \\begin{pmatrix} b_{11}, b_{12} & \\cdots & b_{1p}\\\\b_{21}, b_{22} & \\cdots & b_{2p} \\\\ \\vdots & \\ddots & \\vdots \\\\ b_{m1}, b_{m2} & \\cdots & b_{mp} \\end{pmatrix} $$\n",
    "Matrix product <b>C</b> = <b>AB</b>:\n",
    "$$C = \\begin{pmatrix} c_{11}, c_{12} & \\cdots & c_{1p} \\\\c_{21}, c_{22} & \\cdots & c_{2p} \\\\ \\vdots & \\ddots & \\vdots \\\\ c_{n1}, c_{n2} & \\cdots & c_{np} \\end{pmatrix} $$ \n",
    "$c_{ij} = a_{i1}b_{1j} + ... +  a_{im}b_{mj} = \\sum_{k=1}^{m} a_{ik}b_{kj}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The <i>numpy.dot()</i> function or \"@\" shortcut is used for this purpose in NumPy. That is unpleasant to confuse these two operations, especially when matrix broadcasting exists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A:\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "\n",
      "B:\n",
      "[3 3 3]\n",
      "\n",
      "A*B:\n",
      "[[ 3  6  9]\n",
      " [12 15 18]\n",
      " [21 24 27]]\n",
      "\n",
      "A@B:\n",
      "[18 45 72]\n"
     ]
    }
   ],
   "source": [
    "A = np.arange(1, 10).reshape(3,3)\n",
    "print(\"A:\")\n",
    "print(A)\n",
    "print()\n",
    "\n",
    "B = np.full((3,), 3)\n",
    "print(\"B:\")\n",
    "print(B)\n",
    "print()\n",
    "\n",
    "print(\"A*B:\")\n",
    "print(A*B)\n",
    "\n",
    "print()\n",
    "print(\"A@B:\")\n",
    "print(A@B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, be attentive :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. No mess with np.meshgrid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We used np.meshgrid function somewhere in the course, but without any explanations. That's pity in my opinion, as it is not so easy to grasp what it does from the NumPy <a href=\"https://docs.scipy.org/doc/numpy/reference/generated/numpy.meshgrid.html\" target=__blank>documentation</a>:\n",
    "<blockquote cite=\"https://docs.scipy.org/doc/numpy/reference/generated/numpy.meshgrid.html\">\n",
    "numpy.meshgrid(*xi, **kwargs)<br>\n",
    "\n",
    "Return coordinate matrices from coordinate vectors.<br>\n",
    "\n",
    "Make N-D coordinate arrays for vectorized evaluations of N-D scalar/vector fields over N-D grids, given one-dimensional coordinate arrays x1, x2,…, xn.\n",
    "</blockquote>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nevertheless, the first time I've saw its usage was in the <a href=\"https://towardsdatascience.com/convnets-series-spatial-transformer-networks-cff47565ae81\" target=__blank>article</a> about Spatial Transformer Networks, on the step with \"Identity meshgrid\" and \"Transformed meshgrid\". So, it can be a useful stuff. <br>\n",
    "Actually, this function just creates a set of grids with coordinates of x, y, etc. on the corresponding grid locations. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.  -0.5  0.   0.5  1. ]\n",
      " [-1.  -0.5  0.   0.5  1. ]\n",
      " [-1.  -0.5  0.   0.5  1. ]\n",
      " [-1.  -0.5  0.   0.5  1. ]\n",
      " [-1.  -0.5  0.   0.5  1. ]]\n",
      "\n",
      "[[-1.  -1.  -1.  -1.  -1. ]\n",
      " [-0.5 -0.5 -0.5 -0.5 -0.5]\n",
      " [ 0.   0.   0.   0.   0. ]\n",
      " [ 0.5  0.5  0.5  0.5  0.5]\n",
      " [ 1.   1.   1.   1.   1. ]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import cm\n",
    "\n",
    "xvalues = np.arange(-1, 1.05, 0.5)\n",
    "yvalues = np.arange(-1, 1.05, 0.5)\n",
    "\n",
    "xx, yy = np.meshgrid(xvalues, yvalues)\n",
    "print(xx)\n",
    "print()\n",
    "print(yy)\n",
    "grid = plt.plot(xx, yy, marker='.', color='k', linestyle='none')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, those coordinate grids can be used to calculate values of multivariable functions, or to visualize something beautiful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.arange(-8, 8, 0.01)\n",
    "y = np.arange(-8, 8, 0.01)\n",
    "xx, yy = np.meshgrid(x, y, sparse=True)\n",
    "z = np.sin(xx**2 + yy**2) / (xx**2 + yy**2)\n",
    "\n",
    "h = plt.contourf(x,y,z, cmap=cm.PuBu_r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "fig = plt.figure(figsize=(10, 8))\n",
    "ax = fig.gca(projection='3d')\n",
    "ax.view_init(60, 35)\n",
    "\n",
    "# Make data.\n",
    "X = np.arange(-5, 5, 0.25)\n",
    "Y = np.arange(-5, 5, 0.25)\n",
    "X, Y = np.meshgrid(X, Y)\n",
    "R = np.sqrt(X**2 + Y**2)\n",
    "Z = np.sin(R)\n",
    "\n",
    "# Plot the surface.\n",
    "surf = ax.plot_surface(X, Y, Z, cmap=cm.coolwarm, linewidth=0, antialiased=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. Some interesting samples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And lastly a few examples that shows how NumPy allows to write short and elegant code for computational and ML-related tasks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.1 K-Nearest Neighbors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There was a sample above, that counts distances from a single point to set of others. But if it is needed to find the closest points for each point in the set, that can be performed this way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn; seaborn.set()\n",
    "\n",
    "rand = np.random.RandomState(42)\n",
    "X = rand.rand(10, 2)\n",
    "plt.scatter(X[:, 0], X[:, 1], s=100);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    " dist_sq = np.sum((X[:, np.newaxis, :] - X[np.newaxis, :, :]) ** 2, axis=-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, adding newaxis allows to convert the X matrix with shape (10, 2) into two matrices (10, 1, 2) and (1, 10, 2), that have ten 2D-points in rows and cols correspondingly; then, the broadcasting allows to calculate difference between coordinates of points on the i-th row and j-th column; then square and sum operations give squared euclidean distance between those points. <br>\n",
    "The dist_qs matrix has zeros on its diagonal, that proves calculation correctness. Distance between ii element is distance between i-th point and itself; that is zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dist_sq.diagonal()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then <i>np.argsort</i> function allows to sort elements in the each row and print indexes of other points in the order of their remoteness from the i-th point:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 3 4 5 8 1 9 7 2 6]\n",
      " [1 4 6 9 8 0 7 3 2 5]\n",
      " [2 7 9 8 6 4 3 1 0 5]\n",
      " [3 5 0 8 4 9 7 2 1 6]\n",
      " [4 1 0 8 9 6 3 5 7 2]\n",
      " [5 3 0 8 4 9 1 7 2 6]\n",
      " [6 1 9 4 8 7 2 0 3 5]\n",
      " [7 2 9 8 6 4 1 3 0 5]\n",
      " [8 9 4 7 2 3 0 1 5 6]\n",
      " [9 8 7 2 6 1 4 0 3 5]]\n"
     ]
    }
   ],
   "source": [
    "nearests = np.argsort(dist_sq, axis=1)\n",
    "print(nearests)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If only K nearest points (unsorted) are needed, the <i>np.argpartition</i> function allows to take them only, without sorting the whole rows: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 0 4]\n",
      " [1 4 6]\n",
      " [2 7 9]\n",
      " [3 5 0]\n",
      " [1 4 0]\n",
      " [5 3 0]\n",
      " [1 9 6]\n",
      " [7 2 9]\n",
      " [8 9 4]\n",
      " [8 7 9]]\n"
     ]
    }
   ],
   "source": [
    "K = 2\n",
    "nearest_partition = np.argpartition(dist_sq, K + 1, axis=1)\n",
    "print(nearest_partition[:, :K+1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That can be visualized:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cmap = plt.get_cmap('viridis')\n",
    "colors = cmap(np.linspace(0, 1, 10))\n",
    "plt.scatter(X[:, 0], X[:, 1], s=150, color=colors)\n",
    "\n",
    "# draw lines from each point to its two nearest neighbors\n",
    "K = 2\n",
    "\n",
    "for i in range(X.shape[0]):\n",
    "    for j in nearest_partition[i, :K+1]:\n",
    "        # plot a line from X[i] to X[j]\n",
    "        # the lines colors correspond to outgoing point color, but some lines obviously overlap\n",
    "        # using some zip magic:\n",
    "        plt.plot(*zip(X[j], X[i]), c=colors[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.2 Conway's Game of Life"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The <a href=\"https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life\" target=__blank>Conway's Game of Life</a> is a classical model of cellular automaton model and a zero-player game. Given an initial state, it starts to live its own life by applying the following rules on each step:<ul>\n",
    "<li>Each cell on a 2D grid is \"alive\"(1) or \"dead\"(0)</li>\n",
    "<li>Any living cell that has 2 or 3 neighbors survives, else it dies [0,1 or 4+ neighbors]</li>\n",
    "<li>Any cell with exactly 3 neighbors becomes alive (if it was dead)</li></ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What it takes to implement this game using NumPy arrays? It's tricky, but not so long:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def iterate(Z):\n",
    "    # Count neighbours\n",
    "    N = (Z[0:-2,0:-2] + Z[0:-2,1:-1] + Z[0:-2,2:] +\n",
    "         Z[1:-1,0:-2]                + Z[1:-1,2:] +\n",
    "         Z[2:  ,0:-2] + Z[2:  ,1:-1] + Z[2:  ,2:])\n",
    "\n",
    "    # Apply rules\n",
    "    birth = (N==3) & (Z[1:-1,1:-1]==0)\n",
    "    survive = ((N==2) | (N==3)) & (Z[1:-1,1:-1]==1)\n",
    "    Z[...] = 0\n",
    "    Z[1:-1,1:-1][birth | survive] = 1\n",
    "    return Z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>First, it slices original matrix with 0, 1 and 2 vertical strides, thus getting matrices with \"middle\" rows, rows shifted by -1 from the \"middle\" ones, and rows shifted by +1. The similar action is performed with the columns. Combining this steps in different directions creates 8 shifted matrices; their elementwise sum gives amount of \"alive\" neighbors for every element of N matrix.</p>\n",
    "<p>Then, by applying game rules to the N and Z matrices the boolean mask matrices \"birth\" and \"survive\" can be calculated. After that, NumPy boolean indexing allows to set to \"1\" only those cells that were born or had survived.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The folowing code allows to animate the game process when running the notebook. Hopping, nbviewer will show at least a resulting picture :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "%matplotlib notebook\n",
    "plt.ion()\n",
    "\n",
    "#initialize game field\n",
    "Z = np.random.choice([0,1],size=(100,100))\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "fig.show()\n",
    "\n",
    "for _ in range(1000):    \n",
    "    #update\n",
    "    Z = iterate(Z)\n",
    "    \n",
    "    #re-draw image\n",
    "    ax.clear()\n",
    "    ax.imshow(Z,cmap='gray')\n",
    "    fig.canvas.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.3 Convolutional layers in Convolutional Neural Networks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The topic above is quite close to the ML area, as the action performed there is similar to the principle of convolutional layers in Convolution Neural Networks (CNN).<br>\n",
    "When convolution is applied, for example to an image in computer vision, it takes the matrix with image pixels and  slides across it with small window called \"filter\" or \"kernel\". The kernel is just little (3x3, 5x5, 7x7 or smth. like this) weight matrix that contains numerical coefficients. Each of these coefficients has to be multiplied by the value of pixel that is currently under the corresponding kernel cell. Then, all such multiplied element are summed, giving the value of an element of the resulting map. After that, the kernel is moved by 1 or more strides horizontaly or verticaly, to the next group of pixels, and the next weighted sum is calculated.<br>\n",
    "This image illustrates the process of applying the filter and calculating an element of resulting map:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<img src=\"../../img/kseniia_convolution.png\" style=\"width: 600px;\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact, the N matrix, calculating amount of cell's neighbors is similar convolution result, using a filter with wieght \"0\" for the middle element and \"1\" for all its neighbors.<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "filters = np.array([[1,1,1],\n",
    "                    [1,0,1],\n",
    "                    [1,1,1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neural networks usually offers such operation as a ready functionality (<a href=\"https://pytorch.org/docs/master/nn.html#torch-nn-functional\" target=__blank>Pytorch for example</a>). And even scipy model has such a <a href=\"https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.convolve2d.html\" target=__blank>function</a>. <br>\n",
    "Let's see if it indeed does the same thing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Are N1 and N2 identical?\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "from scipy import signal\n",
    "\n",
    "Z = np.random.choice([0,1],size=(10,10))\n",
    "\n",
    "N1 = (Z[0:-2,0:-2] + Z[0:-2,1:-1] + Z[0:-2,2:] +\n",
    "      Z[1:-1,0:-2]                + Z[1:-1,2:] +\n",
    "      Z[2:  ,0:-2] + Z[2:  ,1:-1] + Z[2:  ,2:]) \n",
    "\n",
    "N2 = signal.convolve2d(Z, filters, mode='valid')\n",
    "\n",
    "print(\"Are N1 and N2 identical?\")\n",
    "print(np.array_equal(N1, N2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's all by this moment. Hopping, it was informative :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "<ol>\n",
    "    <li><a href=\"http://shop.oreilly.com/product/0636920034919.do\" target=__blank>\"Python Data Science Handbook\"</a> by Jake VanderPlas</li><ul><li><a href=\"https://jakevdp.github.io/blog/2014/05/09/why-python-is-slow/\" target=__blank>\"Why Python is slow\"</a> article</li>\n",
    "        <li><a href=\"https://jakevdp.github.io/PythonDataScienceHandbook/02.05-computation-on-arrays-broadcasting.html\" target=__blanl>Computation on Arrays: Broadcasting</a></li>\n",
    "    <li><a href=\"https://jakevdp.github.io/PythonDataScienceHandbook/02.08-sorting.html#Example:-k-Nearest-Neighbors\" target=__blank>K-Nearest Neighbors sample</a></li>\n",
    "    </ul>\n",
    "    <li><a href=\"https://medium.com/@ian.dzindo01/what-is-numpy-newaxis-and-when-to-use-it-8cb61c7ed6ae\">What is numpy.newaxis and when to use it</a></li>\n",
    "    <li>NumPy documentation about <a href=\"https://docs.scipy.org/doc/numpy/reference/generated/numpy.dot.html\" target=__blank>numpy.dot</a>, <a href=\"https://docs.scipy.org/doc/numpy/reference/constants.html#numpy.newaxis\" target=__blank>numpy.newaxis</a>, <a href=\"https://docs.scipy.org/doc/numpy/reference/generated/numpy.meshgrid.html\" target=__blank>numpy.meshgrid</a></li>\n",
    "    <li><a href=\"https://matplotlib.org/examples/mplot3d/surface3d_demo.html\">Matplotlib 3d surface example</a></li>\n",
    "    <li>Exercise 88 from the <a href=\"https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises.ipynb\">100 NumPy exercises</a></li>\n",
    "<ol>"
   ]
  }
 ],
 "metadata": {
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}