Neural Network Matrices.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json # only use json to easily open json file"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eigen geschreven functie om dot product (matrix multiplicatie) te berekenen voor matrices. De functie werkt met standaard matrices van lijsten, en niet met numpy arrays of matrices. Ik vond het volgende plaatje wat het proces aardig goed visualiseert:\n",
    "\n",
    "![image.png](attachment:image.png)\n",
    "Bron: https://www.mathsisfun.com/algebra/matrix-multiplying.html\n",
    "\n",
    "Hoe werkt dot product? Dot product kan 2 matrices met elkaar vermenigvuldigen van verschillende groottes. Er zit echter wel 1 belangrijke voorwaarde aan het bereken van de dot product matrix product. Het aantal kolommen van matrix 1 moet gelijk zijn aan het aantal rijen van matrix 2. Als dit het geval is kan dot product uitgevoerd worden. Ik vond het volgende plaatje wat ik het meest duidelijk vind weergeven hoe dot product berekend wordt. Er wordt een nieuwe matrix gemaakt met dimenties: \n",
    "- aantal rijen = aantal rijen matrix 1\n",
    "- aantal kolommen = aantal kolommen matrix 2\n",
    "\n",
    "Elke index waarde die voor de nieuwe matrix berekend moet worden kan op de volgende manier beschreven worden:\n",
    "n is afhankelijk van de grootte van de matrices. A is matrix 1 en B is matrix 2.\n",
    "$A1B1 + A2B2 + ... + AnBn$\n",
    "\n",
    "bovenstaande berekening wordt voor elke rij in matrix 1 uitgevoerd."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to perform matrix multiplication:\n",
    "def dot_product(matrix1, matrix2):\n",
    "    matrix1_rows = len(matrix1)\n",
    "    matrix1_cols = len(matrix1[0])\n",
    "    matrix2_rows = len(matrix2)\n",
    "    matrix2_cols = len(matrix2[0])\n",
    "    \n",
    "    # if columns of first are not equal to rows of second, matrix multiplication is not possible\n",
    "    if matrix1_cols != matrix2_rows: \n",
    "        raise Exception(\"Matrix multiplication is not possible because \"+ str(matrix1_cols) +' != '+str(matrix2_rows))\n",
    "    \n",
    "    # create new empty productmatrix with size; rows of first and columns of second\n",
    "    productmatrix = [[0 for row in range(matrix2_cols)] for col in range(matrix1_rows)]\n",
    "    \n",
    "    for i in range(matrix1_rows):\n",
    "        for j in range(matrix2_cols):\n",
    "            for h in range(matrix1_cols):\n",
    "                productmatrix[i][j] += matrix1[i][h] * matrix2[h][j]\n",
    "            \n",
    "    return productmatrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Om de gewichten uit de bestanden te lezen, is onderstaande functie geschreven. De functie is herbruikbaar voor oneindig aantal lagen. De functie leest de gewichten per laag uit het bestand en maakt van iedere laag een matrix met bijbehorende gewichten."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "def weights_to_matrices(data):\n",
    "    matrices = [] # empty list for all matrices\n",
    "    \n",
    "    for layer in data: # iterate over layers in json file\n",
    "\n",
    "        matrix = [[0 for row in range(int(data[layer][\"size_in\"]))] for col in range(int(data[layer][\"size_out\"]))] \n",
    "        #empty matrix\n",
    "        \n",
    "        for index, node in enumerate(data[layer][\"weights\"]): # iterate over nodes in layer\n",
    "            for weight in data[layer][\"weights\"][node]: # iterate over weights in node\n",
    "                \n",
    "                matrix[int(weight) - 1][int(node) - 1] = float(data[layer][\"weights\"][node][weight])\n",
    "                # add weight to correct place in matrix\n",
    "            \n",
    "        matrices.append(matrix) # add matrix to all matrices\n",
    "    \n",
    "    return matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Om het resultaat van het neurale netwerk te berekenen moet in een bepaalde volgorde de matrix multiplicatie uitgevoerd worden. De volgorde is $Laag2 \\cdot Laag1 \\cdot Laag0 \\cdot \\vec{input}$ Door deze volgorde aan te houden (en dus van de laatste naar de eerste matrix toe te werken) kunnen eerst alle matrices met elkaar vermenigvuldigd worden, om als laatst het resultaat met de input vector te vermenigvuldigen. Als de lagen van het begin naar het einde worden afgewerkt, moeten er telkens een $\\vec{tussenresultaat}$ met de volgende matrix vermenigvuldigd worden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ordered_matrix_multiplication(matrices, inputvector):\n",
    "    \n",
    "    if len(matrices) == 1: # if only 1 matrix in matrices:\n",
    "        productvector = dot_product(matrices[0], inputvector) # multiply this matrix with input network\n",
    "\n",
    "    else: # else iterate over reversed list matrices, while we know there must be more than 1 in matrices\n",
    "\n",
    "        matrices.reverse() # reverse matrices to do L2 * L1 * L0... instead of L0 * L1 * L2\n",
    "\n",
    "        for layer, matrix1 in enumerate(matrices):  # use layer as counting index\n",
    "\n",
    "            if layer == 0: # if index = 0 multiply first two matrices with each other (we know it must be 2)\n",
    "                productmatrix = dot_product(matrix1, matrices[layer + 1])\n",
    "\n",
    "            elif layer + 1 == len(matrices): # else if all matrices are multiplied, multiply last product with input\n",
    "                productvector = dot_product(productmatrix, inputvector) # perform dotproduct with productmatrix\n",
    "\n",
    "            else: # else multiply all matrices with each other starting with productmatrix\n",
    "                productmatrix = dot_product(productmatrix, matrices[layer + 1])\n",
    "\n",
    "    return [round(i[0], 2) for i in productvector] # rounded values in productmatrix on 2 decimals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Als laatst worden de bestanden met lagen geopend en de functies gebruikt om:\n",
    "- lagen in matrices te laden met de functie: weights_to_matrices\n",
    "- matrices in de juiste volgorde te vermenigvuldigen met de functie: ordered_matrix_multiplication\n",
    "\n",
    "Deze functie zorgt ervoor dat aan alle situaties gedacht is, en dat de inputvector altijd met het laatste resultaat van matrix multiplicatie vermenigvuldigd wordt. Als laatst wordt dit resultaat geprint!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Output values 1 layer:\n",
      " [0.5, -0.3, 0.2, 0.5]\n",
      "\n",
      "Output values 2 layers:\n",
      " [0.62, 0.36]\n",
      "\n",
      "Output values 3 layers:\n",
      " [0.38]\n"
     ]
    }
   ],
   "source": [
    "# 1 layer\n",
    "json_file = open(\"example-1layer.json\", \"r\") # open json file in reading mode\n",
    "data = json.load(json_file) # load json file in datastructure with json\n",
    "# input vector\n",
    "inputvector = [[1] for col in range(int(data[\"layer1\"][\"size_in\"]))] # input for the neural network\n",
    "matrices = weights_to_matrices(data) # load weights from file into matrices, for each layer 1 matrix\n",
    "# will multiply matrices in reversed order. Last productmatrix will be multiplied with input vector\n",
    "lastproduct = ordered_matrix_multiplication(matrices, inputvector) # this function ensures correct order of matrix multiplication\n",
    "print(\"\\nOutput values 1 layer:\\n\", lastproduct) # print output\n",
    "\n",
    "# 2 layers\n",
    "json_file = open(\"example-2layer.json\", \"r\") # open json file in reading mode\n",
    "data = json.load(json_file) # load json file in datastructure with json\n",
    "# input vector\n",
    "inputvector = [[1] for col in range(int(data[\"layer1\"][\"size_in\"]))] # input for the neural network\n",
    "matrices = weights_to_matrices(data) # load weights from file into matrices, for each layer 1 matrix\n",
    "# will multiply matrices in reversed order. Last productmatrix will be multiplied with input vector\n",
    "lastproduct = ordered_matrix_multiplication(matrices, inputvector) # this function ensures correct order of matrix multiplication\n",
    "print(\"\\nOutput values 2 layers:\\n\", lastproduct) # print output\n",
    "\n",
    "# 3 layers\n",
    "json_file = open(\"example-3layer.json\", \"r\") # open json file in reading mode\n",
    "data = json.load(json_file) # load json file in datastructure with json\n",
    "# input vector\n",
    "inputvector = [[1] for col in range(int(data[\"layer1\"][\"size_in\"]))] # input for the neural network\n",
    "matrices = weights_to_matrices(data) # load weights from file into matrices, for each layer 1 matrix\n",
    "# will multiply matrices in reversed order. Last productmatrix will be multiplied with input vector\n",
    "lastproduct = ordered_matrix_multiplication(matrices, inputvector) # this function ensures correct order of matrix multiplication\n",
    "print(\"\\nOutput values 3 layers:\\n\", lastproduct) # print output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ik heb hier nog toegevoegd hoe een outputvector steeds gebruikt kan worden om met de volgende laag de ouput te berekenen. Ik vind het wel dubbel, en enigzins onzin, aangezien eerst juist verteld werd dat dit niet gebruikt mocht worden (ik had eerst mijn opdracht met vector output multiplicatie uitgewerkt). Maar alsnog opnieuw uitgewerkt bij deze:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ordered_vectoroutput_multiplication(matrices, inputvector):\n",
    "    \n",
    "    if len(matrices) == 1: # if only 1 matrix in matrices:\n",
    "        productvector = dot_product(matrices[0], inputvector) # multiply this matrix with input network\n",
    "\n",
    "    else: # else iterate over reversed list matrices, while we know there must be more than 1 in matrices\n",
    "\n",
    "        for layer, matrix1 in enumerate(matrices):  # use layer as counting index\n",
    "\n",
    "            if layer == 0: # if index = 0 multiply first two matrices with each other (we know it must be 2)\n",
    "                productvector = dot_product(matrix1, inputvector)\n",
    "\n",
    "            elif layer + 1 == len(matrices): # else if all matrices are multiplied, multiply last product with input\n",
    "                productvector = dot_product(matrices[layer], productvector) # perform dotproduct with productmatrix\n",
    "\n",
    "            else: # else multiply all matrices with each other starting with productmatrix\n",
    "                productvector = dot_product(matrices[layer], productvector)\n",
    "\n",
    "    return [round(i[0], 2) for i in productvector] # rounded values in productmatrix on 2 decimals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Output values 1 layer:\n",
      " [0.5, -0.3, 0.2, 0.5]\n",
      "\n",
      "Output values 2 layers:\n",
      " [0.62, 0.36]\n",
      "\n",
      "Output values 3 layers:\n",
      " [0.38]\n"
     ]
    }
   ],
   "source": [
    "# 1 layer\n",
    "json_file = open(\"example-1layer.json\", \"r\") # open json file in reading mode\n",
    "data = json.load(json_file) # load json file in datastructure with json\n",
    "# input vector\n",
    "inputvector = [[1] for col in range(int(data[\"layer1\"][\"size_in\"]))] # input for the neural network\n",
    "matrices = weights_to_matrices(data) # load weights from file into matrices, for each layer 1 matrix\n",
    "# will multiply matrices in reversed order. Last productmatrix will be multiplied with input vector\n",
    "lastproduct = ordered_vectoroutput_multiplication(matrices, inputvector) # this function ensures correct order of matrix multiplication\n",
    "print(\"\\nOutput values 1 layer:\\n\", lastproduct) # print output\n",
    "\n",
    "# 2 layers\n",
    "json_file = open(\"example-2layer.json\", \"r\") # open json file in reading mode\n",
    "data = json.load(json_file) # load json file in datastructure with json\n",
    "# input vector\n",
    "inputvector = [[1] for col in range(int(data[\"layer1\"][\"size_in\"]))] # input for the neural network\n",
    "matrices = weights_to_matrices(data) # load weights from file into matrices, for each layer 1 matrix\n",
    "# will multiply matrices in reversed order. Last productmatrix will be multiplied with input vector\n",
    "lastproduct = ordered_vectoroutput_multiplication(matrices, inputvector) # this function ensures correct order of matrix multiplication\n",
    "print(\"\\nOutput values 2 layers:\\n\", lastproduct) # print output\n",
    "\n",
    "# 3 layers\n",
    "json_file = open(\"example-3layer.json\", \"r\") # open json file in reading mode\n",
    "data = json.load(json_file) # load json file in datastructure with json\n",
    "# input vector\n",
    "inputvector = [[1] for col in range(int(data[\"layer1\"][\"size_in\"]))] # input for the neural network\n",
    "matrices = weights_to_matrices(data) # load weights from file into matrices, for each layer 1 matrix\n",
    "# will multiply matrices in reversed order. Last productmatrix will be multiplied with input vector\n",
    "lastproduct = ordered_vectoroutput_multiplication(matrices, inputvector) # this function ensures correct order of matrix multiplication\n",
    "print(\"\\nOutput values 3 layers:\\n\", lastproduct) # print output"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}