som_tech_challenge.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Self Organising Map Challenge\n",
    "\n",
    "## The Kohonen Network\n",
    "\n",
    "The Kohonen Self Organizing Map (SOM) provides a data visualization technique which helps to understand high dimensional data by reducing the dimensions of data to a map. SOM also represents clustering concept by grouping similar data together.\n",
    "\n",
    "Unlike other learning technique in neural networks, training a SOM requires no target vector. A SOM learns to classify the training data without any external supervision.\n",
    "\n",
    "![Network](http://www.pitt.edu/~is2470pb/Spring05/FinalProjects/Group1a/tutorial/kohonen1.gif)\n",
    "\n",
    "### Structure\n",
    "A network has a width and a height that descibes the grid of nodes.  For example, the grid may be 4x4, and so there would be 16 nodes.\n",
    "\n",
    "Each node has a weight for each value in the input vector.  A weight is simply a float value that the node multiplies the input value by to determine how influential it is (see below)\n",
    "\n",
    "Each node has a set of weights that match the size of the input vector.  For example, if the input vector has 10 elements, each node would have 10 weights.\n",
    "\n",
    "### Training \n",
    "To train the network\n",
    "\n",
    "1. Each node's weights are initialized.\n",
    "2. We enumerate through the training data for some number of iterations (repeating if necessary).  The current value we are training against will be referred to as the `current input vector`\n",
    "3. Every node is examined to calculate which one's weights are most like the input vector. The winning node is commonly known as the Best Matching Unit (BMU).\n",
    "4. The radius of the neighbourhood of the BMU is now calculated. This is a value that starts large, typically set to the 'radius' of the lattice,  but diminishes each time-step. Any nodes found within this radius are deemed to be inside the BMU's neighbourhood.\n",
    "5. Each neighbouring node's (the nodes found in step 4) weights are adjusted to make them more like the input vector. The closer a node is to the BMU, the more its weights get altered.\n",
    "6. Go to step 2 until we've completed N iterations.\n",
    "    \n",
    "\n",
    "### Calculating the Best Matching Unit (BMU)\n",
    "\n",
    "To determine the best matching unit, one method is to iterate through all the nodes and calculate the Euclidean distance between each node's weight vector and the current input vector. The node with a weight vector closest to the input vector is tagged as the BMU.\n",
    "\n",
    "The Euclidean distance $\\mathsf{distance}_{i}$ (from the input vector $V$ to the $i$th node's weights $W_i$)is given as (using Pythagoras):\n",
    "\n",
    "$$ \\mathsf{distance}_{i}=\\sqrt{\\sum_{k=0}^{k=n}(V_k - W_{i_k})^2}$$\n",
    "\n",
    "where V is the current input vector and $W_i$ is the node's weight vector.  $n$ is the size of the input & weight vector.\n",
    "\n",
    "*Note*: $V$ and $W$ are vectors.  $V$ is the input vector, and $W_i$ is the weight vector of the $i$th node.  $V_k$ and $W_{i_k}$ represent the $k$'th value within those vectors.  \n",
    "\n",
    "The BMU is the node with the minimal distance for the current input vector\n",
    "\n",
    "### Calculating the Neighbourhood Radius\n",
    "\n",
    "The next step is to calculate which of the other nodes are within the BMU's neighbourhood. All these nodes will have their weight vectors altered.\n",
    "\n",
    "First we calculate what the radius of the neighbourhood should be and then use Pythagoras to determine if each node is within the radial distance or not.\n",
    "\n",
    "A unique feature of the Kohonen learning algorithm is that the area of the neighbourhood shrinks over time. To do this we use the exponential decay function:\n",
    "\n",
    "Given a desired number of training iterations $n$:\n",
    "$$n_{\\mathsf{max iterations}} = 100$$\n",
    "\n",
    "Calculate the radius $\\sigma_t$ at iteration number $t$:\n",
    "\n",
    "$$\\sigma_t = \\sigma_0 \\exp\\left(- \\frac{t}{\\lambda} \\right) \\qquad t = 1,2,3,4... $$\n",
    "\n",
    "Where $\\sigma_0$ denotes the neighbourhood radius at iteration $t=0$, $t$ is the current iteration. We define $\\sigma_0$ (the initial radius) and $\\lambda$ (the time constant) as below:\n",
    "\n",
    "$$\\sigma_0 = \\frac{\\max(width,height)}{2} \\qquad \\lambda = \\frac{n_{\\mathsf{max iterations}}}{\\log(\\sigma_0)} $$\n",
    "\n",
    "Where $width$ & $height$ are the width and height of the grid.\n",
    "\n",
    "### Calculating the Learning Rate\n",
    "\n",
    "We define the initial leanring rate $\\alpha_0$ at iteration $t = 0$ as:\n",
    "$$\\alpha_0 = 0.1$$\n",
    "\n",
    "So, we can calculate the learning rate at a given iteration t as:\n",
    "\n",
    "$$\\alpha_t = \\alpha_0 \\exp \\left(- \\frac{t}{\\lambda} \\right) $$\n",
    "\n",
    "where $t$ is the iteration number, $\\lambda$ is the time constant (calculated above)\n",
    "        \n",
    "### Calculating the Influence\n",
    "\n",
    "As well as the learning rate, we need to calculate the influence $\\theta_t$ of the learning/training at a given iteration $t$.  \n",
    "\n",
    "So for each node, we need to caclulate the euclidean distance $d_i$ from the BMU to that node.  Similar to when we calculate the distance to find the BMU, we use Pythagoras.  The current ($i$th) node's x position is given by $x(W_i)$, and the BMU's x position is, likewise, given by $x(Z)$.  Similarly, $y()$ returns the y position of a node.\n",
    "\n",
    "$$ d_{i}=\\sqrt{(x(W_i) - x(Z))^2 + (y(W_i) - y(Z))^2} $$\n",
    "\n",
    "Then, the influence decays over time according to:\n",
    "\n",
    "$$\\theta_t = \\exp \\left( - \\frac{d_{i}^2}{2\\sigma_t^2} \\right) $$\n",
    "\n",
    "Where $\\sigma_t$ is the neighbourhood radius at iteration $t$ as calculated above. \n",
    "\n",
    "Note: You will need to come up with an approach to x() and y().\n",
    "\n",
    "\n",
    "### Updating the Weights\n",
    "\n",
    "To update the weights of a given node, we use:\n",
    "\n",
    "$$W_{i_{t+1}} = W_{i_t} + \\alpha_t \\theta_t (V_t - W_{i_t})$$\n",
    "        \n",
    "So $W_{i_{t+1}}$ is the new value of the weight for the $i$th node, $V_t$ is the current value of the training data, $W_{i_t}$ is the current weight and $\\alpha_t$ and $\\theta_t$ are the learning rate and influence calculated above.\n",
    "\n",
    "*Note*: the $W$ and $V$ are vectors "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Challenge\n",
    "\n",
    "In this challenge, you need to implement a SOM such that it can categorise a set of random 3-dimensional colours.  The output should be an image of the organised data.  \n",
    "\n",
    "### Expectations and Criteria\n",
    "- Be prepared to talk through your decisions & thinking (we encourage you to include these in code comments too!)\n",
    "- You may use any language you like (the examples given below are using Python)\n",
    "- Avoid libraries that would do too much of the work for you. For example, in Python a good approach would be to use `numpy`, but no packages with SOM specific functionality\n",
    "- Try and make your code as efficient as possible. Feel free to deviate from a literal interpretation of the instructions given under the **Training** heading above\n",
    "- Consider the best way to structure your code and code base for later use by other developers or in anticipation of productionisation (you don't need to use a Jupyter Notebook)\n",
    "- Include any tests you may have used (tests are not required however)\n",
    "- Include a `Dockerfile` to package your code for production\n",
    "- Be prepared to discuss your approach and process to productionise this application\n",
    "- You can use code below to generate the trainig data of 10 colours:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.37454012 0.95071431 0.73199394]\n",
      " [0.59865848 0.15601864 0.15599452]\n",
      " [0.05808361 0.86617615 0.60111501]\n",
      " [0.70807258 0.02058449 0.96990985]\n",
      " [0.83244264 0.21233911 0.18182497]\n",
      " [0.18340451 0.30424224 0.52475643]\n",
      " [0.43194502 0.29122914 0.61185289]\n",
      " [0.13949386 0.29214465 0.36636184]\n",
      " [0.45606998 0.78517596 0.19967378]\n",
      " [0.51423444 0.59241457 0.04645041]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x27b5bb83808>"
      ]
     },
     "execution_count": 1,
     "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": [
    "# Generate Data\n",
    "import numpy as np\n",
    "np.random.seed(seed=42)\n",
    "input_data = np.random.random((10,3))\n",
    "print(input_data)\n",
    "img = np.reshape(input_data, (1,input_data.shape[0],3))\n",
    "\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "plt.imshow(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Implement a Kohonen network\n",
    "- Use the above description to implement a Kohonen network\n",
    "- Make sure you can configure the size of the input vector and the size of the map\n",
    "- Make sure node's weights are initialized to random values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numba import jit\n",
    "\n",
    "class SOM():\n",
    "    \"\"\"\n",
    "    My SOM Implementation. The focus of this implementation is in vectorisation and \\\n",
    "    setting up the classes to be compatible with Numba through the static method.\n",
    "    \n",
    "    Usage example:\n",
    "        np.random.seed(seed=42)\n",
    "        input_data = np.random.random((20,3))\n",
    "        size = 10\n",
    "        som = SOM(size,size)\n",
    "        som.train(input_data, number_iterations=10, initial_learningrate=0.1)\n",
    "    \"\"\"\n",
    "    def __init__(self, width, height):\n",
    "        super(SOM, self).__init__()\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "        \n",
    "    @staticmethod\n",
    "    @jit(nopython=True)\n",
    "    def calculate_euclidean_distance(matrix, vector):\n",
    "        \"\"\"\n",
    "        L2 Norm Calculation by subtracting a single row from a column matrix. \n",
    "        \"\"\"\n",
    "        dist_array = np.sum((matrix - vector)**2, axis=1)\n",
    "        return dist_array\n",
    "        \n",
    "    @staticmethod\n",
    "    @jit(nopython=True)\n",
    "    def calculate_BMU(current_input_vector, weights):\n",
    "        \"\"\"\n",
    "        Best Matching Unit (BMU) calculation.\n",
    "        - Reshapes into column array\n",
    "        - Calculates L2 Norm\n",
    "        - Finds argmin id and 2D coordinates of the BMU\n",
    "        \"\"\"\n",
    "        weights_reshaped = weights.reshape(-1,3)\n",
    "        dist_array = np.sum((weights_reshaped - current_input_vector)**2, axis=1)\n",
    "        min_id = np.argmin(dist_array)\n",
    "        \n",
    "        BMU_x_coords = min_id // weights.shape[0]\n",
    "        BMU_y_coords = min_id % weights.shape[1]\n",
    "        BMU_coord = np.array([BMU_x_coords,BMU_y_coords])\n",
    "        return min_id, BMU_coord   \n",
    "    \n",
    "    @staticmethod\n",
    "    @jit(nopython=True)\n",
    "    def calculate_decay(current_iteration, time_constant):\n",
    "        \"\"\"\n",
    "        Decay calculation to run once at every time step.\n",
    "        \"\"\"\n",
    "        decay = np.exp(-current_iteration / time_constant)\n",
    "        return decay\n",
    "    \n",
    "    @staticmethod\n",
    "    @jit(nopython=True)\n",
    "    def calculate_radius(initial_radius,decay):\n",
    "        \"\"\"\n",
    "        Radius calculation to run once at every time step.\n",
    "        \"\"\"\n",
    "        current_radius = initial_radius * decay\n",
    "        return current_radius\n",
    "\n",
    "    @staticmethod\n",
    "    @jit(nopython=True)\n",
    "    def calculate_neighbourhood(current_radius, BMU_coord, dimensions):\n",
    "        \"\"\"\n",
    "        Neighbour calculation:\n",
    "        - Create 3D array where the first page is the x coordinate associated with \\\n",
    "        each element and the second page is the y coordinate. This allows us to get \\\n",
    "        the x and y coordinate of any particular grid element (i.e. (3,10))\n",
    "        - Subtract BMU from this git to get manhattan distance of every element to BMU coords\n",
    "        - Calculate L2 norm of entire grid from BMU coords\n",
    "        - Check inside radius\n",
    "        - Returns coordinates and IDs of nodes inside the current_radius\n",
    "        \"\"\"\n",
    "        # Normally we would just use np.indicies but numba doesn't like it! so we are reworking from source code\n",
    "        # Create coordinates grid\n",
    "        N = 2 # 2D Iamge\n",
    "        output_shape = np.array((N,dimensions[0],dimensions[1])) ###\n",
    "        my_tuple = (output_shape[0],output_shape[1],output_shape[2])\n",
    "        coords_list = np.ones(my_tuple,dtype=np.int32)\n",
    "        for i, dim in enumerate(dimensions):\n",
    "            if i == 0:\n",
    "                reshape_shape = (dim,1)\n",
    "            else:\n",
    "                reshape_shape = (1,dim)\n",
    "            idx_temp = np.arange(dim)\n",
    "            idx = idx_temp.reshape(reshape_shape)\n",
    "            coords_list[i] = idx\n",
    "        coords_list = coords_list.reshape(2,-1).T\n",
    "        \n",
    "        # Subtract the BMU_coord coords to get manhattans\n",
    "        dist = coords_list - np.array((BMU_coord[0],BMU_coord[1]))\n",
    "        abs_dist = np.abs(dist) # Absolute value of manhattan\n",
    "        dist_sum = np.sqrt(np.square(abs_dist).sum(1)) # L2 Norm\n",
    "        # dist_sum = (abs_dist).sum(1) # L1 Norm\n",
    "        id_mask = dist_sum <= int(current_radius) # Get true/false mask\n",
    "        ids = np.where(id_mask)[0] \n",
    "        return coords_list, id_mask, ids # Returns coordinates of nodes inside the current_radius\n",
    "\n",
    "    @staticmethod\n",
    "    @jit(nopython=True)\n",
    "    def calculate_learningrate(initial_learningrate, decay):\n",
    "        \"\"\"\n",
    "        Learning rate calculation to run once at every time step.\n",
    "        \"\"\"\n",
    "        current_learningrate = initial_learningrate * decay\n",
    "        return current_learningrate\n",
    "\n",
    "    @staticmethod\n",
    "    @jit(nopython=True)\n",
    "    def calculate_influence(coords_list, id_mask, ids, BMU_coord, current_radius):\n",
    "        \"\"\"\n",
    "        Vectorised influence array calculation:\n",
    "        - Calculate influence using the coords list of nodes inside the radius (i.e. (22,3))\n",
    "        - Pad the influence array to the full size and fill with zeros (i.e. (100,3)) to assist in update calc\n",
    "        \"\"\"\n",
    "        dist_array = np.sum((coords_list[id_mask] - BMU_coord)**2, axis=1)\n",
    "        influence_array = np.exp(- dist_array / (2 * current_radius**2))\n",
    "        padded_influence_array = np.zeros((coords_list.shape[0],1))\n",
    "        influence_array = np.reshape(influence_array, (-1, 1))\n",
    "        padded_influence_array[ids] = influence_array\n",
    "        return padded_influence_array\n",
    "\n",
    "    @staticmethod\n",
    "    @jit(nopython=True)\n",
    "    def calculate_update(weights, current_learningrate, padded_influence_array, current_input_vector):\n",
    "        \"\"\"\n",
    "        Vectorised update calculation:\n",
    "        - Use the padded influence array (i.e. 100,3) to calculate updates for all weights in a \\\n",
    "        single vectorised equation\n",
    "        \"\"\"\n",
    "        weights_reshaped = weights.reshape(-1,3)\n",
    "        updated_weights = weights_reshaped + current_learningrate * padded_influence_array * (current_input_vector - weights_reshaped)\n",
    "        updated_weights = updated_weights.reshape(weights.shape)\n",
    "        return updated_weights\n",
    "\n",
    "    @staticmethod\n",
    "    @jit(nopython=True)\n",
    "    def get_current_input_vector(input_data):\n",
    "        \"\"\"\n",
    "        Randomly select a single row from input data\n",
    "        \"\"\"\n",
    "        number_of_rows = input_data.shape[0]\n",
    "        random_indices = np.random.choice(number_of_rows, size=1)\n",
    "        current_input_vector = input_data[random_indices, :]\n",
    "        return current_input_vector\n",
    "\n",
    "    @staticmethod\n",
    "    @jit(nopython=True)\n",
    "    def get_image(weights, size, number_attributes):\n",
    "        \"\"\"\n",
    "        Get image for displaying the weights image\n",
    "        \"\"\"\n",
    "        current_weights_image = np.reshape(weights, (size,size,number_attributes))\n",
    "        return current_weights_image\n",
    "    \n",
    "    def train(self, input_data, number_iterations, initial_learningrate):\n",
    "        \"\"\"\n",
    "        Training Loop:\n",
    "        Initialise Data and Weights\n",
    "        ## for 0 to n_iters\n",
    "            ## Randomly choose current input data\n",
    "            ## Calculate BMU\n",
    "            ## Calculate Radius\n",
    "            ## Calculate Neighbourhood\n",
    "            ## Calculate Learning Rate\n",
    "            ## Calculate Influence\n",
    "            ## Calculate Update Weights\n",
    "        ## Generate Image\n",
    "        \"\"\"\n",
    "\n",
    "\n",
    "        self.input_data = input_data\n",
    "        self.number_attributes = input_data.shape[1]\n",
    "        self.weights = np.random.random((self.width, self.height, self.number_attributes))\n",
    "        self.number_iterations = number_iterations\n",
    "        self.initial_radius = np.max((self.width,self.height))/2\n",
    "        self.initial_learningrate = initial_learningrate\n",
    "        self.time_constant = self.number_iterations/np.log(self.initial_radius)\n",
    "#         self.current_weights_image = np.random.random((self.width, self.height, self.number_attributes))\n",
    "        \n",
    "        for current_iteration in range(self.number_iterations):\n",
    "            current_input_vector = SOM.get_current_input_vector(self.input_data)\n",
    "            min_id, BMU_coord = SOM.calculate_BMU(current_input_vector, self.weights)\n",
    "            decay = SOM.calculate_decay(current_iteration, self.time_constant)\n",
    "            current_radius = SOM.calculate_radius(self.initial_radius, decay)\n",
    "            dimensions = np.array([self.width, self.height])\n",
    "            coords_list, id_mask, ids = SOM.calculate_neighbourhood(current_radius, BMU_coord, dimensions)\n",
    "            current_learningrate = SOM.calculate_learningrate(self.initial_learningrate, decay)\n",
    "            padded_influence_array = SOM.calculate_influence(coords_list, id_mask, ids, BMU_coord, current_radius)\n",
    "            updated_weights = SOM.calculate_update(self.weights, current_learningrate, padded_influence_array, current_input_vector)\n",
    "            self.weights = updated_weights\n",
    "#             current_weights_image = SOM.get_image(self.weights, self.width, self.number_attributes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Train a 10x10 network over 100 iterations\n",
    "\n",
    "- Training data is a random set of 20 colours\n",
    "- How long does this take?\n",
    "- What does the map look like? (You will need to translate the weights of each node in the map to pixel data)\n",
    "- What does this look like if you perform 200 & 500 iterations?\n",
    "\n",
    "You should end up with something that looks like below after 500 iterations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run once for Numba caching\n",
    "np.random.seed(seed=42)\n",
    "input_data = np.random.random((20,3))\n",
    "size = 10\n",
    "som = SOM(size,size)\n",
    "som.train(input_data, number_iterations=10, initial_learningrate=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.74 ms ± 61.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x27b5e8a9988>"
      ]
     },
     "execution_count": 4,
     "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": [
    "# Map size 10 and 100 iterations\n",
    "np.random.seed(seed=42)\n",
    "input_data = np.random.random((20,3))\n",
    "size = 10\n",
    "som100 = SOM(size,size)\n",
    "%timeit -n 100 som100.train(input_data, number_iterations=100, initial_learningrate=0.1)\n",
    "\n",
    "# Plot\n",
    "weights_100_img = som100.get_image(som100.weights, size, 3)\n",
    "plt.imshow(weights_100_img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.42 ms ± 74.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x27b5e3cfb88>"
      ]
     },
     "execution_count": 5,
     "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": [
    "# Map size 10 and 200 iterations\n",
    "np.random.seed(seed=42)\n",
    "input_data = np.random.random((20,3))\n",
    "size = 10\n",
    "som100 = SOM(size,size)\n",
    "%timeit -n 100 som100.train(input_data, number_iterations=200, initial_learningrate=0.1)\n",
    "\n",
    "# Plot\n",
    "weights_100_img = som100.get_image(som100.weights, size, 3)\n",
    "plt.imshow(weights_100_img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.73 ms ± 298 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x27b5e6b5648>"
      ]
     },
     "execution_count": 6,
     "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": [
    "# Map size 10 and 500 iterations\n",
    "np.random.seed(seed=42)\n",
    "input_data = np.random.random((20,3))\n",
    "size = 10\n",
    "som100 = SOM(size,size)\n",
    "%timeit -n 100 som100.train(input_data, number_iterations=500, initial_learningrate=0.1)\n",
    "\n",
    "# Plot\n",
    "weights_100_img = som100.get_image(som100.weights, size, 3)\n",
    "plt.imshow(weights_100_img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Train a 100x100 network over 1000 iterations\n",
    "\n",
    "- This network will likely be significantly slower to train\n",
    "- What could you do to improve performance?\n",
    "- What does the network look like after 1000 iterations?\n",
    "\n",
    "You should end up with something like below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "332 ms ± 9.4 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x27b5e3e7dc8>"
      ]
     },
     "execution_count": 7,
     "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": [
    "np.random.seed(seed=42)\n",
    "input_data = np.random.random((100,3))\n",
    "size = 100\n",
    "som1000 = SOM(size,size)\n",
    "%timeit -n 100 som1000.train(input_data, number_iterations=1000, initial_learningrate=0.1)\n",
    "\n",
    "# Plot\n",
    "weights_1000_img = som1000.get_image(som1000.weights, size, 3)\n",
    "plt.imshow(weights_1000_img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "         9017 function calls in 0.375 seconds\n",
      "\n",
      "   Ordered by: standard name\n",
      "\n",
      "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)\n",
      "     1000    0.000    0.000    0.000    0.000 :0(array)\n",
      "        1    0.000    0.000    0.375    0.375 :0(exec)\n",
      "        1    0.000    0.000    0.000    0.000 :0(getattr)\n",
      "        1    0.000    0.000    0.000    0.000 :0(implement_array_function)\n",
      "        1    0.000    0.000    0.000    0.000 :0(items)\n",
      "        2    0.000    0.000    0.000    0.000 :0(random)\n",
      "        1    0.000    0.000    0.000    0.000 :0(reduce)\n",
      "        1    0.000    0.000    0.000    0.000 :0(setprofile)\n",
      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:2(amax)\n",
      "     1000    0.000    0.000    0.000    0.000 <ipython-input-2-7209291588f4>:104(calculate_learningrate)\n",
      "     1000    0.016    0.000    0.016    0.000 <ipython-input-2-7209291588f4>:113(calculate_influence)\n",
      "     1000    0.047    0.000    0.047    0.000 <ipython-input-2-7209291588f4>:128(calculate_update)\n",
      "     1000    0.000    0.000    0.000    0.000 <ipython-input-2-7209291588f4>:141(get_current_input_vector)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-2-7209291588f4>:16(__init__)\n",
      "        1    0.047    0.047    0.375    0.375 <ipython-input-2-7209291588f4>:161(train)\n",
      "     1000    0.156    0.000    0.156    0.000 <ipython-input-2-7209291588f4>:30(calculate_BMU)\n",
      "     1000    0.000    0.000    0.000    0.000 <ipython-input-2-7209291588f4>:48(calculate_decay)\n",
      "     1000    0.000    0.000    0.000    0.000 <ipython-input-2-7209291588f4>:57(calculate_radius)\n",
      "     1000    0.109    0.000    0.109    0.000 <ipython-input-2-7209291588f4>:66(calculate_neighbourhood)\n",
      "        1    0.000    0.000    0.375    0.375 <string>:1(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 fromnumeric.py:2584(_amax_dispatcher)\n",
      "        1    0.000    0.000    0.000    0.000 fromnumeric.py:2589(amax)\n",
      "        1    0.000    0.000    0.000    0.000 fromnumeric.py:70(_wrapreduction)\n",
      "        1    0.000    0.000    0.000    0.000 fromnumeric.py:71(<dictcomp>)\n",
      "        1    0.000    0.000    0.375    0.375 profile:0(input_data=np.random.random((100,3)); size=100; som = SOM(size,size);              som.train(input_data, number_iterations=1000, initial_learningrate=0.1);print)\n",
      "        0    0.000             0.000          profile:0(profiler)\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import profile\n",
    "profile.run('input_data=np.random.random((100,3)); size=100; som = SOM(size,size); \\\n",
    "             som.train(input_data, number_iterations=1000, initial_learningrate=0.1);print')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Application"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "img = cv2.imread('./test_images/ed.jpeg')\n",
    "print('Image Dimensions :', img.shape)\n",
    "rgb_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "plt.imshow(rgb_img)\n",
    "plt.show()\n",
    "\n",
    "# Generate Data\n",
    "np.random.seed(seed=2010)\n",
    "def get_current_input_vector(input_data,count):\n",
    "    number_of_rows = input_data.shape[0]\n",
    "    random_indices = np.random.choice(number_of_rows, size=count)\n",
    "    current_input_vector = input_data[random_indices, :]\n",
    "    return current_input_vector\n",
    "\n",
    "image_vector = rgb_img.reshape(-1,3)/255\n",
    "current_input_vector = get_current_input_vector(image_vector, count = 5)\n",
    "\n",
    "img = np.reshape(current_input_vector, (1,current_input_vector.shape[0],3))\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "plt.imshow(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(seed=42)\n",
    "img = cv2.imread('./test_images/ed.jpeg')\n",
    "rgb_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "image_vector = rgb_img.reshape(-1,3)/255\n",
    "\n",
    "size = 100\n",
    "som3 = SOM(size,size)\n",
    "som3.train(image_vector, number_iterations=2000, initial_learningrate=0.1)\n",
    "output = np.reshape(som3.weights, (size,size,3))\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "plt.imshow(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob\n",
    "import cv2 as cv2\n",
    "keyword = \"downloads\"\n",
    "path = glob.glob(f\"./google-image-download/{keyword}/*\")\n",
    "cv_img = None\n",
    "count = 0\n",
    "for img in path:\n",
    "    if count == 0:\n",
    "        new = cv2.imread(img)\n",
    "        new_rgb = cv2.cvtColor(new, cv2.COLOR_BGR2RGB)\n",
    "        new_rgb = cv2.resize(new_rgb, (300,300), interpolation = cv2.INTER_AREA)\n",
    "        cv_img = new_rgb\n",
    "    elif count > 4:\n",
    "        break\n",
    "    else:\n",
    "        new = cv2.imread(img)\n",
    "        new_rgb = cv2.cvtColor(new, cv2.COLOR_BGR2RGB)\n",
    "        new_rgb = cv2.resize(new_rgb, (300,300), interpolation = cv2.INTER_AREA)\n",
    "        cv_img = np.concatenate((cv_img, new_rgb), axis = 1)\n",
    "    count += 1\n",
    "\n",
    "plt_img = cv_img/255\n",
    "plt.imshow(plt_img)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(seed=42)\n",
    "image_vector = cv_img.reshape(-1,3)/255\n",
    "\n",
    "size = 100\n",
    "som3 = SOM(size,size)\n",
    "som3.train(image_vector, number_iterations=2000, initial_learningrate=0.1)\n",
    "output = np.reshape(som3.weights, (size,size,3))\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "plt.imshow(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}