Untitled.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = [0.99,0,0,0,0.99,0.99,0.99,0,0.99,0.99,0.99,0,0.99,0,0.99,0.99,0,0,0,0.99,0.99,0,0,0,0.99]\n",
    "O = [0,0.99,0.99,0.99,0,0,0.99,0,0.99,0,0,0.99,0,0.99,0,0,0.99,0,0.99,0,0,0.99,0.99,0.99,0]\n",
    "L = [0,0.99,0,0,0,0,0.99,0,0,0,0,0.99,0,0,0,0,0.99,0,0,0,0,0.99,0.99,0.99,0]\n",
    "E = [0,0.99,0.99,0.99,0,0,0.99,0,0,0,0,0.99,0.99,0.99,0,0,0.99,0,0,0,0,0.99,0.99,0.99,0]\n",
    "O2 = [0.99,0.99,0.99,0.99,0.99,0.99,0,0,0,0.99,0.99,0,0,0,0.99,0.99,0,0,0,0.99,0.99,0.99,0.99,0.99,0.99]\n",
    "O_blur = [0.2,0.2,0.2,0.2,0.2,0.4,0.1,0,0.1,0.4,0.4,0.1,0,0.1,0.4,0.4,0.1,0,0.1,0.4,0.2,0.2,0.2,0.2,0.2,]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.1  0.1  0.1  0.1  0.1  0.3  0.  -0.1  0.   0.3  0.3  0.  -0.1  0.\n",
      "  0.3  0.3  0.  -0.1  0.   0.3  0.1  0.1  0.1  0.1  0.1]\n"
     ]
    }
   ],
   "source": [
    "import statistics \n",
    "\n",
    "def preprocessing(list_1):\n",
    "\n",
    "    \"\"\"returns a new list with its characters corrected for noise\n",
    "    \n",
    "    Args:\n",
    "        list_1 (list): a list of integers representing a vector\n",
    "        \n",
    "    Returns: \n",
    "        char_processed (list): a new list corrected for noise\n",
    "        \n",
    "    \"\"\"\n",
    "    char_processed = np.copy(list_1)\n",
    " \n",
    "    for i in range(len(char_processed)):     \n",
    "        char_processed[i] = char_processed[i] - 0.1\n",
    "\n",
    "    return char_processed\n",
    "\n",
    "new_M = preprocessing(M)\n",
    "new_O = preprocessing(O)\n",
    "new_L = preprocessing(L)\n",
    "new_E = preprocessing(E)\n",
    "new_O2 = preprocessing(O2)\n",
    "new_O_blur = preprocessing(O_blur)\n",
    "\n",
    "print(new_O_blur)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# so this function basically just compares the prepocessed letters to the neural network and plots the predictive\n",
    "# percentages. (how sure it is). besides the preprocessing function, and the standardising function, \n",
    "# this is all we need. the rest is just for explaining what actually happens. \n",
    "\n",
    "\n",
    "def plot(data_):\n",
    "    Letters = ['M(0)', 'O(1)', 'L(2)', 'E(3)', 'O_Scale(4)', 'O_Blur(5)']\n",
    "    percent = []\n",
    "    precentage = []\n",
    "\n",
    "    for i in np.matmul(NN,data_):\n",
    "        percent.append(i)\n",
    "\n",
    "    Letter_dict = {Letters[i]: percent[i] for i in range(len(Letters))}\n",
    "    alpha = list(Letter_dict.keys())\n",
    "    nums = list(Letter_dict.values())\n",
    "\n",
    "    fig, ax = plt.subplots()\n",
    "    ax.bar(alpha, nums)\n",
    "    fig.suptitle('Predictive Accurace of Letter matching')\n",
    "    \n",
    "plot(new_M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### all that is following is not necessarilly needed atm and is more for own comprehension "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(str(np.dot(M,M))+'\\t'+str(np.dot(O,M))+'\\t'+str(np.dot(L,M))+'\\t'+str(np.dot(E,M))+'\\t'+str(np.dot(O2,M))+'\\t'+str(np.dot(O_blur,M)))\n",
    "print(str(np.dot(M,O))+'\\t'+str(np.dot(O,O))+'\\t'+str(np.dot(L,O))+'\\t'+str(np.dot(E,O))+'\\t'+str(np.dot(O2,O))+'\\t'+str(np.dot(O_blur,O)))\n",
    "print(str(np.dot(M,L))+'\\t'+str(np.dot(O,L))+'\\t'+str(np.dot(L,L))+'\\t'+str(np.dot(E,L))+'\\t'+str(np.dot(O2,L))+'\\t'+str(np.dot(O_blur,L)))\n",
    "print(str(np.dot(M,E))+'\\t'+str(np.dot(O,E))+'\\t'+str(np.dot(L,E))+'\\t'+str(np.dot(E,E))+'\\t'+str(np.dot(O2,E))+'\\t'+str(np.dot(O_blur,E)))\n",
    "print(str(np.dot(M,O2))+'\\t'+str(np.dot(O,O2))+'\\t'+str(np.dot(L,O2))+'\\t'+str(np.dot(E,O2))+'\\t'+str(np.dot(O2,O2))+'\\t'+str(np.dot(O_blur,O2)))\n",
    "print(str(np.dot(M,O_blur))+'\\t'+str(np.dot(O,O_blur))+'\\t'+str(np.dot(L,O_blur))+'\\t'+str(np.dot(E,O_blur))+'\\t'+str(np.dot(O2,O_blur))+'\\t'+str(np.dot(O_blur,O_blur)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(str(np.dot(new_M,new_M))+'\\t'+str(np.dot(new_O,new_M))+'\\t'+str(np.dot(new_L,new_M))+'\\t'+str(np.dot(new_E,new_M))+'\\t'+str(np.dot(new_O2,new_M))+'\\t'+str(np.dot(new_O_blur,new_M)))\n",
    "print(str(np.dot(new_M,new_O))+'\\t'+str(np.dot(new_O,new_O))+'\\t'+str(np.dot(new_L,new_O))+'\\t'+str(np.dot(new_E,new_M))+'\\t'+str(np.dot(new_O2,new_M))+'\\t'+str(np.dot(new_O_blur,new_M)))\n",
    "print(str(np.dot(new_M,new_L))+'\\t'+str(np.dot(new_O,new_L))+'\\t'+str(np.dot(new_L,new_L))+'\\t'+str(np.dot(new_E,new_M))+'\\t'+str(np.dot(new_O2,new_M))+'\\t'+str(np.dot(new_O_blur,new_M)))\n",
    "print(str(np.dot(new_M,new_E))+'\\t'+str(np.dot(new_O,new_E))+'\\t'+str(np.dot(new_L,new_E))+'\\t'+str(np.dot(new_E,new_E))+'\\t'+str(np.dot(new_O2,new_M))+'\\t'+str(np.dot(new_O_blur,new_M)))\n",
    "print(str(np.dot(new_M,new_O2))+'\\t'+str(np.dot(new_O,new_O2))+'\\t'+str(np.dot(new_L,new_O2))+'\\t'+str(np.dot(new_E,new_O2))+'\\t'+str(np.dot(new_O2,new_O2))+'\\t'+str(np.dot(new_O_blur,new_M)))\n",
    "print(str(np.dot(new_M,new_O_blur))+'\\t'+str(np.dot(new_O,new_O_blur))+'\\t'+str(np.dot(new_L,new_O_blur))+'\\t'+str(np.dot(new_E,new_O_blur))+'\\t'+str(np.dot(new_O2,new_O_blur))+'\\t'+str(np.dot(new_O_blur,new_O_blur)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def matmul(data):\n",
    "    \n",
    "    \"\"\"returns a list of floats that represents similarity to letters\n",
    "    \n",
    "    Args: \n",
    "        data (list): a list representing weights for each cell in the matrix (vector) letter\n",
    "        \n",
    "    Returns: \n",
    "        percentage (list): a list where each value represents the similarity between data and the NN. \n",
    "    \"\"\"\n",
    "    \n",
    "    NN = [new_M,new_O,new_L,new_E,new_O2,new_O_blur]\n",
    "    percentage = np.matmul(NN,data)\n",
    "    \n",
    "    return percentage\n",
    "    \n",
    "\n",
    "    \n",
    "print(matmul(new_M))\n",
    "print(matmul(new_O))\n",
    "print(matmul(new_L))\n",
    "print(matmul(new_E))\n",
    "print(matmul(new_O2))\n",
    "print(matmul(new_O_blur))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.argmax(np.matmul(NN,new_O)))\n",
    "print(np.argmax(np.matmul(NN,new_M)))\n",
    "print(np.argmax(np.matmul(NN,new_L)))\n",
    "print(np.argmax(np.matmul(NN,new_E)))\n",
    "print(np.argmax(np.matmul(NN,new_E)))\n",
    "print(np.argmax(np.matmul(NN,new_O2)))\n",
    "print(np.argmax(np.matmul(NN,new_O_blur)))"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}