{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](../docs/banner.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 6: NumPy Implementation Details"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h2>Chapter Outline<span class=\"tocSkip\"></span></h2>\n",
    "<hr>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#1.-Introduction\" data-toc-modified-id=\"1.-Introduction-1\">1. Introduction</a></span></li><li><span><a href=\"#2.-Numpy-Arrays\" data-toc-modified-id=\"2.-Numpy-Arrays-2\">2. Numpy Arrays</a></span></li><li><span><a href=\"#3.-Memory-Layout-and-Strides\" data-toc-modified-id=\"3.-Memory-Layout-and-Strides-3\">3. Memory Layout and Strides</a></span></li><li><span><a href=\"#4.-Why-Do-We-Care?\" data-toc-modified-id=\"4.-Why-Do-We-Care?-4\">4. Why Do We Care?</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter Learning Objectives\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Understand at a high level how NumPy arrays are stored in memory.\n",
    "- Explain the concept of \"strides\" in NumPy.\n",
    "- Use strides to efficiently access data with NumPy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Introduction\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this chapter, I'll show more about how NumPy manages and stores arrays in memory. I'll stress that a thorough understanding of the NumPy internals like how memory is handled and accessed is really more for developers working on super-optimized algorithms or for those interested in these kinds of things. The data scientist who does not care about these implementation details can skip this chapter and just continue to visualize and use arrays as N-dimensional data structures - afterall the point of NumPy is to abstract away the technical implementation details so such users can focus on writing code and wrangling data!\n",
    "\n",
    "This chapter draws on excellent material presented in:\n",
    "- [The NumPy documentation](https://numpy.org/doc/stable/reference/internals.html).\n",
    "- [Guide to NumPy](https://web.mit.edu/dvp/Public/numpybook.pdf) by Travis Oliphant, 2006."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Numpy Arrays\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that an N-dimensional array (\"ndarray\") is just a *homogenous* set of elements. You may be more familiar with the term \"vector\" (a 1-d array) or a \"matrix\" (a 2-d array). There are two key pieces of information that describe any given ndarray:\n",
    "\n",
    "1. The shape of the array; and,\n",
    "2. The datatype of the array elements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can think of the shape of an ndarray as the \"length\" of each dimension. For example, consider the following vector which has 6 elements and shape `(6,)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4, 5, 6])\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This vector has one dimension full of 6 elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The shape of this ndarray is: (6,)\n",
      " The number of dimensions is: 1\n",
      "   The number of elements is: 6\n"
     ]
    }
   ],
   "source": [
    "print(f\"The shape of this ndarray is: {a.shape}\")\n",
    "print(f\" The number of dimensions is: {a.ndim}\")\n",
    "print(f\"   The number of elements is: {a.size}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compare this vector to the following matrix of shape `(2, 3)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 2, 3],\n",
    "              [4, 5, 6]])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The shape of this ndarray is: (2, 3)\n",
      " The number of dimensions is: 2\n",
      "   The number of elements is: 6\n"
     ]
    }
   ],
   "source": [
    "print(f\"The shape of this ndarray is: {a.shape}\")\n",
    "print(f\" The number of dimensions is: {a.ndim}\")\n",
    "print(f\"   The number of elements is: {a.size}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, here's a 4-d array (try visualizing that! 🤷‍♂️):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[[ 0,  1],\n",
       "         [ 2,  3],\n",
       "         [ 4,  5]],\n",
       "\n",
       "        [[ 6,  7],\n",
       "         [ 8,  9],\n",
       "         [10, 11]],\n",
       "\n",
       "        [[12, 13],\n",
       "         [14, 15],\n",
       "         [16, 17]]],\n",
       "\n",
       "\n",
       "       [[[18, 19],\n",
       "         [20, 21],\n",
       "         [22, 23]],\n",
       "\n",
       "        [[24, 25],\n",
       "         [26, 27],\n",
       "         [28, 29]],\n",
       "\n",
       "        [[30, 31],\n",
       "         [32, 33],\n",
       "         [34, 35]]]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(36).reshape(2, 3, 3, 2)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The shape of this ndarray is: (2, 3, 3, 2)\n",
      " The number of dimensions is: 4\n",
      "   The number of elements is: 36\n"
     ]
    }
   ],
   "source": [
    "print(f\"The shape of this ndarray is: {a.shape}\")\n",
    "print(f\" The number of dimensions is: {a.ndim}\")\n",
    "print(f\"   The number of elements is: {a.size}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Data Type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All ndarrays are homogeneous, meaning that every element has the exact same data-type (e.g., integer, float, string, etc) which takes up the exact same amount of memory.\n",
    "\n",
    "For example, consider the following 1d-array which is full of 8-bit integers (`int8`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6], dtype=int8)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4, 5, 6], dtype='int8')\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One byte is equal to eight bits ([refresh yourself on bits and bytes here](https://web.stanford.edu/class/cs101/bits-bytes.html)), so for this array of `int8` data-types, we would expect each element to take up one byte. We can confirm using:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.itemsize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> An aside on the difference between e.g., `int8`, `int16`, `int32`. The number here refers to the number of bits used to represent each integer. For example, `int8` is an integer represented with one byte (one byte = 8 bits). Recall that bits are the basic unit of information \"0/1\" used by computers. So the maximum *unsigned* number that can be held with an `int8` datatype is: 2^8 (but because Python indexes from 0, the unsigned range of `int8` is 0 to 257). If we wish to have negative numbers, we need to use one of those bits to represent the sign, and we are left with 2^7 bits to make numbers with, and so the signed range of `int8` is -128 to +127. Likewise, `int16` has an unsigned range of 0 to 65,535 (2^16), or a signed range of -32,768 to +32,767, etc. It's interesting to watch what happens if you try to use a dtype that does not support the number you wish to store:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 126,  127, -128, -127, -126, -125, -124], dtype=int8)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([126, 127, 128, 129, 130, 131, 132], dtype='int8')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Above, notice how when we exceeded the integer 127 (the max of the `int8` signed range), NumPy automatically represents this number by counting up from the minimum of the signed range (-128). Cool! Of course, this wouldn't be a problem if we used `int16`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([126, 127, 128, 129, 130, 131, 132], dtype=int16)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([126, 127, 128, 129, 130, 131, 132], dtype='int16')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally I'll say that technically it is possible to have mixed data-types in an array (i.e., a heterogenous array), but in this case, the array still \"sees\" each element as the same thing: a reference to some Python object, and the dtype would be \"object\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([list(['a', 'b', 'c']), 1, 3.14159], dtype=object)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([['a', 'b', 'c'], 1, 3.14159], dtype='object')\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above is an ndarrays of objects, each one being a reference to some other Python object with its own data-type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[list, int, float]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(type, a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using arrays like this negates much of the optimized functionality that comes with them, and I can't recall a time when I've used a \"heterogenous array\". For mixed data-types, I would typically use other structures like lists or dictionaries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Memory Layout and Strides\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we've covered the basic concepts of ndarrays, we can talk more about how arrays are represented in memory. An ndarray is stored as a single “chunk” of memory starting at some location. It's helpful to think of it as a one-dimensional sequence in memory but with \"fancy indexing\" that can help map an N-dimensional index (for ndarrays) into that one-dimensional representation.\n",
    "\n",
    "Consider \"**Panel a**\" in the below conceptual figure from the paper [Array programming with NumPy](https://www.nature.com/articles/s41586-020-2649-2), showing how a 2d-array of data-type `int64` (8 bytes) is represented in memory as a single chunk:\n",
    "\n",
    "![](img/chapter5/numpy_paper.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That word **strides** is the number of bytes you need to step in each dimension when traversing the array. As you can see in the example, the **stride** information is particularly important for mapping the chunk of memory back to a n-dimensional array structure. So in the above case, the strides is `(24, 8)` meaning 24 bytes (three 8-byte `int64` elements) and 8 bytes (one 8-byte `int64` element), meaning that every 3 elements we increment our first dimension (i.e., move to the next row) and every 1 element we increment our second dimension (i.e., move to the next column).\n",
    "\n",
    "Let's go through another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]], dtype=int16)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 2], [3, 4], [5, 6]], dtype='int16')\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we have an ndarray of shape `(3, 2)` and with a dtype of `int16` (2 bytes per element in the array). We would expect the stride to be `(4, 2)` (every 4 bytes, which is 2 elements here for `int16`, we begin a new row, and every 2 bytes, which is 1 element here, we begin a new column). We can confirm with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 2)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.strides"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neat! We could actually change how our ndarray maps from the memory block back to the ndarray by changing the stride information:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3],\n",
       "       [2, 4],\n",
       "       [3, 5]], dtype=int16)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.strides = (2, 4)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To further drive the point home, what do you expect the strides to be of a 1D array? In that case, there is only one dimension to traverse, so we'd expect the strides to just be the number of bytes of 1 element, `(2,)` (i.e., every 2 bytes, which is one `int16` element). Let's confirm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 2, 4, 3, 5], dtype=int16)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = a.flatten()\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2,)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.strides"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's look at the strides of the following 3D array of size `(3,3,2)` but with the data-type `int8` (so that 1 byte = 1 element which makes interpreting strides a little easier). Visualizing 3D arrays starts to get a bit tricker, but I think of them as matrices stacked together like slices in a loaf of bread, or multiple chessboards stacked on top of each other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1],\n",
       "        [ 2,  3],\n",
       "        [ 4,  5]],\n",
       "\n",
       "       [[ 6,  7],\n",
       "        [ 8,  9],\n",
       "        [10, 11]],\n",
       "\n",
       "       [[12, 13],\n",
       "        [14, 15],\n",
       "        [16, 17]]], dtype=int8)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(18, dtype='int8').reshape(3, 3, 2)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6, 2, 1)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.strides"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now things are getting a little more confusing! The above is saying that every 6 elements we increment a \"depth dimension\", every 2 elements we increment a \"row dimension\" and every 1 element we increment a \"column dimension\". Using our chessboard analogy, every 6 elements in memory we move to the next chessboard in the stack, every 2 elements we move down one row of a chessboard and every element we move across 1 column of our chessboard. I'll talk more about this 3D example in the next section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Why Do We Care?\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reshaping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One sometimes confusing topic in NumPy is understanding how ndarrays are reshaped. But now that you understand how ndarrays are represented in memory, you can better understand how reshaping works in NumPy too! Basically, you can think of reshaping as viewing that \"chunk\" of memory in a different way (reading it into a different shape but preserving the ordering of the data in memory). Consider the same 2D array we just saw earlier, but with the data-type `int8` (so that 1 byte = 1 element which makes interpreting strides a little easier):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]], dtype=int8)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 2], [3, 4], [5, 6]], dtype='int8')\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 1)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.strides"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we reshape the array, think of it as flattening the array out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6], dtype=int8)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.flatten()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And then reading that data back into a different shape with different strides. Below I'll change the shape to be `(2, 3)`, which means that we'll need strides of `(3, 1)` (every 3 elements, increment a row, every 1 element, increment a column in the array)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]], dtype=int8)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape = (2, 3)\n",
    "a.strides = (3, 1)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Above, I didn't need to do `a.strides`. When I changed the shape to `(2, 3)`, NumPy already took care of changing the strides for me, but I'm showing it for demonstration purposes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same logic applies to reshaping ndarrays of more than 2 dimensions. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17], dtype=int8)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(18, dtype='int8')\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1],\n",
       "        [ 2,  3],\n",
       "        [ 4,  5]],\n",
       "\n",
       "       [[ 6,  7],\n",
       "        [ 8,  9],\n",
       "        [10, 11]],\n",
       "\n",
       "       [[12, 13],\n",
       "        [14, 15],\n",
       "        [16, 17]]], dtype=int8)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = a.reshape(3, 3, 2)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6, 2, 1)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.strides"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example, we have three 2D matrix stacked together (I'll call them \"slices\"). We use the first 6 elements of our flattened array to fill in the first \"slice\", and within that 2D slice, those elements are arranged in rows and columns dictated by the strides (i.e., every 2 elements increment a row and every 1 element increment a column). Once we've used the first 6 elements, we traverse a dimensional \"slice\" and use the next 6 element to fill that 2D slice. We then repeat that one more time for the last \"slice\".\n",
    "\n",
    "You might be wondering two things at this point:\n",
    "\n",
    "1. Why is our array above composed of 3 slices of 3x2 matrices and not 2 slices of 3x3 matrices? \n",
    "2. how did NumPy decide to fill each 2D matrix slice with elements first, why not fill along the \"depth\" dimension first?\n",
    "\n",
    "These questions are related and actually much deeper than you might expect. They are explained in detail in the [NumPy documentation](https://numpy.org/doc/stable/reference/internals.html#multidimensional-array-indexing-order-issues) and in section *2.3 Memory Layout of ndarray* in the book [Guide to NumPy](https://web.mit.edu/dvp/Public/numpybook.pdf) by Travis Oliphant, but they are to do with the fundamental implementation of how NumPy reads data from memory.\n",
    "\n",
    "Briefly, NumPy uses \"row-major\" indexing when reading data from memory which basically means that \"grouping\" starts from the left most index. So for a 2D array, the order is `(row, column)`, for a 3D array the order is `(depth, row, column)`, for a 4D array it is `(4th dimension, depth, row, column)`, etc. The way I think about this is that the ndarray is a container, in the 3D case I think of a cube made up of stacked matrices. I can enter this for container (\"dimension\") and view a matrix. The next container is a \"row\" of values which comprises one smaller container for each \"column\". There are two overarching styles that dictate the way data is read in from memory, they are the \"C style\" and \"Fortran style\". NumPy uses the \"C style\" by default which is what we saw above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1],\n",
       "        [ 2,  3],\n",
       "        [ 4,  5]],\n",
       "\n",
       "       [[ 6,  7],\n",
       "        [ 8,  9],\n",
       "        [10, 11]],\n",
       "\n",
       "       [[12, 13],\n",
       "        [14, 15],\n",
       "        [16, 17]]], dtype=int8)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(18, dtype='int8').reshape(3, 3, 2, order=\"C\")\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But there is also the \"Fortran style\", which you can see in the example below and can specify using the `order` argument, which appears to fill the \"depth\" dimension first:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  9],\n",
       "        [ 3, 12],\n",
       "        [ 6, 15]],\n",
       "\n",
       "       [[ 1, 10],\n",
       "        [ 4, 13],\n",
       "        [ 7, 16]],\n",
       "\n",
       "       [[ 2, 11],\n",
       "        [ 5, 14],\n",
       "        [ 8, 17]]], dtype=int8)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(18, dtype='int8').reshape(3, 3, 2, order=\"F\")\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These implementation details are not really necessary to know unless your developing algorithms or packages like NumPy that are directly interfacing with a computer's memory."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Super-speed Code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Knowing about how ndarrays are stored in memory and what strides are can help us leverage some pretty nifty tricks to speed up our numpy code. Consider performing convolution on a 2D image by passing a filter window of \"weights\" over the image pixels. For example:\n",
    "\n",
    "![](img/chapter6/conv.gif)\n",
    "\n",
    "Source: [hackernoon.com](https://hackernoon.com/visualizing-parts-of-convolutional-neural-networks-using-keras-and-cats-5cc01b214e59)\n",
    "\n",
    "There are plenty of ways to solve this problem. The goal is really to apply our filter to windowed segments of our array. One way we can \"view\" our array as windows is using strides and the `numpy.lib.stride_tricks` module. Here's a 400 x 400 pixel image of yours truly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "from numpy.lib.stride_tricks import as_strided\n",
    "plt.style.use('ggplot')\n",
    "plt.rcParams.update({'font.size': 16, 'figure.figsize': (8,6), 'axes.grid': False})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'plt' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-65e80ed6e478>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mimage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'img/chapter6/tomas_beuzen.png'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimage\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'gray'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'plt' is not defined"
     ]
    }
   ],
   "source": [
    "image = plt.imread('img/chapter6/tomas_beuzen.png')[:,:,0]\n",
    "plt.imshow(image, cmap='gray');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the filter I want to apply to the image:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = np.array([[-2, -1, 0],\n",
    "              [-1, 1, 1],\n",
    "              [0, 1, 2]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now I'll use strides to view the image as 3 x 3 windows, so I can there just apply the filter to every single window. Basically the goal here is to view our array as a series of 3x3 windows. So think of this as for each pixel in our image, we want to view a 3x3 window around that pixel. We have 400x400 pixels, and if we have a 3x3 window for each pixel, we will have a 4D view of our array with shape `(400, 400, 3, 3)`. In this case, we can't have a 3x3 window at the edges of the image, so I'm just going to cut those off with our final shape being `(398, 398, 3, 3)` (but you could just pad the image with 0's to apply the filter at the edges if you wanted to). Once we have our 4D view, I can just apply the filter to each of those 3x3 windows and sum the numbers in each window. No `for` loops are complex functions needed!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time taken for convolution: 0.0329s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "start = time.time()    # start time\n",
    "size = f.shape[0]      # filter size\n",
    "win_img = as_strided(  # Now use as_strided to get a windowed view of the array\n",
    "    image,             # image to view as windows\n",
    "    shape=(image.shape[0] - size + 1, image.shape[1] - size + 1, size, size),  # the shape of the new view (398, 398, 3, 3), the edge pixels are cut-off, but we could always pad if we wanted to here\n",
    "    strides=image.strides * 2,  # this just duplicates the strides as we are now working in 4 dimensions, strides will be (6400, 16, 6400, 16)\n",
    ")\n",
    "filtered_image = (win_img * f).sum(axis=(2, 3))  # apply filter to each window (the 3rd and 4th dimensions of win_img)\n",
    "plt.imshow(filtered_image, cmap=\"gray\")\n",
    "print(f\"Wall time taken for convolution: {time.time()-start:.4f}s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is some wicked fast convolution! 🚀\n",
    "\n",
    "If that example was a little too much for you right now, Jessica Yung provides a nice simple example of using arrays and strides in the blog post [What makes Numpy Arrays Fast: Memory and Strides](https://www.jessicayung.com/numpy-arrays-memory-and-strides/)."
   ]
  }
 ],
 "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.7.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}