How it works - data structures for deep learning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview\n",
    "\n",
    "I recently completed the [Udacity Deep Learning Nanodegree](https://www.udacity.com/course/deep-learning-nanodegree--nd101) which focuses on implementing a variety of deep learning architectures using [PyTorch](https://pytorch.org/). At the outset it's pretty fundamental to understand the data structures you'll be encountering as inputs and outputs - this tutorial aims to cover all those basics, but <i>does</i> assume a good level of prior Python knowledge and a smattering of linear algebra. I hope it may help you to get up and running quickly!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First things first... structures in Python and Numpy\n",
    "Just a quick reminder: these are the 4 types of structures we'll be encountering:\n",
    "<img src='data_structures.png' width='80%' /><p>\n",
    "Let's take a look how these work in Numpy which you should be more accustomed to, (and then we'll move onto PyTorch, as well as how to go back and forth between these two worlds)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scalars\n",
    "Scalars have 0 dimensions and are essentially just single numbers:<p>\n",
    "    <b>1, 3.4, 19, etc.</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output:  5\n",
      "Shape:  ()\n",
      "Type:  <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# If you want to create a NumPy array that holds a scalar\n",
    "# pass the value to NumPy's array function, like so:\n",
    "s = np.array(5)\n",
    "print('Output: ', s)\n",
    "print('Shape: ', s.shape)\n",
    "print('Type: ', type(s))\n",
    "# Notice how the shape has 0 dimensions!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output:  8\n",
      "Shape:  ()\n",
      "Type:  <class 'numpy.int64'>\n"
     ]
    }
   ],
   "source": [
    "# Even though scalars are inside arrays, you can still use them like a normal scalar or single number. So you could \n",
    "# quite feasibly add a scalar and an integer - but notice the output is an integer, and no longer an array:\n",
    "x = s + 3\n",
    "print('Output: ', x)\n",
    "print('Shape: ', x.shape)\n",
    "print('Type: ', type(x))\n",
    "# It's important to always be aware of input types and resulting output types!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vectors\n",
    "Vectors have 1 dimension and are essentially lists of numbers:<p>\n",
    "Row vector (aka 1 x 3 matrix):<br>\n",
    "    <b>1 2 3</b><p>\n",
    "Column vector (aka 3 x 1 matrix):<br>\n",
    "    <b>1<br>\n",
    "    2<br>\n",
    "    3</b><br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output:  [1 2 3]\n",
      "Shape:  (3,)\n",
      "Type:  <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# To create a vector, you'd pass a Python list to the array function, like this:\n",
    "v = np.array([1,2,3])\n",
    "print('Output: ', v)\n",
    "print('Shape: ', v.shape)\n",
    "print('Type: ', type(v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# You can access an element within the vector using indices, like this:\n",
    "x = v[1]\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 3]\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# NumPy also supports slicing, negative indexation, etc. just like you'd expect it to:\n",
    "print(v[1:])\n",
    "print(v[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrices\n",
    "Matrices have 2 dimensions and essentially form a grid of values:<p>\n",
    "    <b>1 2 3<br>\n",
    "       4 5 6<br>\n",
    "       7 8 9</b>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output: \n",
      " [[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "Shape:  (3, 3)\n",
      "Type:  <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# You create matrices using NumPy's array function, just as you did for vectors. \n",
    "# However, instead of just passing in a list, you need to supply a list of lists, \n",
    "# where each list represents a *row*:\n",
    "m = np.array([[1,2,3], [4,5,6], [7,8,9]])\n",
    "print('Output: \\n', m)\n",
    "print('Shape: ', m.shape)\n",
    "print('Type: ', type(m))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Access elements via their indices - note unlike Excel (yes I DO still use Excel!), indices go [row][column]\n",
    "m[1][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tensors\n",
    "Tensors can have n dimensions, so they'll often get harder to visualize mentally! A typical example might be a tensor for an image which will have a grid of pixels by 3 RGB color channels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output: \n",
      " [[[[ 1]\n",
      "   [ 2]]\n",
      "\n",
      "  [[ 3]\n",
      "   [ 4]]\n",
      "\n",
      "  [[ 5]\n",
      "   [ 6]]]\n",
      "\n",
      "\n",
      " [[[ 7]\n",
      "   [ 8]]\n",
      "\n",
      "  [[ 9]\n",
      "   [10]]\n",
      "\n",
      "  [[11]\n",
      "   [12]]]\n",
      "\n",
      "\n",
      " [[[13]\n",
      "   [14]]\n",
      "\n",
      "  [[15]\n",
      "   [16]]\n",
      "\n",
      "  [[17]\n",
      "   [17]]]]\n",
      "Shape:  (3, 3, 2, 1)\n",
      "Type:  <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# To create a 3x3x2x1 tensor, you could do the following:\n",
    "t = np.array([[[[1],[2]],[[3],[4]],[[5],[6]]],[[[7],[8]],\\\n",
    "    [[9],[10]],[[11],[12]]],[[[13],[14]],[[15],[16]],[[17],[17]]]])\n",
    "print('Output: \\n', t)\n",
    "print('Shape: ', t.shape)\n",
    "print('Type: ', type(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that you read the shape from the outside in: so this tensor has 3 outer groupings, each of which has 3 groupings itself, each of which contains a group of 2 items, each of which is made up of 1 item.<p>\n",
    "<img src='tensor_shape_2.png' width='30%' /><p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can access items just like with matrices, but with more indices - read from the outside in as described above\n",
    "t[2][1][1][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Changing shapes\n",
    "Sometimes you'll need to change the shape of your data without actually changing its contents. For example, you may have a vector, which is one-dimensional, but need a matrix, which is two-dimensional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output: \n",
      " [1 2 3 4]\n",
      "Shape:  (4,)\n",
      "Type:  <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# Let's take a row vector\n",
    "v = np.array([1,2,3,4])\n",
    "print('Output: \\n', v)\n",
    "print('Shape: ', v.shape)\n",
    "print('Type: ', type(v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output: \n",
      " [[1 2 3 4]]\n",
      "Shape:  (1, 4)\n",
      "Type:  <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# You can transform this to a 1 x 4 matrix\n",
    "x = v.reshape(1,4)\n",
    "print('Output: \\n', x)\n",
    "print('Shape: ', x.shape)\n",
    "print('Type: ', type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output: \n",
      " [[1]\n",
      " [2]\n",
      " [3]\n",
      " [4]]\n",
      "Shape:  (4, 1)\n",
      "Type:  <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# Or even to a 4 x 1 matrix!\n",
    "x = v.reshape(4,1)\n",
    "print('Output: \\n', x)\n",
    "print('Shape: ', x.shape)\n",
    "print('Type: ', type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output: \n",
      " [[1 2 3 4]]\n",
      "Shape:  (1, 4)\n",
      "Type:  <class 'numpy.ndarray'>\n",
      "Output: \n",
      " [[1]\n",
      " [2]\n",
      " [3]\n",
      " [4]]\n",
      "Shape:  (4, 1)\n",
      "Type:  <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# Instead of reshape you may see variants like this:\n",
    "x = v[None, :]\n",
    "print('Output: \\n', x)\n",
    "print('Shape: ', x.shape)\n",
    "print('Type: ', type(x))\n",
    "x = v[:, None]\n",
    "print('Output: \\n', x)\n",
    "print('Shape: ', x.shape)\n",
    "print('Type: ', type(x))\n",
    "# For clarity I must say I prefer np.reshape()!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating empty structures\n",
    "You may sometimes want to create an 'empty' array of the right shape, ready to feed data into - this is quite easy to do with np.zeros(). You'll usually populate it with data later on by referring to each location by its index - so again it will be important to have a clear picture of what each level represents:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty_matrix = np.zeros(shape = (3, 4))\n",
    "empty_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0., 0.],\n",
       "        [0., 0.],\n",
       "        [0., 0.],\n",
       "        [0., 0.]],\n",
       "\n",
       "       [[0., 0.],\n",
       "        [0., 0.],\n",
       "        [0., 0.],\n",
       "        [0., 0.]],\n",
       "\n",
       "       [[0., 0.],\n",
       "        [0., 0.],\n",
       "        [0., 0.],\n",
       "        [0., 0.]]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty_tensor = np.zeros(shape = (3, 4, 2))\n",
    "empty_tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### In the real world... some practical examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Natural language processing - vectors of words\n",
    "When working with words, we'll typically be dealing with vectors, for example, if we have the following sentence:<p>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;<i>I went on a wonderful holiday with a friend to see the sea and I had a marvellous time</i><p>\n",
    "We might convert it into a sequence of numbers, and then represent the words in the sentence as follows:<p>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;<i>[0, 2, 3, 1, 4, 5, 6, 7, 8, 9, 10, 0, 11, 1, 12, 13]</i><p>\n",
    "That process will typically work something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I went on a wonderful holiday with a friend to see the sea and I had a marvellous time\n"
     ]
    }
   ],
   "source": [
    "# We have a sentence which is just a string of words:\n",
    "my_sentence = 'I went on a wonderful holiday with a friend to see the sea and I had a marvellous time'\n",
    "print(my_sentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['i', 'went', 'on', 'a', 'wonderful', 'holiday', 'with', 'a', 'friend', 'to', 'see', 'the', 'sea', 'and', 'i', 'had', 'a', 'marvellous', 'time']\n"
     ]
    }
   ],
   "source": [
    "# We split those words so each word becomes a separate item in a list:\n",
    "word_list = my_sentence.lower().split(' ')\n",
    "print(word_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 0,\n",
       " 'i': 1,\n",
       " 'went': 2,\n",
       " 'on': 3,\n",
       " 'wonderful': 4,\n",
       " 'holiday': 5,\n",
       " 'with': 6,\n",
       " 'friend': 7,\n",
       " 'to': 8,\n",
       " 'see': 9,\n",
       " 'the': 10,\n",
       " 'sea': 11,\n",
       " 'and': 12,\n",
       " 'had': 13,\n",
       " 'marvellous': 14,\n",
       " 'time': 15}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We use some method to get all the words in the vocab and turn them into numbers\n",
    "# Here we use Counter to get a list of unique words and then number them based on frequency\n",
    "# Notice how 'a' occurs most frequently so it becomes item 0, \n",
    "# then 'i' occurs next most frequently so it becomes item 1 and so on\n",
    "from collections import Counter\n",
    "counts = Counter(word_list)\n",
    "vocab = sorted(counts, key=counts.get, reverse=True)\n",
    "word2idx = {w: idx for (idx, w) in enumerate(vocab)}\n",
    "word2idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output: \n",
      " [ 1  2  3  0  4  5  6  0  7  8  9 10 11 12  1 13  0 14 15]\n",
      "Shape:  (19,)\n",
      "Type:  <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# And then we turn the word list into a vector\n",
    "my_sentence_numeric = np.array([word2idx[word] for word in word_list])\n",
    "print('Output: \\n', my_sentence_numeric)\n",
    "print('Shape: ', my_sentence_numeric.shape)\n",
    "print('Type: ', type(my_sentence_numeric))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Black & white images - matrices\n",
    "Black and white images will often be represented as matrices - each pixel in the image has a location in terms of height and width (the 2 dimensions of our matrix) but there is only one colour channel: representing shades of grey between pure black and pure white.<p>\n",
    "The MNIST images are the most typical toy examples that you'll come across - here we see a sample '5':\n",
    "<img src='img_5.png' width='10%' /><p>\n",
    "Here's how a typical image import happens:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# One way to work with image data is using matplotlib:\n",
    "import os\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape:  (280, 280)\n",
      "Type:  <class 'numpy.ndarray'>\n",
      "Min and max values: 0.003921568859368563 and 1.0\n"
     ]
    }
   ],
   "source": [
    "# We can use the imread() function to import the above 'png' file - \n",
    "# and hey presto! it's just another array of numbers!\n",
    "img_5_plt = plt.imread('img_5.png')\n",
    "print('Shape: ', img_5_plt.shape)\n",
    "print('Type: ', type(img_5_plt))\n",
    "print('Min and max values: {} and {}'.format(img_5_plt.min(), img_5_plt.max()))\n",
    "# Notice that it's an array with 2 dimensions, i.e. a matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x10becff60>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "# We can plot our number as follows:\n",
    "plt.imshow(img_5_plt, cmap='binary_r')\n",
    "# Note plt.imshow() assumes an RGB colour channel which is why we need to tell it what colormap to use\n",
    "# for our black and white only scenario (you can try running this cell again without the cmap parameter\n",
    "# to see what I mean!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x10c050470>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "# Each pixel's location can be expressed by referencing our array - this is easiest seen by \n",
    "# 'drawing a line' across our number, i.e. changing the value of some white pixels to black:\n",
    "img_5_plt[25][50:225] = 0.01\n",
    "plt.imshow(img_5_plt, cmap='binary_r')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Colour images - tensors representing RGB colour channels\n",
    "Colour images are usually represented as tensors - each pixel in the image has a location in terms of height and width AND the colour channel it belongs to (R, G, and B)<p>\n",
    "Here is a small sea picture from my holiday:\n",
    "<img src='sea_picture.jpg' width='20%' /><p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape:  (256, 256, 3)\n",
      "Type:  <class 'numpy.ndarray'>\n",
      "Min and max values: 0 and 249\n"
     ]
    }
   ],
   "source": [
    "# Let's read that image in - again just and array, but with more dimensions:\n",
    "image_sea_plt = plt.imread('sea_picture.jpg')\n",
    "print('Shape: ', image_sea_plt.shape)\n",
    "print('Type: ', type(image_sea_plt))\n",
    "print('Min and max values: {} and {}'.format(image_sea_plt.min(), image_sea_plt.max()))\n",
    "# Notice that it's an array with 3 dimensions, i.e. a tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1040e3c18>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "# Because this is a regular RGB image we can plot it with plt.imshow() and no additional parameters:\n",
    "plt.imshow(image_sea_plt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# And we can view the values at a specific point using indexation or slicing as we've come to expect:\n",
    "image_sea_plt[0][0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape:  (256, 256, 3)\n",
      "Type:  <class 'numpy.ndarray'>\n",
      "Min and max values: 0 and 249\n"
     ]
    }
   ],
   "source": [
    "# We could equally well have used OpenCV to read in the image - the results are the same, again an array:\n",
    "import cv2\n",
    "image_sea_cv = cv2.imread('sea_picture.jpg')\n",
    "print('Shape: ', image_sea_cv.shape)\n",
    "print('Type: ', type(image_sea_cv))\n",
    "print('Min and max values: {} and {}'.format(image_sea_cv.min(), image_sea_cv.max()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Flattening image arrays - re-shaping in action\n",
    "With deep learning we'll usually 'flatten' a matrix or tensor before doing a forward pass through the network - so we'd want to take a multi-dimensional thing (matrix or tensor), and turn it into a one-dimensional vector like, a bit like this:\n",
    "<img src='flattening.png' width='50%' /><p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(280, 280)\n"
     ]
    }
   ],
   "source": [
    "# Let's remind ourselves of the shape of our sample MNIST '5':\n",
    "print(img_5_plt.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 78400)\n"
     ]
    }
   ],
   "source": [
    "# And now we can flatten it - note the '-1' notation is a nifty way of saying \n",
    "# 'just fit the other dimensions in' so it works out that the vector length is \n",
    "# 78400 in this case (280 x 280)\n",
    "img_5_flattened = img_5_plt.reshape(1,-1)\n",
    "print(img_5_flattened.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(256, 256, 3)\n"
     ]
    }
   ],
   "source": [
    "# Let's remind ourselves of the shape of my holiday sea picture:\n",
    "print(image_sea_plt.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 196608)\n"
     ]
    }
   ],
   "source": [
    "# And now we can flatten it - note the '-1' notation is a nifty way of saying \n",
    "# 'just fit the other dimensions in' so it works out that the vector length is \n",
    "# 196608 in this case (256 x 256 x 3)\n",
    "image_sea_flattened = image_sea_plt.reshape(1, -1)\n",
    "print(image_sea_flattened.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Element-wise operations\n",
    "Here's how we perform math functions on matrices (or vectors or tensors)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's setup our initial matrix\n",
    "m = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3,  4,  5],\n",
       "       [ 6,  7,  8],\n",
       "       [ 9, 10, 11]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Adding a number to the matrix adds that number to each element within the matrix\n",
    "2 + m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5, 1. , 1.5],\n",
       "       [2. , 2.5, 3. ],\n",
       "       [3.5, 4. , 4.5]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Same with dividing by a number\n",
    "m/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  4,  6],\n",
       "       [ 8, 10, 12],\n",
       "       [14, 16, 18]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# What about adding 2 matrices? Take each number at the corresponding index and add it, so 1 + 1, 2 + 2, etc.\n",
    "# Because the operations are done index by index the matrices have to be the same shape!\n",
    "m + m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4,  9],\n",
       "       [16, 25, 36],\n",
       "       [49, 64, 81]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# What about multiplying 2 matrices? Same principle applies:\n",
    "m * m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0]\n",
      " [0 0 0]\n",
      " [0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "# What if you have your matrix already and you want to re-use it by setting the contents to 0? Multiply by 0!\n",
    "m *= 0\n",
    "print(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dot product\n",
    "Let's take the example of 2 vectors:<br>\n",
    "[9, 2, 4, 16] . [1, 7, 13, 0]<p>\n",
    "To find the dot product we'll perform element-wise multiplication and then add the results to produce a single number, i.e. <br>\n",
    "the sum of : 9 x 1, 2 x 7, 4 x 13, 16 x 0 = 75<p>\n",
    "Note we always need 2 vectors of <i>equal length</i>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "75"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 = np.array([9, 2, 4, 16])\n",
    "v2 = np.array([1, 7, 13, 0])\n",
    "v1@v2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix product\n",
    "Take a series of dot products between every <b>ROW</b> in the left matrix and every <b>COLUMN</b> in the right matrix. Note that because we'll be taking the dot product for rows by columns, the number of columns in the first matrix needs to be the same length as the number of rows in the second matrix - in this case 4. Check the shapes of the first and the second: if the inner numbers are the same you can go ahead and multiply!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output: \n",
      " [[ 9  2  4 16]\n",
      " [ 8 10 12 14]]\n",
      "Output: \n",
      " [[ 1  3  5]\n",
      " [ 7  9 11]\n",
      " [13 15 17]\n",
      " [ 0 21 23]]\n",
      "Shapes:  (2, 4) (4, 3)\n"
     ]
    }
   ],
   "source": [
    "# Let's setup our matrices and check their shapes\n",
    "m1 = np.array([[9, 2, 4, 16], [8, 10, 12, 14]])\n",
    "m2 = np.array([[1, 3, 5], [7, 9, 11], [13, 15, 17], [0, 21, 23]])\n",
    "print('Output: \\n', m1)\n",
    "print('Output: \\n', m2)\n",
    "print('Shapes: ', m1.shape, m2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 75, 441, 503],\n",
       "       [234, 588, 676]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# And now we do matrix multiplications\n",
    "m1@m2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checking = m1@m2\n",
    "checking.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  3  5]\n",
      " [ 7  9 11]]\n",
      "[[ 0  6]\n",
      " [ 2  8]\n",
      " [ 4 10]]\n",
      "Shapes:  (2, 3) (3, 2)\n"
     ]
    }
   ],
   "source": [
    "# How does shape affect the answer? Scenario 1\n",
    "m1a = np.array([[1, 3, 5], [7, 9, 11]])\n",
    "m1b = np.array([[0, 6], [2, 8], [4, 10]])\n",
    "print(m1a)\n",
    "print(m1b)\n",
    "print('Shapes: ', m1a.shape, m1b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 26  80]\n",
      " [ 62 224]]\n",
      "Shape:  (2, 2)\n"
     ]
    }
   ],
   "source": [
    "# Notice how when we multiply them together the resulting answer has\n",
    "# the same number of rows as our first matrix and the same number of \n",
    "# columns as our second matrix\n",
    "answer1 = m1a@m1b\n",
    "print(answer1)\n",
    "print('Shape: ', answer1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 7]\n",
      " [3 9]\n",
      " [5 1]]\n",
      "[[ 0  2  4]\n",
      " [ 6  8 10]]\n",
      "Shapes:  (3, 2) (2, 3)\n"
     ]
    }
   ],
   "source": [
    "# How does shape affect the answer? Scenario 2 - essentially the same but shaped differently\n",
    "m2a = np.array([[1, 7], [3, 9], [5, 1]])\n",
    "m2b = np.array([[0, 2, 4], [6, 8, 10]])\n",
    "print(m2a)\n",
    "print(m2b)\n",
    "print('Shapes: ', m2a.shape, m2b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 42  58  74]\n",
      " [ 54  78 102]\n",
      " [  6  18  30]]\n",
      "Shape:  (3, 3)\n"
     ]
    }
   ],
   "source": [
    "# Notice how when we multiply them together the resulting answer has\n",
    "# the same number of rows as our first matrix and the same number of \n",
    "# columns as our second matrix\n",
    "answer2 = m2a@m2b\n",
    "print(answer2)\n",
    "print('Shape: ', answer2.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So multiplying a 10000 x 300 matrix by another 300 x 600 matrix will give you a 10000 x 6000 matrix.<br>\n",
    "Where multiplying a 300 x 600 matrix by another 300 x 10000 matrix will give you a 6000 x 10000 matrix.<br>\n",
    "So unlike standard multiplication, matrix multiplication is NOT commutative, i.2. A.B != B.A.<br>\n",
    "Data in the left matrix should be arranged as rows, while data in the right matrix should be arranged as columns.<br>\n",
    "<img src='multiplication.png' width='50%' /><p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 42  58  74]\n",
      " [ 54  78 102]\n",
      " [  6  18  30]]\n"
     ]
    }
   ],
   "source": [
    "# An alternative method is to use the matmul function\n",
    "answer2 = np.matmul(m2a, m2b)\n",
    "print(answer2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 42  58  74]\n",
      " [ 54  78 102]\n",
      " [  6  18  30]]\n"
     ]
    }
   ],
   "source": [
    "# You may also see the dot function but be careful as this is only really good for 2 dimensions\n",
    "answer2 = np.dot(m2a, m2b)\n",
    "print(answer2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix transpose\n",
    "This is where the values of the <b>ROWS</b> in the original matrix become the values of the <b>COLUMNS</b> in the transposed matrix.<p>\n",
    "This can be useful, e.g. in a situation where you need to perform matrix multiplication but the shapes of your matrices are incompatible. But this is a situation just like you'd have in Excel: if you're storing data in rows or columns it's going to make a difference what you shuffle about!<p>\n",
    "If both of the original matrices store their data as ROWS it's safe to use a transpose<p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 42,  58,  74],\n",
       "       [ 54,  78, 102],\n",
       "       [  6,  18,  30]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Remember our last matrix? Here it is again:\n",
    "answer2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 42,  54,   6],\n",
       "       [ 58,  78,  18],\n",
       "       [ 74, 102,  30]])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now compare the results once it's transposed - the values from ROW 0 have become the values for COLUMN 0\n",
    "answer2.transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 42,  54,   6],\n",
       "       [ 58,  78,  18],\n",
       "       [ 74, 102,  30]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Practically lots of people use .T because it's so much shorter to type\n",
    "answer2.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 42  54   6]\n",
      " [ 58  78  18]\n",
      " [ 74 102 400]]\n",
      "[[ 42  58  74]\n",
      " [ 54  78 102]\n",
      " [  6  18 400]]\n"
     ]
    }
   ],
   "source": [
    "# Be careful because even though you create a 'new' variable from one of these \n",
    "# it still references the original variable - notice how BOTH are updated to 400\n",
    "answer_t = answer2.T\n",
    "answer_t[2][2] = 400\n",
    "print(answer_t)\n",
    "print(answer2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A transpose use case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.27  0.45  0.64  0.31]]\n",
      "Shape:  (1, 4)\n"
     ]
    }
   ],
   "source": [
    "# We have a bunch of inputs, note the shape 1 x 4\n",
    "inputs = np.array([[-0.27,  0.45,  0.64, 0.31]])\n",
    "print(inputs)\n",
    "print('Shape: ', inputs.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.02   0.001 -0.03   0.036]\n",
      " [ 0.04  -0.003  0.025  0.009]\n",
      " [ 0.012 -0.045  0.28  -0.067]]\n",
      "Shape:  (3, 4)\n"
     ]
    }
   ],
   "source": [
    "# And a bunch of weights, note the incompatible shape 3 x 4\n",
    "weights = np.array([[0.02, 0.001, -0.03, 0.036], \\\n",
    "    [0.04, -0.003, 0.025, 0.009], [0.012, -0.045, 0.28, -0.067]])\n",
    "print(weights)\n",
    "print('Shape: ', weights.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that to multiply successfully we need the number of <b>ROWS</b> in the first matrix to equal the number of <b>COLUMNS</b> in the second matrix. In this case we need the shape of our second matrix to be (4, 3) and not (3, 4)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.01299  0.00664  0.13494]]\n",
      "Shape:  (1, 3)\n"
     ]
    }
   ],
   "source": [
    "# By transposing the weights we can multiply the 2 together\n",
    "updated_values = np.matmul(inputs, weights.T)\n",
    "print(updated_values)\n",
    "print('Shape: ', updated_values.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.01299]\n",
      " [ 0.00664]\n",
      " [ 0.13494]]\n",
      "Shape:  (3, 1)\n"
     ]
    }
   ],
   "source": [
    "# Similarly by transposing the inputs we can ALSO multiply the 2 together\n",
    "updated_values2 = np.matmul(weights, inputs.T)\n",
    "print(updated_values2)\n",
    "print('Shape: ', updated_values2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Notice how the answers are just transposes of each other, so which one you use \n",
    "# really just depends on the shape you want for the output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Special case with 1D vectors\n",
    "It's possible to get the transpose of an array like so arr.T, but for a 1D array, the transpose will return a row vector. Instead, use arr[:,None] to create a column vector:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's create a 1D vector for illustration purposes\n",
    "vec_1d = np.array([3, 6, 9])\n",
    "vec_1d.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 6 9]\n",
      "[3 6 9]\n"
     ]
    }
   ],
   "source": [
    "# Notice how transposing it makes no difference!\n",
    "print(vec_1d)\n",
    "print(vec_1d.transpose())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3],\n",
       "       [6],\n",
       "       [9]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# But this will work nicely, basically saying all of the elements from the vector and None for the second column\n",
    "vec_1d[:,None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 6 9]]\n",
      "[[3]\n",
      " [6]\n",
      " [9]]\n"
     ]
    }
   ],
   "source": [
    "# OR create the original 1D vector with TWO dimensions in the first place (quicker than reshaping after):\n",
    "vec_2d = np.array([3, 6, 9], ndmin = 2)\n",
    "print(vec_2d)\n",
    "print(vec_2d.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Coding a very simple forward pass\n",
    "A forward pass is just matrix multiplication in action:\n",
    "<img src='weight_matrix_detail_2.png' width='85%' /><p>\n",
    "Notice how the weight matrix has been constructed, where the number of rows is the same as the number of features in x, and the number of columns is the same as the number of hidden nodes in h:<p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 6 9]]\n",
      "(1, 3)\n"
     ]
    }
   ],
   "source": [
    "# features is 2D array containing the input data x1, x2, x3\n",
    "features = np.array([3, 6, 9]).reshape(1,3)\n",
    "print(features)\n",
    "print(features.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Number of records and input units\n",
    "n_records, n_inputs = features.shape\n",
    "print(n_records)\n",
    "print(n_inputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.80314015  0.51174729]\n",
      " [ 0.93638071 -0.1819504 ]\n",
      " [ 0.82375177 -0.07644257]]\n"
     ]
    }
   ],
   "source": [
    "# Set number of hidden units to 2\n",
    "n_hidden = 2\n",
    "# Generate random weights to fit our mini architecture\n",
    "weights_input_to_hidden = np.random.normal(0, n_inputs**-0.5, size=(n_inputs, n_hidden))\n",
    "print(weights_input_to_hidden)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 3)\n",
      "(3, 2)\n"
     ]
    }
   ],
   "source": [
    "# If we now check the shapes, we are ready to multiply!\n",
    "print(features.shape)\n",
    "print(weights_input_to_hidden.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10.62262974 -0.24444369]]\n",
      "(1, 2)\n"
     ]
    }
   ],
   "source": [
    "# Here we go\n",
    "hidden_inputs = np.dot(features, weights_input_to_hidden)\n",
    "print(hidden_inputs)\n",
    "print(hidden_inputs.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3]\n",
      " [6]\n",
      " [9]]\n",
      "(3, 1)\n"
     ]
    }
   ],
   "source": [
    "# Let's look at the transposed features\n",
    "print(features.transpose())\n",
    "print(features.transpose().shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.80314015  0.93638071  0.82375177]\n",
      " [ 0.51174729 -0.1819504  -0.07644257]]\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "# And the transposed random weights\n",
    "print(weights_input_to_hidden.transpose())\n",
    "print(weights_input_to_hidden.transpose().shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10.62262974]\n",
      " [-0.24444369]]\n",
      "(2, 1)\n"
     ]
    }
   ],
   "source": [
    "# So we could also just multiply as follows (note how we have to swap \n",
    "# the weights and the features to line up the shapes:\n",
    "transposed_hidden_inputs = np.dot(weights_input_to_hidden.transpose(), features.transpose())\n",
    "print(transposed_hidden_inputs)\n",
    "print(transposed_hidden_inputs.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Clearly, the important thing when setting this up in practice is to know what is represented by the rows versus the columns, what shape the outputs are and what those represent, and so on!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now let's move on... structures in PyTorch\n",
    "Scalars, vectors, matrices and tensors are all used, but instead of the NumPy array, they are held in the PyTorch tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.2077, -1.1962, -2.3296,  0.1182, -0.6795]])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Here we are creating a 1 x 5 tensor filled with random values\n",
    "my_tensor_1 = torch.randn((1, 5))\n",
    "my_tensor_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[ 0.8850, -0.8992, -1.4532],\n",
       "          [-0.3825,  0.0726, -0.6434]],\n",
       "\n",
       "         [[ 0.2978,  0.6723, -0.7668],\n",
       "          [-0.4401,  0.8991,  0.9226]],\n",
       "\n",
       "         [[-0.2236, -0.7165, -0.2679],\n",
       "          [-1.0320, -0.5938,  0.8750]]],\n",
       "\n",
       "\n",
       "        [[[ 0.9508, -1.9034, -0.5138],\n",
       "          [-1.1421, -1.5693,  1.1334]],\n",
       "\n",
       "         [[-0.0899,  1.3160,  0.5830],\n",
       "          [-0.7927, -1.0147, -1.6163]],\n",
       "\n",
       "         [[ 0.5218,  1.6359,  0.5626],\n",
       "          [-0.8350, -0.6344, -0.4213]]]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can create tensors of many dimensions!\n",
    "my_4D_tensor = torch.randn((2, 3, 2, 3))\n",
    "my_4D_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 1.3532,  0.8760,  0.3802,  0.8343, -0.3119]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can also create a second random tensor *with the same shape* as the first...\n",
    "my_tensor_2 = torch.randn_like(my_tensor_1)\n",
    "my_tensor_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-0.2077],\n",
      "        [-1.1962],\n",
      "        [-2.3296],\n",
      "        [ 0.1182],\n",
      "        [-0.6795]])\n",
      "tensor([[-0.2077],\n",
      "        [-1.1962],\n",
      "        [-2.3296],\n",
      "        [ 0.1182],\n",
      "        [-0.6795]])\n",
      "tensor([[-0.2077],\n",
      "        [-1.1962],\n",
      "        [-2.3296],\n",
      "        [ 0.1182],\n",
      "        [-0.6795]])\n"
     ]
    }
   ],
   "source": [
    "# With matrix multiplication and just working with matrices in general we may need to re-shape, \n",
    "# in fact there are many circumstances where you'll want to do this!\n",
    "\n",
    "# Method 1 - RESHAPE - basically returns a new tensor\n",
    "my_reshape_tensor_1 = my_tensor_1.reshape(5, 1)\n",
    "print(my_reshape_tensor_1)\n",
    "\n",
    "# Method 2 - RESIZE - returns same tensor with a different shape\n",
    "my_reshape_tensor_2 = my_reshape_tensor_1.resize_(5, 1)\n",
    "print(my_reshape_tensor_2)\n",
    "\n",
    "# Method 3 - VIEW - also returns a new tensor, quite frequently seen\n",
    "my_reshape_tensor_3 = my_reshape_tensor_1.view(5, 1)\n",
    "print(my_reshape_tensor_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.8118,  0.3068, -0.9181],\n",
      "        [ 0.7558, -0.8581, -1.0108],\n",
      "        [-0.4357, -0.8279, -0.5920],\n",
      "        [ 1.1929, -0.0802, -0.0894]])\n",
      "tensor([[ 0.8118,  0.3068, -0.9181,  0.7558],\n",
      "        [-0.8581, -1.0108, -0.4357, -0.8279],\n",
      "        [-0.5920,  1.1929, -0.0802, -0.0894]])\n",
      "tensor([[ 0.8118,  0.3068, -0.9181,  0.7558, -0.8581, -1.0108, -0.4357, -0.8279,\n",
      "         -0.5920,  1.1929, -0.0802, -0.0894]])\n"
     ]
    }
   ],
   "source": [
    "# Just as we did in NumPy we can use -1 as an indicator to re-shape to the required\n",
    "# remaining number in the shape for everything to 'balance' - check out these variations:\n",
    "my_tensor_3 = torch.randn((4, 3))\n",
    "print(my_tensor_3)\n",
    "print(my_tensor_3.view(3, -1))\n",
    "print(my_tensor_3.view(1, -1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.8118,  0.3068, -0.9181,  0.7558],\n",
       "        [-0.8581, -1.0108, -0.4357, -0.8279],\n",
       "        [-0.5920,  1.1929, -0.0802, -0.0894]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can also re-shape one tensor to be *like the shape of another tensor - just like so:\n",
    "my_tensor_4 = torch.randn(3, 4)\n",
    "my_tensor_3.view(*my_tensor_4.shape)\n",
    "# Obviously the shapes of the from and to tensors have to be compatible so all the values\n",
    "# still 'fit in' as they should"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.8118,  0.3068, -0.9181],\n",
      "        [ 0.7558, -0.8581, -1.0108],\n",
      "        [-0.4357, -0.8279, -0.5920],\n",
      "        [ 1.1929, -0.0802, -0.0894]])\n",
      "torch.return_types.topk(\n",
      "values=tensor([[ 0.8118,  0.3068],\n",
      "        [ 0.7558, -0.8581],\n",
      "        [-0.4357, -0.5920],\n",
      "        [ 1.1929, -0.0802]]),\n",
      "indices=tensor([[0, 1],\n",
      "        [0, 1],\n",
      "        [0, 2],\n",
      "        [0, 1]]))\n"
     ]
    }
   ],
   "source": [
    "# There's another function we'll use quite often in PyTorch which is .topk(). By default topk() is going \n",
    "# to find the top value per row, so the following says 'give me the top 2 values per row', and we\n",
    "# see we get values in the first tensor AND the indices of those values in the second tensor\n",
    "print(my_tensor_3)\n",
    "print(my_tensor_3.topk(2))\n",
    "# Notice that it's returned the top 2 values per ROW"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.8118,  0.3068, -0.9181],\n",
      "        [ 0.7558, -0.8581, -1.0108],\n",
      "        [-0.4357, -0.8279, -0.5920],\n",
      "        [ 1.1929, -0.0802, -0.0894]])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "torch.return_types.topk(\n",
       "values=tensor([[ 1.1929,  0.3068, -0.0894],\n",
       "        [ 0.8118, -0.0802, -0.5920]]),\n",
       "indices=tensor([[3, 0, 3],\n",
       "        [0, 3, 2]]))"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# But often in our data we'll want to get the .topk() by COLUMN, in which case we can flip it thus\n",
    "print(my_tensor_3)\n",
    "my_tensor_3.topk(2, dim=0)\n",
    "# So we see that dim=1 (the default) means 'get me the top values per row', \n",
    "# while dim=0 means 'get me the top values per column'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 5])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Always be aware when working with tensors what shape and type is going in, and what shape and type is going out\n",
    "# Use .shape() for debugging purposes, just like you would in NumPy\n",
    "my_tensor_1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.float32"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The other thing to be aware of is the data types of your tensors - sometimes these will need to be\n",
    "# changed (read the docs here: https://pytorch.org/docs/stable/tensor_attributes.html)\n",
    "# Let's have a look at the type of our 4D tensor created earlier:\n",
    "my_4D_tensor.dtype\n",
    "# The thing I found confusing at first was terminology: this one is float32, but is also just known as type float\n",
    "# and similarly float64 is also known as double - but this is all in the documentation so no need to remain confused!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.float64"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# If I want to cast my tensor to a new data type it's perfectly simple:\n",
    "my_4D_tensor = my_4D_tensor.type(torch.float64)\n",
    "my_4D_tensor.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-1.9041]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's do a quick dot product of 2 of our tensors to get a single 1 x 1 tensor as an answer\n",
    "new_1by1_tensor = my_tensor_1@my_tensor_2.view(5, 1)\n",
    "new_1by1_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.904099464416504"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sometimes you'll now just want to get that number out as a number instead of a tensor: .item() is the way\n",
    "new_1by1_tensor.item()\n",
    "# This value can now be passed to regular Python functions for further processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 784])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# And remember our network accepts a vector as input, but sometimes we'll have a matrix, e.g. with images, \n",
    "# imagine this tensor is a 28 x 28 pixel image:\n",
    "my_image_tensor = torch.randn((28, 28))\n",
    "\n",
    "# We can flatten this with a simple change of shape\n",
    "my_image_tensor = my_image_tensor.view(1, -1)\n",
    "my_image_tensor.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([64, 1, 28, 28])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You need to just keep your wits about you when re-shaping! For example, if we were to import *batches* of \n",
    "# 64 black and white images at a time we might end up with a tensor like this one, where the first dimension \n",
    "# represents each of the 64 images, and thereafter we have the pixels associated with that image. Now we'll \n",
    "# want to flatten the pixel data, but not the image data - after all we want to keep each image separate!\n",
    "sample_images = torch.randn((64, 1, 28, 28))\n",
    "sample_images.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([64, 784])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This means that when we want to flatten this tensor to pass it into our network we do this:\n",
    "sample_images = sample_images.view(sample_images.shape[0], -1)\n",
    "sample_images.shape\n",
    "# So we are preserving the first dimension: we still have 64 individual images\n",
    "# but we have flattened the 28 x 28 pixels into vectors of length 784"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pytorch operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-0.2077, -1.1962, -2.3296,  0.1182, -0.6795]])\n",
      "tensor([[ 1.3532,  0.8760,  0.3802,  0.8343, -0.3119]])\n"
     ]
    }
   ],
   "source": [
    "# A reminder of what we have\n",
    "print(my_tensor_1)\n",
    "print(my_tensor_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-0.2811, -1.0479, -0.8857,  0.0986,  0.2119]])\n"
     ]
    }
   ],
   "source": [
    "# Regular element-wise multiplication\n",
    "print(my_tensor_1 * my_tensor_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 1.1455, -0.3203, -1.9494,  0.9524, -0.9914]])\n"
     ]
    }
   ],
   "source": [
    "# Regular element-wise addition\n",
    "print(my_tensor_1 + my_tensor_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.8118,  0.3068, -0.9181],\n",
      "        [ 0.7558, -0.8581, -1.0108],\n",
      "        [-0.4357, -0.8279, -0.5920],\n",
      "        [ 1.1929, -0.0802, -0.0894]])\n",
      "tensor(-1.7450)\n"
     ]
    }
   ],
   "source": [
    "# Adding all the values in a tensor\n",
    "print(my_tensor_3)\n",
    "print(torch.sum(my_tensor_3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 2.3247, -1.4594, -2.6104])\n"
     ]
    }
   ],
   "source": [
    "# Notice how when we use dim=0 as a parameter what it does is it sums up all the column values\n",
    "# just like what we saw with .topk() earlier:\n",
    "print(torch.sum(my_tensor_3, dim=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 0.2005, -1.1131, -1.8556,  1.0232])\n"
     ]
    }
   ],
   "source": [
    "# Notice how when we use dim=1 as a parameter what it does is it sums up all the row values\n",
    "print(torch.sum(my_tensor_3, dim=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 9.7923,  8.8038,  7.6704, 10.1182,  9.3205]])\n"
     ]
    }
   ],
   "source": [
    "# Regular adding something to every item in the tensor\n",
    "print(my_tensor_1 + 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[7.3767]])\n"
     ]
    }
   ],
   "source": [
    "# Regular dot product - remember the inner dimensions need to be the same (i.e. both 5)\n",
    "# and the result will be a tensor of the shape of the outer dimensions, in this case 1 x 1 \n",
    "print(my_tensor_1@my_tensor_1.view(5, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[7.3767]])\n"
     ]
    }
   ],
   "source": [
    "# The following is equivalent to the dot product @ above\n",
    "print(torch.mm(my_tensor_1, my_tensor_1.view(5, 1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[7.3767]])\n"
     ]
    }
   ],
   "source": [
    "# And the following is also equivalent to the dot product @ above\n",
    "print(torch.matmul(my_tensor_1, my_tensor_1.view(5, 1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-0.2077, -1.1962, -2.3296,  0.1182, -0.6795]])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor([[0.8124, 0.3023, 0.0973, 1.1254, 0.5069]])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the exponent values of a tensor\n",
    "print(my_tensor_1)\n",
    "torch.exp(my_tensor_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.2077, -1.1962, -2.3296,  0.1182, -0.6795]])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the log values of a tensor - notice how we're back where we started, \n",
    "# Google this relationship if you need a reminder!\n",
    "torch.log(torch.exp(my_tensor_1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A practical example: coding [softmax](https://en.wikipedia.org/wiki/Softmax_function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "# All of the above are used in some fancy footwork when we were going to manually define softmax with a function\n",
    "def softmax(x):\n",
    "    return torch.exp(x) / torch.sum(torch.exp(x), dim = 1).view(-1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[-0.8777,  0.2851, -0.4389,  2.8232, -0.5627],\n",
      "        [ 0.8622, -1.2912, -0.2677,  0.7676,  0.4953],\n",
      "        [-1.0641, -1.8382, -0.3919, -1.5695,  0.1419],\n",
      "        [-0.0973, -1.5966,  0.4856,  0.8416,  1.1836],\n",
      "        [-1.1976,  0.4660, -0.0243, -0.7778, -0.0898],\n",
      "        [-1.2676, -0.6465, -0.5454, -0.1206, -0.6875],\n",
      "        [ 1.9780,  0.7043,  0.5908,  0.5227,  0.9768],\n",
      "        [-0.3293, -0.1564,  1.2097, -0.1866, -0.7827],\n",
      "        [-0.7087, -0.3273,  0.3907, -0.4444, -0.6915],\n",
      "        [ 0.5122,  2.0538,  0.1797, -1.3488,  0.0805]])\n"
     ]
    }
   ],
   "source": [
    "# For softmax we'd have several rows of records, where each column has a score\n",
    "# and we want probability of the record belonging to that class - here I'm just \n",
    "# going to use random numbers to illustrate the mechanics of the thing\n",
    "my_test_tensor = torch.randn(10, 5)\n",
    "print(my_test_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.0210, 0.0672, 0.0326, 0.8504, 0.0288],\n",
      "        [0.3288, 0.0382, 0.1062, 0.2991, 0.2278],\n",
      "        [0.1358, 0.0626, 0.2660, 0.0819, 0.4536],\n",
      "        [0.1090, 0.0243, 0.1953, 0.2788, 0.3925],\n",
      "        [0.0711, 0.3754, 0.2299, 0.1082, 0.2153],\n",
      "        [0.1015, 0.1888, 0.2089, 0.3195, 0.1813],\n",
      "        [0.4694, 0.1313, 0.1172, 0.1095, 0.1725],\n",
      "        [0.1158, 0.1376, 0.5395, 0.1335, 0.0736],\n",
      "        [0.1284, 0.1881, 0.3856, 0.1673, 0.1307],\n",
      "        [0.1390, 0.6494, 0.0997, 0.0216, 0.0903]])\n"
     ]
    }
   ],
   "source": [
    "# Check this out\n",
    "print(softmax(my_test_tensor))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
       "        1.0000])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Do these rows all add to 1 as expected? Yes! Now let's break that function down...\n",
    "torch.sum(softmax(my_test_tensor), dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.4157,  1.3299,  0.6447, 16.8300,  0.5697],\n",
      "        [ 2.3684,  0.2749,  0.7651,  2.1545,  1.6410],\n",
      "        [ 0.3450,  0.1591,  0.6758,  0.2081,  1.1525],\n",
      "        [ 0.9073,  0.2026,  1.6252,  2.3200,  3.2661],\n",
      "        [ 0.3019,  1.5936,  0.9760,  0.4594,  0.9141],\n",
      "        [ 0.2815,  0.5239,  0.5796,  0.8864,  0.5028],\n",
      "        [ 7.2282,  2.0224,  1.8055,  1.6866,  2.6558],\n",
      "        [ 0.7195,  0.8552,  3.3526,  0.8298,  0.4572],\n",
      "        [ 0.4923,  0.7209,  1.4780,  0.6412,  0.5008],\n",
      "        [ 1.6690,  7.7978,  1.1968,  0.2596,  1.0838]])\n",
      "torch.Size([10, 5])\n"
     ]
    }
   ],
   "source": [
    "# Step 1 - for our numerator and the inner part of our denominator we get 10 records x 5 classes back\n",
    "print(torch.exp(my_test_tensor))\n",
    "print(torch.exp(my_test_tensor).shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([19.7901,  7.2040,  2.5405,  8.3211,  4.2451,  2.7742, 15.3984,  6.2142,\n",
      "         3.8332, 12.0070])\n",
      "torch.Size([10])\n"
     ]
    }
   ],
   "source": [
    "# Step 2 - for our denominator we're then going to sum up all these values and get a single value\n",
    "print(torch.sum(torch.exp(my_test_tensor), dim = 1))\n",
    "print(torch.sum(torch.exp(my_test_tensor), dim = 1).shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "ename": "RuntimeError",
     "evalue": "The size of tensor a (5) must match the size of tensor b (10) at non-singleton dimension 1",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-105-fede49816ea6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Now: if we were just to do this it would throw an error because our shapes don't match up,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# our 10 x nothing tensor needs to be a 10 x 1 matrix\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_test_tensor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_test_tensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdim\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m: The size of tensor a (5) must match the size of tensor b (10) at non-singleton dimension 1"
     ]
    }
   ],
   "source": [
    "# Now: if we were just to do this it would throw an error because our shapes don't match up, \n",
    "# our 10 x nothing tensor needs to be a 10 x 1 matrix\n",
    "torch.exp(my_test_tensor) / torch.sum(torch.exp(my_test_tensor), dim = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[19.7901],\n",
       "        [ 7.2040],\n",
       "        [ 2.5405],\n",
       "        [ 8.3211],\n",
       "        [ 4.2451],\n",
       "        [ 2.7742],\n",
       "        [15.3984],\n",
       "        [ 6.2142],\n",
       "        [ 3.8332],\n",
       "        [12.0070]])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check how this fixes it\n",
    "torch.sum(torch.exp(my_test_tensor), dim = 1).view(-1,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.0210, 0.0672, 0.0326, 0.8504, 0.0288],\n",
       "        [0.3288, 0.0382, 0.1062, 0.2991, 0.2278],\n",
       "        [0.1358, 0.0626, 0.2660, 0.0819, 0.4536],\n",
       "        [0.1090, 0.0243, 0.1953, 0.2788, 0.3925],\n",
       "        [0.0711, 0.3754, 0.2299, 0.1082, 0.2153],\n",
       "        [0.1015, 0.1888, 0.2089, 0.3195, 0.1813],\n",
       "        [0.4694, 0.1313, 0.1172, 0.1095, 0.1725],\n",
       "        [0.1158, 0.1376, 0.5395, 0.1335, 0.0736],\n",
       "        [0.1284, 0.1881, 0.3856, 0.1673, 0.1307],\n",
       "        [0.1390, 0.6494, 0.0997, 0.0216, 0.0903]])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# And hence our final function\n",
    "torch.exp(my_test_tensor) / torch.sum(torch.exp(my_test_tensor), dim = 1).view(-1,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PyTorch to NumPy and back again\n",
    "You'll often need to transfer your data from one world to the other, and back again. For example, you may import data and do a whole lot of pre-processing in NumPy, and then want to get your data into PyTorch structures to actually run your model. Once you have your results, you may way to get them to NumPy or even Pandas for further analysis. Knowing how to translate is pretty fundamental!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.46911657, 0.74893065, 0.79124169],\n",
       "       [0.35685369, 0.32958451, 0.32630023],\n",
       "       [0.33777507, 0.25061065, 0.07958428],\n",
       "       [0.33802701, 0.65186334, 0.50257681]])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Let's create a numpy array\n",
    "a = np.random.rand(4,3)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.4691, 0.7489, 0.7912],\n",
       "        [0.3569, 0.3296, 0.3263],\n",
       "        [0.3378, 0.2506, 0.0796],\n",
       "        [0.3380, 0.6519, 0.5026]], dtype=torch.float64)"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Here's how you create a pytorch tensor from that\n",
    "b = torch.from_numpy(a)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.46911657, 0.74893065, 0.79124169],\n",
       "       [0.35685369, 0.32958451, 0.32630023],\n",
       "       [0.33777507, 0.25061065, 0.07958428],\n",
       "       [0.33802701, 0.65186334, 0.50257681]])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# And how you go from torch back to numpy, which you may want to do for visualization purposes, for example\n",
    "b.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.9382, 1.4979, 1.5825],\n",
      "        [0.7137, 0.6592, 0.6526],\n",
      "        [0.6756, 0.5012, 0.1592],\n",
      "        [0.6761, 1.3037, 1.0052]], dtype=torch.float64)\n",
      "[[0.93823315 1.49786129 1.58248339]\n",
      " [0.71370739 0.65916902 0.65260045]\n",
      " [0.67555014 0.5012213  0.15916857]\n",
      " [0.67605403 1.30372668 1.00515362]]\n"
     ]
    }
   ],
   "source": [
    "# ***The memory is shared between the Numpy array and Torch tensor***, so if you change the values in-place \n",
    "# of one object, the other will change as well - check this out:\n",
    "\n",
    "# Multiply PyTorch Tensor by 2, in place\n",
    "b.mul_(2)\n",
    "\n",
    "print(b)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## One more thing!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x1254dd7f0>"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# How to set the random seed so things are predictable\n",
    "torch.manual_seed(7)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}