HopfieldModel_FINAL.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Hopfield Model and data reconstuction**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Authors:\n",
    "- **Ballarin Marco**,   $\\textit{1228022, Physics of Data}$\n",
    "- **Iriarte Delfina**,  $\\textit{1231682, Physics of Data}$\n",
    "- **Segalini Beatrice**, $\\textit{1234430, Physics of Data}$\n",
    "- **Magenya Joemah**,   $\\textit{1233392, Physics of Data}$\n",
    "\n",
    "### Supervised by:\n",
    "- Professor Baiesi Marco, marco.baiesi@unipd.it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "G9AzwsBa14XR"
   },
   "source": [
    "Artificial Neural Networks (ANN) are computational techniques that aim to realize a very simplified model of the human brain. In this way, ANN try to learn tasks mimicking the behavior of brain, which is composed of a large set of elements, specialized cells called neurons. Each single neuron is a very simple entity but the power of the brain is given by the fact that neurons are numerous and strongly interconnected between them. The human brain is one of the most computationally efficient device that is why in the late years a lot of effort has been done in order to develop an artificial version of it, as a matter of fact companies like Telsa motors are developing self driving cars which are based on ANN to implement the behavior of the human brain in computer systems. \n",
    "\n",
    "The easiest way to represent a neuron is either \"on or off\" with the synapsys either eccitative or inibitive. We can easily map the neural network into a spin system by mapping neurons in spins $\\{s_i\\}_{i=1,\\cdots,N}$ and synapsys into the magnetic coupling $J_{ij}$.\n",
    "By a specific representation of these coupling costant we can define the Hopfield model.\n",
    "\n",
    "## The Hopfield Model\n",
    "\n",
    "The Hopfield model is a fully connected neural network able to recall stored memories starting from a noisy or distorted input. The Hopfield network consists of $N$ neurons connected through symmetric bidirectional links. The neuron interactions are encoded in the connection matrix, a $N × N$ real symmetric matrix without self-interaction terms, whose $J_{ij}$ entries define the weight of the connection between neuron $i$ and $j$. \n",
    "\n",
    "The model respect the following mapping:\n",
    "\n",
    "$$\n",
    "n = \\{0,1\\} \\longrightarrow s = \\{-1,1\\}    \n",
    "$$\n",
    "                                   \n",
    "where $n$ is the neuron and $s$ the spin. \n",
    "The correct transformation of this mapping is:\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "s = f(n) = 2n-1\n",
    "\\end{equation}\n",
    "$$\n",
    "\n",
    "We define the synapses as:\n",
    "$$\n",
    "J_{ij}=\\begin{cases}\n",
    "+1 & \\mbox{ excitatory synapses} \\\\\n",
    "-1 & \\mbox{ inhibitory synapses}\n",
    "\\end{cases}\n",
    "$$\n",
    "\n",
    "A neuron is activated if it receives a sufficient number of active impulses, and we can compute these impulses as follows:\n",
    "$$\n",
    "\\begin{equation}\n",
    "h_i(t) = \\sum^N_{j=1,j\\neq i} J_{ij}(s_j(t)+1)\n",
    "\\label{eq:h} \n",
    "\\end{equation}\n",
    "$$\n",
    "It is important to notice that $j\\neq i$ since the neuron $\\textit{does not}$ interacts with itself.\n",
    "To decide if these impulses are sufficient to activate the neuron, we apply a non-linear function to the impulses:\n",
    "$$\n",
    "\\begin{equation}\n",
    "s_i(t+1)=sign{\\left(h_i(t)-\\theta_i\\right)}\n",
    "\\end{equation}\n",
    "$$\n",
    "where $\\theta_i$ is a fixed threshold. We choose this threshold in a way that is useful for the calculations:\n",
    "$$\n",
    "\\theta_i = \\sum^N_{j=1,j\\neq i} J_{ij}.\n",
    "$$\n",
    "By applying this threshold, we obtain the following $\\textbf{update rule}$, which we will be using below in the code:\n",
    "$$\n",
    "\\\\\n",
    "\\begin{equation}\n",
    "s_i(t+1)=sign{\\left(\\sum^N_{j=1,j\\neq i} J_{ij}s_j(t)\\right)}\n",
    "\\label{eq:upd}\n",
    "\\end{equation}\n",
    "\\\\\n",
    "$$\n",
    "The $\\textbf{Hopfield model}$ that we will exploit in our work consists of a specific choice for the synapses ($\\textit{magnetic couplings}$):\n",
    "$$\n",
    "\\\\\n",
    "\\begin{equation}\n",
    "\\begin{cases}\n",
    "J_{ii}=0 & \\mbox{ known as Hebb rule} \\\\\n",
    "J_{ij}=\\frac{1}{N}\\sum_{\\mu=1}^{p} \\xi^\\mu_i\\xi^\\mu_j\n",
    "\\end{cases}\n",
    "\\label{eq:hop}\n",
    "\\end{equation}\n",
    "\\\\\n",
    "$$\n",
    "where the $\\vec{\\xi^\\mu}$ are $p<<N$ excitatory pattern with $\\xi^\\mu_i=\\{+1,-1\\}$.\n",
    "This choice encodes these patterns in the couplings and gives to the system some interesting properties:\n",
    "- If the system starts from a configuration equal to a pattern $\\vec{\\xi^\\mu}$ and we apply the update rule of Eq $\\eqref{eq:upd}$, it remains in that pattern $\\forall t$.\n",
    "- By solving the system from a statistical mechanics point of view, it turns out that all the minima of the system corresponds to the patterns.\n",
    "\n",
    "It is instructive to see the proof of the stability of the patterns.\n",
    "$$\n",
    "s(1)=sign{\\left(\\sum^N_{j=1} J_{ij}s_j(0)\\right)}\\overset{s_j(0)=\\xi^\\mu_j}{=}\n",
    "sign{\\left(\\sum^N_{j=1} \\frac{1}{N}\\sum^p_{\\nu=1}\\xi_i^\\nu\\xi_j^\\nu\\xi_j^\\mu\\right)} \n",
    "\\\\=sign{\\left(\\sum^N_{\\nu=1}\\xi_i^\\nu\\frac{1}{N}\\sum^p_{j=1}\\xi_j^\\nu\\xi_j^\\mu \\right)} \n",
    "=sign{\\left(\\sum^N_{\\nu=1}\\xi_i^\\nu(\\delta_{\\mu\\nu}+O(N^{-\\frac{1}{2}}) \\right)}\n",
    "\\simeq sign\\left(\\xi^\\mu_i \\right)=\\xi^\\mu_i\n",
    "$$\n",
    "And so the property enuciated before holds.\n",
    "\n",
    "From now on we will talk about spins and not neurons anymore.\n",
    "\n",
    "This model take into account fully connected systems, where each spin is connected to all the others. But what happen if we consider an interaction lenght $R$? It is an interesting question to look at how the results vary with this assumption.\n",
    "\n",
    "Moreover, this type of system does not need training, differently to other neural networks, and so it can be really interesting if the results are good.\n",
    "\n",
    "In conclusion, the aim of this work is to start from this theoretical model and further analyze it, by studying the stability of the patterns, the recovering of corrupted ones and simulate its dynamics with a Montecarlo method.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy as scp\n",
    "from copy import deepcopy\n",
    "import time as time\n",
    "import pylab as pb \n",
    "from mpl_toolkits.mplot3d import Axes3D\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stability of the model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this first section, we are going to discuss about the stability of the Hopfield model, in both MF and NMF, especially focusing on these main points:\n",
    "\n",
    "- study of the dependence of error of the algorithm with respect to number of patterns; \n",
    "- time scaling with size of the system;\n",
    "- time scaling with the number of patterns;\n",
    "- dependence of the error on the number of neighbors. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameters\n",
    "L = 10   # Length of the edge of the image\n",
    "N = L**2 # Number of spins \n",
    "p = 5    # Number of patterns\n",
    "MF = 0   # Use or not the Mean Field strategy: if MF = 1 uses MF, if MF = 0 only spins at\n",
    "         # a distance R interacts\n",
    "R = 3    # The 3-nearest neighbor interacts\n",
    "np.random.seed(1234) # Seed to make the random process reproducible"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1f3a9c311d0>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPUAAAD4CAYAAAA0L6C7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAKL0lEQVR4nO3dwYukd53H8fdnZww6cUVh++JM2EQQd4OwxC4kGpAl8aBrMJc9RFBYL3NZNYqLZPfiPyCiBxGGqBeDOYw5iAR1Yb3sZbBnEtBJK4Q4m4yJ2Dmsipcx+PXQLYwz3VNPV9eTp59v3i8YmKqu1Hyp7nd+T1U99etUFZL6+JupB5C0XkYtNWPUUjNGLTVj1FIzJ8e40ySjvKS+ubk5xt1y8eLFtd/nWLOOZYzHAPyejeXKlSu88sor2e9rGeMtrbGiHuvtt2Tfx+ZI5vZW4RiPAfg9G8tisWBra2vfB8HDb6kZo5aaMWqpGaOWmjFqqRmjlpoZFHWSDyX5RZLnkjw69lCSVrc06iQngK8BHwbuBj6W5O6xB5O0miEr9XuB56rq+aq6BjwBPDTuWJJWNSTq08CL112+unfdX0lyNslWkq11DSfp8Iac+73fqWg3nU9XVeeAczDeaaKSlhuyUl8F7rju8hngpXHGkXRUQ6L+CfDOJHcluQ14GPjeuGNJWtXSw++qejXJp4AfAieAb1bV5dEnk7SSQZ+nrqqngKdGnkXSGnhGmdSMUUvNGLXUjFFLzRi11Mwou4nOzZw2nBuLj8H8Nl88iCu11IxRS80YtdSMUUvNGLXUjFFLzRi11IxRS80YtdSMUUvNGLXUjFFLzRi11IxRS80YtdSMUUvNGLXUjFFLzRi11IxRS80YtdTMKLuJbm5usrU1n989P9YukmMYa2fKue2k6e6nB3OllpoxaqkZo5aaMWqpGaOWmjFqqRmjlppZGnWSO5L8OMl2kstJHnktBpO0miEnn7wKfL6qLiX5W+Bikv+uqmdHnk3SCpau1FX1clVd2vv774Ft4PTYg0lazaGeUye5E7gHuLDP184m2UqytbOzs57pJB3a4KiTvBn4LvDZqvrdjV+vqnNVtaiqxcbGxjpnlHQIg6JO8gZ2g368qp4cdyRJRzHk1e8A3wC2q+rL448k6SiGrNT3AZ8A7k/yzN6ffxl5LkkrWvqWVlX9LzCfDxxLr3OeUSY1Y9RSM0YtNWPUUjMZYwO3JLPaFc5N7Oa38eAY885pVoCq2veOXamlZoxaasaopWaMWmrGqKVmjFpqxqilZoxaasaopWaMWmrGqKVmjFpqxqilZoxaasaopWaMWmrGqKVmjFpqxqilZoxaasaopWaW/tqd1wN3phzP3HYp7cCVWmrGqKVmjFpqxqilZoxaasaopWaMWmpmcNRJTiR5Osn3xxxI0tEcZqV+BNgeaxBJ6zEo6iRngI8Aj407jqSjGrpSfwX4AvCng26Q5GySrSRba5lM0kqWRp3kQeA3VXXxVrerqnNVtaiqxdqmk3RoQ1bq+4CPJrkCPAHcn+Tbo04laWU5zKddkvwz8B9V9eCS273uP0Ljp7TGNadPaY34SbV979j3qaVmDrVSD75TV2pX6pG5UrtSS68bRi01Y9RSM0YtNWPUUjOj7Ca6ubnJ1tb6zxad086Uc3uVem6v1s9pB9gx7nexOPjETVdqqRmjlpoxaqkZo5aaMWqpGaOWmjFqqRmjlpoxaqkZo5aaMWqpGaOWmjFqqRmjlpoxaqkZo5aaMWqpGaOWmjFqqRmjlpoxaqmZUXYTHcvcdryckznt1Arz+p691rO6UkvNGLXUjFFLzRi11IxRS80YtdSMUUvNDIo6yVuTnE/y8yTbSd439mCSVjP05JOvAj+oqn9NchtwasSZJB3B0qiTvAX4APBvAFV1Dbg27liSVjXk8PsdwA7wrSRPJ3ksye033ijJ2SRbSbZ2dnbWPqikYYZEfRJ4D/D1qroH+APw6I03qqpzVbWoqsXGxsaax5Q01JCorwJXq+rC3uXz7EYu6RhaGnVV/Rp4Mcm79q56AHh21KkkrWzoq9+fBh7fe+X7eeCT440k6SgGRV1VzwCLkWeRtAaeUSY1Y9RSM0YtNWPUUjNGLTUzq91E52Ruu2jObd4xzOmxXSwOfjPKlVpqxqilZoxaasaopWaMWmrGqKVmjFpqxqilZoxaasaopWaMWmrGqKVmjFpqxqilZoxaasaopWaMWmrGqKVmjFpqxqilZma18aCb2LlB4Ji6PLau1FIzRi01Y9RSM0YtNWPUUjNGLTVj1FIzg6JO8rkkl5P8LMl3krxx7MEkrWZp1ElOA58BFlX1buAE8PDYg0lazdDD75PAm5KcBE4BL403kqSjWBp1Vf0K+BLwAvAy8Nuq+tGNt0tyNslWkq2dnZ31TyppkCGH328DHgLuAt4O3J7k4zferqrOVdWiqhYbGxvrn1TSIEMOvz8I/LKqdqrqj8CTwPvHHUvSqoZE/QJwb5JT2f24yQPA9rhjSVrVkOfUF4DzwCXgp3v/zbmR55K0okGfp66qLwJfHHkWSWvgGWVSM0YtNWPUUjNGLTVj1FIzs9pNVOMZaydNvfZcqaVmjFpqxqilZoxaasaopWaMWmrGqKVmjFpqxqilZoxaasaopWaMWmrGqKVmjFpqxqilZoxaasaopWaMWmrGqKVmjFpqxqilZjLGLpJJdoD/G3DTvwNeWfsA45nTvHOaFeY173GY9e+rat9fBD9K1EMl2aqqxWQDHNKc5p3TrDCveY/7rB5+S80YtdTM1FHP7ZfXz2neOc0K85r3WM866XNqSes39Uotac2MWmpmsqiTfCjJL5I8l+TRqeZYJskdSX6cZDvJ5SSPTD3TEElOJHk6yfennuVWkrw1yfkkP997jN839Uy3kuRzez8HP0vynSRvnHqmG00SdZITwNeADwN3Ax9LcvcUswzwKvD5qvpH4F7g34/xrNd7BNieeogBvgr8oKr+AfgnjvHMSU4DnwEWVfVu4ATw8LRT3Wyqlfq9wHNV9XxVXQOeAB6aaJZbqqqXq+rS3t9/z+4P3elpp7q1JGeAjwCPTT3LrSR5C/AB4BsAVXWtqv5/2qmWOgm8KclJ4BTw0sTz3GSqqE8DL153+SrHPBSAJHcC9wAXpp1kqa8AXwD+NPUgS7wD2AG+tfdU4bEkt0891EGq6lfAl4AXgJeB31bVj6ad6mZTRZ19rjvW760leTPwXeCzVfW7qec5SJIHgd9U1cWpZxngJPAe4OtVdQ/wB+A4v77yNnaPKO8C3g7cnuTj0051s6mivgrccd3lMxzDw5i/SPIGdoN+vKqenHqeJe4DPprkCrtPa+5P8u1pRzrQVeBqVf3lyOc8u5EfVx8EfllVO1X1R+BJ4P0Tz3STqaL+CfDOJHcluY3dFxu+N9Est5Qk7D7n266qL089zzJV9Z9Vdaaq7mT3cf2fqjp2qwlAVf0aeDHJu/auegB4dsKRlnkBuDfJqb2fiwc4hi/snZziH62qV5N8Cvghu68gfrOqLk8xywD3AZ8Afprkmb3r/quqnppwpk4+DTy+9z/354FPTjzPgarqQpLzwCV23xV5mmN4yqiniUrNeEaZ1IxRS80YtdSMUUvNGLXUjFFLzRi11MyfAc9NclHp3pEsAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Patterns\n",
    "def random_patterns(N,p):\n",
    "    xi = np.random.randint(0,2,N*p).reshape(p,N) # Each line is a pattern\n",
    "    xi[xi==0]=-1\n",
    "    return xi\n",
    "\n",
    "xi = random_patterns(N,p)\n",
    "idx = np.random.randint(0,p)\n",
    "plt.imshow(xi[idx].reshape(L,L),cmap='Greys') # This is an example of pattern \n",
    "# -1 = white, +1 = black"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Coupling constant\n",
    "# Row i is the connections of the i-th neuron with the others.\n",
    "# Note that the Hopfield model requires Jii=0\n",
    "# Note that J is a symmetrical matrix (J=J.T)\n",
    "\n",
    "def MF_coupling(xi,N):\n",
    "    J = 1/N * np.array( [ (xi[:,i]*xi[:,j]).sum() for i in range(N) for j in range(N) ] )\n",
    "    J = J.reshape(N,N)        \n",
    "    for i in range(len(J)):\n",
    "        J[i,i] = 0\n",
    "    return J\n",
    "\n",
    "def R_coupling(xi,N,R):\n",
    "    J = MF_coupling(xi,N)\n",
    "    L = int(np.sqrt(N))\n",
    "    for i in range( J.shape[0] ):\n",
    "        J_temp = J[i].reshape(L,L)\n",
    "        for j in range(L):\n",
    "            y = (i%L -j)**2 \n",
    "            for k in range(L):\n",
    "                if np.sqrt( (i//L - k)**2 + y ) > R: J_temp[j,k] = 0\n",
    "        J[i] = J_temp.reshape(1,N)\n",
    "    return J\n",
    "\n",
    "if MF: J = MF_coupling(xi,N)\n",
    "else: J = R_coupling(xi,N,R)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Update rule\n",
    "\n",
    "def update(sys1):\n",
    "    sys = deepcopy(sys1)\n",
    "    N = len(sys)\n",
    "    temp = np.zeros(N) \n",
    "    for i in range(N):\n",
    "        for j in range(N): \n",
    "            temp[i] +=  J[i][j]*sys[j]\n",
    "        if temp[i] == 0: temp[i] = 2*np.random.randint(0,2)-1\n",
    "    sys = np.sign(temp)\n",
    "    return np.sign(sys)\n",
    "\n",
    "def deterministic_hopfield(sys, t): #t is the number of iterations\n",
    "    for i in range(t):\n",
    "        sys = update(sys)\n",
    "    return sys\n",
    "\n",
    "#we define the error as the number of different pixels between a pattern and the image \n",
    "#normalized to the system size\n",
    "def error_im(xi_idx, sys): #xi_idx is the \"correct\" pattern\n",
    "    wrong_pixels = (np.abs( sys-xi_idx )/2).sum()\n",
    "    return wrong_pixels/len(sys)\n",
    "\n",
    "def assign_pattern(xi,sys): #xi are the patterns\n",
    "    errors = [ error_im(i,sys) for i in xi ]\n",
    "    correct = np.argmin(errors)\n",
    "    return correct \n",
    "\n",
    "#calculate score and error for all the possible patterns\n",
    "def total_error(xi,t):\n",
    "    errors = []\n",
    "    prediction = []\n",
    "    for mu in range(len(xi)):\n",
    "        sys = deterministic_hopfield(xi[mu],t)\n",
    "        errors.append( error_im(xi[mu],sys) )\n",
    "        if assign_pattern(xi,sys)==mu:\n",
    "            prediction.append( 1 )\n",
    "        else: prediction.append( 0 )\n",
    "    errors = (np.array(errors)).mean()\n",
    "    prediction = np.array(prediction).sum()/len(xi)\n",
    "    return errors, prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The error of the algorithm is 0.030000\n",
      "The algorithm recognised the pattern 2 and the correct pattern is 2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# actual algorithm\n",
    "\n",
    "idx = np.random.randint(0,p) #randomly chosen pattern\n",
    "sys = deepcopy(xi[idx])\n",
    "\n",
    "sys = deterministic_hopfield(sys,100)\n",
    "wrong_pixels = error_im(xi[idx],sys)\n",
    "assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "fig, ax = plt.subplots(1,2, figsize = (10,6))\n",
    "ax[0].set_title('Pattern')\n",
    "ax[0].imshow(xi[idx].reshape(L,L), cmap='Greys')\n",
    "ax[1].set_title('Finishing configuration')\n",
    "ax[1].imshow(sys.reshape(L,L), cmap='Greys')\n",
    "print('The error of the algorithm is %f' %(wrong_pixels))\n",
    "print('The algorithm recognised the pattern %i and the correct pattern is %i' %(assigned_pattern,idx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analysis\n",
    "\n",
    "At first we studied how the performances of the algorithm depended on the number of patterns $p$. The system size was fixed to $L=16$ for the first case, then we changed it to other sizes in order to compare the error and score. Both the Mean Field model (MF) and the Non Mean Field one (NMF) have been studied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = 16\n",
    "N = L**2\n",
    "\n",
    "P = np.arange(5,N/2,20)\n",
    "scores_16 = [[],[]]\n",
    "errors_16 = [[],[]]\n",
    "\n",
    "for MF in range(2):\n",
    "    for p in P: \n",
    "        p = int(p)\n",
    "        xi = random_patterns(N,p)\n",
    "        if MF: J = MF_coupling(xi,N)\n",
    "        else: J = R_coupling(xi,N,R)\n",
    "        err, pred = total_error(xi,30)    \n",
    "        scores_16[MF].append( pred )\n",
    "        errors_16[MF].append(err)\n",
    "\n",
    "figp, axp = plt.subplots(1,2, figsize=(14,6))\n",
    "axp[0].set_title('Dependance of the error by number of pattern p')\n",
    "axp[0].set_xlabel('Number of pattern p')\n",
    "axp[0].set_ylabel('Average error along the p patterns')\n",
    "axp[0].plot(P,errors_16[0],  '--bo', label='Error, no MF')\n",
    "axp[0].plot(P,errors_16[1], '--go', label='Error, MF')\n",
    "axp[0].legend()\n",
    "\n",
    "axp[1].set_title('Dependance of the prediction of the correct pattern by number of pattern p')\n",
    "axp[1].set_xlabel('Number of pattern p')\n",
    "axp[1].set_ylabel('Fraction of pattern correctly predicted')\n",
    "axp[1].plot(P,scores_16[0], '--bo', label='Score, no MF')\n",
    "axp[1].plot(P,scores_16[1], '--go', label='Score, MF')\n",
    "axp[1].legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\".\\Images\\stability_p_error_and_scores.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dependance of error with patterns generally follows an increasing tendency at the beginning of the curve, which then flatters, reaching a plateau. The growth is particularly steep in the case of the NMF model, which reaches its maximum within the first $40$ patterns. It is instead less pronounced for the MF theory: here the highest value ($\\approx 0.25$) is reached only after about $70$ patterns. The plateau of the NMF graph is, on the contrary, more stable, showing almost no oscillation around the value of $0.15$, which is also lower than the MF one.\n",
    "\n",
    "Concerning the dependence of the prediction of the correct pattern with number of patterns, it can be observed that, in case of NMF model, the score is always constant whichever the pattern, thus the independence of the error with number of patterns and the perfect effectiveness of the predictions. However, with the MF model, this stability is not preserved: in fact, after passing the first few patterns, the score drops to about $70\\%$, and oscillates around that value.\n",
    "\n",
    "These results can be justified by the structure of the models themselves: indeed, the Mean Field one is more influenced by similar patterns, since it averages over all the spins, while the Non Mean Field is more \"details oriented\" and will perceive small differences without looking at the whole image. \n",
    "\n",
    "It can be stated, after these considerations, that the Non Mean Field algorithm is more effective in studying the dependance of the error and score as functions of the number of patterns. As a consequence, for further analysis this model will be used.\n",
    "\n",
    "By observing both graphs, it can be observed that there exist an optimal value of $p$ patterns which optimize the performances of the algorithm, which in this case is around $20$ (about $8\\%$ of the system size, which is $\\approx \\sqrt{N} = L$ ). In order to verify if this tendency is preserved, different system sizes are studied."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = 10\n",
    "N = L**2\n",
    "P_10 = np.arange(5,N/2,5)\n",
    "scores_10 = []\n",
    "errors_10 = []\n",
    "sigma_10 = []\n",
    "\n",
    "MF = 0\n",
    "\n",
    "for pi in P_10: \n",
    "    err = []\n",
    "    pred = []\n",
    "    for n in range(20):\n",
    "        p = int(pi)\n",
    "        xi = random_patterns(N,p)\n",
    "        if MF: J = MF_coupling(xi,N)\n",
    "        else: J = R_coupling(xi,N,R)\n",
    "        e, p = total_error(xi,30)    \n",
    "        err.append(e)\n",
    "        pred.append(p)\n",
    "    pred = np.array(pred)\n",
    "    err = np.array(err)\n",
    "    sigma_10.append( pred.std() )\n",
    "    scores_10.append( pred.mean() )\n",
    "    errors_10.append( err.mean() )\n",
    "    \n",
    "L = 6\n",
    "N = L**2\n",
    "P_6 = np.arange(2,N/2,1)\n",
    "scores_6 = []\n",
    "errors_6 = []\n",
    "sigma_6 = []\n",
    "\n",
    "for pi in P_6: \n",
    "    err = []\n",
    "    pred = []\n",
    "    for n in range(50):\n",
    "        p = int(pi)\n",
    "        xi = random_patterns(N,p)\n",
    "        if MF: J = MF_coupling(xi,N)\n",
    "        else: J = R_coupling(xi,N,R)\n",
    "        e, p = total_error(xi,30)    \n",
    "        err.append(e)\n",
    "        pred.append(p)\n",
    "    pred = np.array(pred)\n",
    "    err = np.array(err)\n",
    "    sigma_6.append( pred.std() )\n",
    "    scores_6.append( pred.mean() )\n",
    "    errors_6.append( err.mean() )\n",
    "\n",
    "L = 8\n",
    "N = L**2\n",
    "P_8 = np.arange(2,N/2,2)\n",
    "scores_8 = []\n",
    "errors_8 = []\n",
    "sigma_8 = []\n",
    "\n",
    "for pi in P_8: \n",
    "    err = []\n",
    "    pred = []\n",
    "    for n in range(40):\n",
    "        p = int(pi)\n",
    "        xi = random_patterns(N,p)\n",
    "        if MF: J = MF_coupling(xi,N)\n",
    "        else: J = R_coupling(xi,N,R)\n",
    "        e, p = total_error(xi,30)    \n",
    "        err.append(e)\n",
    "        pred.append(p)\n",
    "    pred = np.array(pred)\n",
    "    err = np.array(err)\n",
    "    sigma_8.append( pred.std() )\n",
    "    scores_8.append( pred.mean() )\n",
    "    errors_8.append( err.mean() )\n",
    "\n",
    "figp, axp = plt.subplots(1,2, figsize=(14,6))\n",
    "axp[0].set_title('Dependance of the error by number of pattern p')\n",
    "axp[0].set_xlabel('Number of pattern p')\n",
    "axp[0].set_ylabel('Average error along the p patterns')\n",
    "axp[0].plot(P_6,errors_6, '--co', label='Error, no MF, L = 6')\n",
    "axp[0].plot(P_8,errors_8, '--ro', label='Error, no MF, L = 8')\n",
    "axp[0].plot(P_10,errors_10, '--ko', label='Error, no MF, L = 10')\n",
    "axp[0].legend() \n",
    "\n",
    "axp[1].set_title('Dependance of the prediction of the correct pattern by number of pattern p')\n",
    "axp[1].set_xlabel('Number of pattern p')\n",
    "axp[1].set_ylabel('Fraction of pattern correctly predicted')\n",
    "axp[1].plot(P_6, scores_6, '--co', label='Score, no MF, L = 6')\n",
    "axp[1].plot(P_8, scores_8, '--ro', label='Score, no MF, L = 8')\n",
    "axp[1].plot(P_10, scores_10, '--ko', label='Score, no MF, L = 10')\n",
    "axp[1].legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\".\\Images\\err_score_p_diffsizes.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the comparison of system with different sizes, one can deduce that the hypothesized tendency is respected. In fact, the scores show the steepest descent with a number of $p$ close to the $\\sqrt{N}$; in the other graph, at the same abscissa, the error raise is the biggest. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How does the time scales with the number of spins N?\n",
    "\n",
    "In this section, the focus of the analysis is moved to implementation time. It is important to state that the actual values derived are not significant, as they strongly depend on the hardware used. We studied different $L$s for both Mean Field and Non Mean Field models, even if we expect the same trend."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = np.arange(10,28,4)\n",
    "N = L**2 \n",
    "p = 10\n",
    "times = [[],[]]\n",
    "\n",
    "for MF in range(2):\n",
    "    for n in N:\n",
    "        xi = np.random.randint(0,2,n*p).reshape(p,n)\n",
    "        xi[xi==0]=-1\n",
    "        J = 1/n * np.array( [ (xi[:,i]*xi[:,j]).sum() for i in range(n) for j in range(n) ] )\n",
    "        J = J.reshape(n,n)\n",
    "        for k in range(len(J)):\n",
    "            J[k,k] = 0\n",
    "        if MF: J = MF_coupling(xi, n)\n",
    "        else: J = R_coupling(xi, n, 3)\n",
    "        idx = np.random.randint(0,p)\n",
    "        start = time.time()\n",
    "        deterministic_hopfield(xi[idx],30)\n",
    "        end = time.time()\n",
    "        times[MF].append(end-start)\n",
    "\n",
    "fig, ax = plt.subplots(figsize = (8, 8))\n",
    "ax.plot(N,times[0], '--bo', label = 'Data with 10 patterns, no MF')\n",
    "ax.plot(N,times[1], '--go', label = 'Data with 10 patterns, MF')\n",
    "ax.set(xlabel = ' Number of spins N', ylabel =' Implementation time [s]', \n",
    "              title = '  Dependency of the time implementation on the size of the system')\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\".\\Images\\time_2.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The two curves above show both an exponential growth of the implementation time as a function of the size of the system. The tendency does not change for both Mean Field and Non Mean Field models: this is consistent with the fact that the two algorithms are implemented with the same logic, just by changing the coupling rule.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How does the time scales with the number of pattern p with a fixed N?\n",
    "\n",
    "Now we analyse the behaviour of implementation time with respect to the number of pattern p with a fixed system size, for both Mean Field and Non Mean Field models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = 16\n",
    "N = L**2 \n",
    "P = np.arange(10,N,16)\n",
    "times = [[],[]]\n",
    "\n",
    "for MF in range(2):\n",
    "    for p in P:\n",
    "        p = int(p)\n",
    "        xi = np.random.randint(0,2,N*p).reshape(p,N)\n",
    "        xi[xi==0]=-1\n",
    "        J = 1/N * np.array( [ (xi[:,i]*xi[:,j]).sum() for i in range(N) for j in range(N) ] )\n",
    "        J = J.reshape(N,N)\n",
    "        for k in range(len(J)):\n",
    "            J[k,k] = 0\n",
    "        if MF: J = MF_coupling(xi, N)\n",
    "        else: J = R_coupling(xi, N, 3)\n",
    "        idx = np.random.randint(0,p)\n",
    "        start = time.time()\n",
    "        deterministic_hopfield(xi[idx],30)\n",
    "        end = time.time()\n",
    "        times[MF].append(end-start)\n",
    "\n",
    "fig, ax = plt.subplots(figsize = (8, 8))\n",
    "ax.plot(P,times[0], '--bo', label = 'Data with 16x16 spins, no MF')\n",
    "ax.plot(P,times[1], '--go', label = 'Data with 16x16 spins, MF')\n",
    "ax.set(xlabel = 'Number of patterns p', ylabel =' Implementation time [s]', \n",
    "              title = ' Dependency of the time implementation on the number of patterns')\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\".\\Images\\stab_patt_time.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this graph the implementation time as a function of the number of patterns is displayed. The shape of the curve does not outline any particular tendency, and oscillates randomly showing instability.\n",
    "The Mean Field model has less pronounced fluctuations with respect to the Non Mean Field one.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changing the number of neighbors\n",
    "\n",
    "We have seen that the Non Mean Field model seems to be more stable and lead to smaller errors. It is then relevant to study how the model evolves if we change the number $R$ of neighbors. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MF = 0\n",
    "L = 10\n",
    "N = L**2 \n",
    "P = 10\n",
    "error_R = [[],[]]\n",
    "sigmas_R = [[],[]]\n",
    "R = np.arange(3,L)\n",
    "\n",
    "for MF in range(2):\n",
    "    for r in R: \n",
    "        supp = []\n",
    "        for n in range(50):\n",
    "            xi = random_patterns(N,P)\n",
    "            if MF: J = MF_coupling(xi,N)\n",
    "            else: J = R_coupling(xi,N,r)\n",
    "            err, pred = total_error(xi,30)    \n",
    "            supp.append(err)\n",
    "        supp = np.array(supp)\n",
    "        error_R[MF].append(supp.mean())\n",
    "        sigmas_R[MF].append(supp.std())\n",
    "        \n",
    "fig, ax = plt.subplots(figsize = (8,8))\n",
    "ax.plot(R,error_R[0], '--bo', label = 'no MF')\n",
    "ax.errorbar(R,error_R[0], yerr=sigmas_R[0], fmt='none', color='b')\n",
    "ax.plot(R,error_R[1], '--go', label = 'MF')\n",
    "ax.errorbar(R,error_R[1], yerr=sigmas_R[1], fmt='none', color='g')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\".\\Images\\R_p.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A decreasing tendency in the value of the error can be outlined in the graph above. \n",
    "The errorbars are added after calculating the standard deviation of the error along several iterations, and are significant for the NMF model. Concerning the MF one, we can observe very small errors due to the fact that all the value are indeed close to zero: this happens because we are considering a deterministic evolution and because the MF model does not depend on the number of neighbors, as it is considering an average of all the interactions along the grid.\n",
    "\n",
    "Nevertheless, the most striking feature is that the NMF model approaches the MF one with the increasing number of neighbors. This is just as it can be predicted: as a matter of fact, increasing $R$ means increasing the radius of interactions between spins. By including more and more and more spins, the coupling function will become closer to the average field along all the grid. Hence, the two models will become more similar with bigger $R$s.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "B5cDCWZd1XUi"
   },
   "source": [
    "# Corruption of patterns\n",
    "\n",
    "## Why noise in pattern recognition\n",
    "\n",
    "Noise is the amount of meaningless information contained in corrupted data. It incorporates any type of data that a user system cannot understand or interpret correctly.\n",
    "Using improper procedures to getting rid of noise in the data can lead to inaccurate results and false conlusions. Noise reduction is very important in order to obtain accurate results. \n",
    "\n",
    "We implemented different types of noises to discuss how the patterns differs when they are applied. In this work, we used the following noises:\n",
    "- uniform noise \n",
    "- gaussian noise\n",
    "- cauchy noise\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ReTo8gWs1XVP"
   },
   "outputs": [],
   "source": [
    "#function for plotting\n",
    "def plot(x, y, sys):\n",
    "    fig, ax = plt.subplots(1,3, figsize=(15,8))\n",
    "    ax[0].set_title('Original pattern')\n",
    "    ax[0].imshow(x.reshape(L,L),cmap='Greys')\n",
    "    ax[1].set_title('Corrupted pattern')\n",
    "    ax[1].imshow(y.reshape(L,L),cmap='Greys')\n",
    "    ax[2].set_title('Recovered pattern')\n",
    "    ax[2].imshow(sys.reshape(L,L),cmap='Greys')\n",
    "    plt.show()\n",
    "\n",
    "#function to run the algorithm\n",
    "def algorithm(xi, idx, yi):  #yi is the corrupted pattern\n",
    "    sys = deterministic_hopfield(yi,30)\n",
    "    wrong_pixels = error_im(xi[idx],sys)\n",
    "    assigned_pattern = assign_pattern(xi,sys)\n",
    "    return wrong_pixels, assigned_pattern, sys\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aLP1bdH81XVZ"
   },
   "source": [
    "## Uniform noise\n",
    "\n",
    "A uniform noise is consider as equally distributed along the pixels. To interpret the data, we define $q$ as a threshold probability. In order to corrupt the original pattern, a random number $r \\in (0,1)$ is generated with $\\textit{uniform distribution}$ for each pixel. If $r$ is less than the threshold, then that pixel is flipped. After corrupting the original pattern, the deterministic Hopfield function is called in order to produce a $\\textit{Recovered}$ one. \n",
    "\n",
    "The error with respect to the original pattern is then calculated. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DNdSCVyD1XVc",
    "outputId": "1d3a2e94-cf93-4f8f-823f-b41bba5e05fd",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The error of the algorithm is 0.040000\n",
      "The algorithm recognised the pattern 1 and the correct pattern is 1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x576 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Creates corrupted random data.\n",
    "def corrupt_uniform(sys, q): #q is the threshold probability\n",
    "    sys_temp = deepcopy(sys)\n",
    "    N = sys.shape[0]\n",
    "    for i in range(N):\n",
    "        r = np.random.rand()\n",
    "        if r < q:\n",
    "            sys_temp[i] *= -1\n",
    "    return sys_temp\n",
    "    \n",
    "#Testing the function\n",
    "idx = 1\n",
    "yi = corrupt_uniform(xi[idx],0.1) #we start with q = 0.1\n",
    "wrong_pixels, assigned_pattern, sys =algorithm(xi, idx, yi)\n",
    "print('The error of the algorithm is %f' %(wrong_pixels))\n",
    "print('The algorithm recognised the pattern %i and the correct pattern is %i' %(assigned_pattern,idx))\n",
    "plot(xi[idx], yi, sys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Varying the probability\n",
    "\n",
    "In this section we change the values of the threshold probability $q$ in order to visualize how the system behaves using both MF and NMF."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KgKouBSJ1XWX"
   },
   "outputs": [],
   "source": [
    "#set the probabilities between 0 and 1\n",
    "probabilities = np.arange(0,1,0.05)\n",
    "error = [[],[]]\n",
    "sigma = [[],[]]\n",
    "\n",
    "MF = [0,1]\n",
    "\n",
    "for i in MF:\n",
    "    if i: J = MF_coupling(xi,N)\n",
    "    else: J = R_coupling(xi,N,R)        \n",
    "    for q in probabilities:\n",
    "        supp = []\n",
    "        for n in range(100):\n",
    "            yi = corrupt_uniform(xi[idx],q)\n",
    "            wrong_pixels, assigned_pattern, sys = algorithm(xi, idx, yi)\n",
    "            supp.append(wrong_pixels)\n",
    "        supp = np.array(supp)\n",
    "        error[i].append(supp.mean())\n",
    "        sigma[i].append(supp.std())\n",
    "\n",
    "#Plot the results\n",
    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 7))\n",
    "\n",
    "ax1.plot(probabilities, error[0], '--bo')\n",
    "ax1.set_title('Dependence on the algorithm according to parameter $q$ with NO Mean Field')\n",
    "ax1.set_xlabel('Uniform Probability $q$')\n",
    "ax1.set_ylabel('Error')\n",
    "ax1.errorbar(probabilities, error[0], yerr = sigma[0], fmt = \"none\")\n",
    "\n",
    "ax2.plot(probabilities, error[1], '--bo')\n",
    "ax2.set_title('Dependence on the algorithm according to parameter $q$ with Mean Field')\n",
    "ax2.set_xlabel('Uniform Probability $q$')\n",
    "ax2.set_ylabel('Error')\n",
    "ax2.errorbar(probabilities, error[1], yerr = sigma[1], fmt = \"none\")        \n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\".\\Images\\plot1.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ti7aHXUT1XWq"
   },
   "source": [
    "From the graphs, we can deduced that with probabilty of about 20% the error remains constant in both cases, especially in the MF case. This implies that for this given probability the algorithm recover the pattern perfectly. As we expect, the error increase when more pixel are flipped. \n",
    "\n",
    "One can see that the NMF is less steep than the MF, but both have a sigmoid shape. \n",
    "\n",
    "By observing the errobars, one could notice that their behaviour is different for each interval of $q$:\n",
    "- if $q\\in (0, 0.2)$, the correct pattern is always recovered and so we have negligible errors;\n",
    "- if $q\\in (0.2, 0.8)$, since we change each pixel with $q \\sim 0.5$, we start from different patterns and so we explore a wider range of patterns (minima of the system);\n",
    "- if $q\\in (0.8,1)$ almost all the pixels are flipped and so the algorithm recovers always the same pattern, even if it is wrong."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Oihy6onZ1XVl"
   },
   "source": [
    "## Gaussian noise\n",
    "\n",
    "The gaussian distribution is given by:\n",
    "$$\n",
    "\\\\\n",
    "g(x) = h \\cdot \\exp{\\left[{-\\frac{(x-\\mu)^2}{2\\sigma^2}}\\right]}\n",
    "\\\\\n",
    "$$\n",
    "where $h$ is the maximum height of the distribution, $\\mu$ is its mean and $\\sigma$ its standard deviation.\n",
    "\n",
    "A 2D gaussian, made by the product of two statistically independent gaussians distribution, is overlapped to the original pattern. The coordinates of the centroids were chosen so as to pick only the most relevant cases, i.e. the center of the grid and its four corners. An arbitrary value of $\\sigma$ is chosen as $L/5$ in order to have a gaussian with a probability that goes to $0$ at the edges of the grid when the centroid is in its center. \n",
    "\n",
    "Concerning the parameter $h$, we decided not to choose the normalized version of the gaussian as it would have been unsignificant to our purpose, so we made $h$ vary between 0.1 and 1 in order to have different thresholds. To obtain the corrupted patterns, a random number $r$ is generated using $\\textit{uniform distribution}$ for each pixel. If $r$ is less than the threshold, set by the value of the gaussian in the considered point, then the pixel is flipped. \n",
    "\n",
    "After corrupting the patterns, the deterministic Hopfield function is called in order to produce a $\\textit{Recovered}$ one. Furthermore, the error with respect to the original pattern is calculated. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "W3iT4GgV1XVo"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def gaus(mu, sigma, h, x, y): #mu is a 2d array representing the position of the centroid\n",
    "                              #h is the maximum height of the gaussian\n",
    "    h = np.sqrt(h)\n",
    "    g_x = np.exp(-( (x-mu[0])**2 / ( 2.0 * sigma**2 ) ) )*h\n",
    "    g_y = np.exp(-( (y-mu[1])**2 / ( 2.0 * sigma**2 ) ) )*h\n",
    "    g = g_y * g_x\n",
    "    return g\n",
    "\n",
    "def gaus_3d(mu, sigma, h, x): #mu is a 2d array representing the position of the centroid\n",
    "                              #h is the maximum height of the gaussian\n",
    "    h = np.sqrt(h)\n",
    "    g_x = np.exp(-( (x[0]-mu[0])**2 / ( 2.0 * sigma**2 ) ) )*h\n",
    "    g_y = np.exp(-( (x[1]-mu[1])**2 / ( 2.0 * sigma**2 ) ) )*h\n",
    "    g = g_y * g_x\n",
    "    return g\n",
    "\n",
    "\n",
    "x = np.linspace(0,10)\n",
    "y = np.linspace(0,10)\n",
    "X, Y = np.meshgrid(x, y)\n",
    "Z = gaus_3d([5,5], 2, 0.5, [X, Y])\n",
    "\n",
    "fig = plt.figure(figsize=(20, 10))\n",
    "ax = fig.gca(projection='3d')\n",
    "ax.plot_surface(X, Y, Z, cmap='summer', alpha=0.7)\n",
    "ax.set_xlabel(\"i\", fontweight='bold', fontsize=14)\n",
    "ax.set_ylabel(\"j\", fontweight='bold', fontsize=14)\n",
    "ax.set_zlabel(\"gaus(i,j)\", fontweight='bold', fontsize=14)            \n",
    "pb.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Gm1O-NXC1XVx",
    "outputId": "944aa2f5-cfeb-46d4-bd06-a66593b8199c",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def corrupt_norm(sys, k, h): #k represent the mean in the gaussian\n",
    "                             #h represent the height in the gaussian\n",
    "    sys_temp = deepcopy(sys)\n",
    "    sys_temp = sys_temp.reshape(L,L)\n",
    "    N = sys.shape[0]\n",
    "    for i in range(L):\n",
    "        for j in range(L):\n",
    "            g = gaus(k, L/5, h, i, j)\n",
    "            r = np.random.rand()\n",
    "            if r < g:\n",
    "                sys_temp[i][j] *= -1\n",
    "    return (sys_temp.reshape(1,N))[0]\n",
    "\n",
    "idx = 1\n",
    "centroids = [np.array([0,0]), np.array([0,L-1]), np.array([L-1,0]), np.array([L-1,L-1]), np.array([L//2, L//2])]\n",
    "heights = np.linspace(0.1,1,10)\n",
    "\n",
    "for k in centroids:\n",
    "    print('The position of the centroid is ', k,'\\n')\n",
    "    for h in heights:\n",
    "        print('The height of the distribution is ', h)\n",
    "        yi = corrupt_norm(xi[idx], k, h)\n",
    "        wrong_pixels, assigned_pattern, sys = algorithm(xi, idx, yi)\n",
    "        print('The error of the algorithm is %f' %(wrong_pixels))\n",
    "        print('The algorithm recognised the pattern %i and the correct pattern is %i' %(assigned_pattern,idx))\n",
    "        plot(xi[idx], yi, sys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "764VJx661XWB"
   },
   "source": [
    "<img src = \".\\Images\\gaus.jpeg\">\n",
    "\n",
    "The figure shows the original pattern, the corrupted one with the centroid of the gaussian in the middle (using $h = 1$) and the recovered one. \n",
    "It can be seen that the corrupted pattern flip some pixels in the middle as we expected. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Error as a function of gaussian's height\n",
    "\n",
    "In this section, we compare the results using MF and NMF, studying the error of the algorithm as a function of the height $h$ of the gaussian."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "79iUzlxX1XXF"
   },
   "outputs": [],
   "source": [
    "# parameters \n",
    "idx = 1\n",
    "heights = np.linspace(0,1,10)\n",
    "centroids = [np.array([0,0]), np.array([0,L-1]), np.array([L-1,0]), np.array([L-1,L-1]), np.array([L//2, L//2])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "p-wAgchu1XXL"
   },
   "outputs": [],
   "source": [
    "# gaussian corrupt error behaviour with non mean field changing the parameter height on the gaussian\n",
    "MF = 0\n",
    "error_NMF = [[],[], [],[], []]\n",
    "sigma_NMF = [[],[], [],[], []]\n",
    "i = 0\n",
    "\n",
    "if MF: J = MF_coupling(xi,N)\n",
    "else: J = R_coupling(xi,N,R)            \n",
    "\n",
    "for k in centroids:\n",
    "    for h in heights:\n",
    "        supp = []\n",
    "        for n in range(50):\n",
    "            yi = corrupt_norm(xi[idx], k, h)\n",
    "            wrong_pixels, assigned_pattern, sys = algorithm(xi, idx, yi)\n",
    "            supp.append(wrong_pixels)\n",
    "        supp = np.array(supp)\n",
    "        error_NMF[i].append(supp.mean())\n",
    "        sigma_NMF[i].append(supp.std())\n",
    "    i +=1 \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "j3VOWmJI1XXR"
   },
   "outputs": [],
   "source": [
    "# gaussian corrupt error behaviour with mean field changing the parameter height on the gaussian\n",
    "MF = 1\n",
    "error_MF = [[],[], [],[], []]\n",
    "sigma_MF = [[],[], [],[], []]\n",
    "i = 0\n",
    "\n",
    "if MF: J = MF_coupling(xi,N)\n",
    "else: J = R_coupling(xi,N,R)\n",
    "        \n",
    "for k in centroids:\n",
    "    for h in heights:\n",
    "        supp = []\n",
    "        for n in range(50):\n",
    "            yi = corrupt_norm(xi[idx], k, h)\n",
    "            wrong_pixels, assigned_pattern, sys = algorithm(xi, idx, yi)\n",
    "            supp.append(wrong_pixels)\n",
    "        supp = np.array(supp)\n",
    "        error_MF[i].append(supp.mean())\n",
    "        sigma_MF[i].append(supp.std())\n",
    "    i +=1  \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-mLqKvnE1XXV"
   },
   "outputs": [],
   "source": [
    "#plot the results\n",
    "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(15, 15))\n",
    "\n",
    "ax1.plot(heights, error_NMF[0], '--bo', label ='Error behaviour in centroid [0,0]')\n",
    "ax1.plot(heights, error_NMF[1], '-ro', label ='Error behaviour in centroid [0,L-1]')\n",
    "ax1.plot(heights, error_NMF[2], '--go', label ='Error behaviour in centroid [L-1,0]')\n",
    "ax1.plot(heights, error_NMF[3], '--yo', label ='Error behaviour in centroid [L-1,L-1]')\n",
    "ax1.plot(heights, error_NMF[4], '--co', label ='Error behaviour in middle centroid')\n",
    "ax1.set_title('Dependence on the algorithm according to height $h$ of the gaussian with NO Mean Field')\n",
    "ax1.set_xlabel('Heights $h$')\n",
    "ax1.set_ylabel('Error');\n",
    "ax1.legend()\n",
    "\n",
    "\n",
    "ax2.plot(heights, error_MF[0], '--b', label ='Error behaviour in centroid [0,0]')\n",
    "ax2.plot(heights, error_MF[1], '--ro', label ='Error behaviour in centroid [0,L-1]')\n",
    "ax2.plot(heights, error_MF[2], '--go', label ='Error behaviour in centroid [L-1,0]')\n",
    "ax2.plot(heights, error_MF[3], '--yo', label ='Error behaviour in centroid [L-1,L-1]')\n",
    "ax2.plot(heights, error_MF[4], '--co', label ='Error behaviour in middle centroid')\n",
    "ax2.set_title('Dependence on the algorithm according to height $h$ of the gaussian with Mean Field')\n",
    "ax2.set_xlabel('Heights $h$')\n",
    "ax2.set_ylabel('Error');\n",
    "ax2.legend()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./Images/gaussian_corruption_h.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The MF model is not influenced by the gaussian noise, as it is able to get a broad picture and not be mislead by local changes.\n",
    "\n",
    "On the contrary, the NMF is affected, especially if the centroid coincide with the middle of the grid. The error increase with the gaussian height, as expected."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4NOJZSbd1XWE"
   },
   "source": [
    "## Cauchy noise\n",
    "\n",
    "The Cauchy distribution is given by:\n",
    "$$\n",
    "\\\\\n",
    "\\mathcal{C}(x) = h \\cdot \\left(1 + \\left(\\frac{x- x_0}{\\gamma}\\right)^2 \\right)^{-1}\n",
    "\\\\\n",
    "$$\n",
    "where $h$ is the maximum height of the distribution, $x_{0}$ specifies the location of the peak of the distribution, and $\\gamma$ is the scale parameter which specifies the half-width at half-maximum (HWHM).\n",
    "\n",
    "We chose $\\gamma$ arbitrarily ($\\gamma = L/5$) and made the peak $x_0$ of the distribution and its height $h$ variable, like the parameters $\\sigma$ and $\\mu$ of the gaussian distribution.\n",
    "\n",
    "We followed the same approach we used for the gaussian noise: we overlapped a 2-dimensional Cauchy distribution, and we used it to have a variable threshold for each pixel. Then we generated corrupted patterns, recovered them and evaluated the error.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Alue-hBu1XWF"
   },
   "outputs": [],
   "source": [
    "def cauchy(mu, gamma, h, x, y):#mu is a 2d array representing the position of the median\n",
    "                               #h is the maximum height of the distribution     \n",
    "    h = np.sqrt(h)\n",
    "    c_x = h/(1 + (((x-mu[0]))/gamma)**2)\n",
    "    c_y = h/(1 + (((y-mu[1]))/gamma)**2)\n",
    "    c = c_y * c_x\n",
    "    return c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6CxNq0-E1XWO",
    "outputId": "a765b0b3-1d24-4e2b-faff-4d98e7928ba9"
   },
   "outputs": [],
   "source": [
    "def corrupt_cauchy(sys, k, h): #k represent the mean in the cauchy distribution\n",
    "                               #h represent the height in the cauchy distribution\n",
    "    sys_temp = deepcopy(sys)\n",
    "    sys_temp = sys_temp.reshape(L,L)\n",
    "    N = sys.shape[0]\n",
    "    for i in range(L):\n",
    "        for j in range(L):\n",
    "            g = cauchy(k, L/5, h, i, j)\n",
    "            r = np.random.rand()\n",
    "            if r < g:\n",
    "                sys_temp[i][j] *= -1\n",
    "    return (sys_temp.reshape(1,N))[0]\n",
    "\n",
    "idx = 1\n",
    "centroids = [np.array([0,0]), np.array([0,L-1]), np.array([L-1,0]), np.array([L-1,L-1]), np.array([L//2, L//2])]\n",
    "heights = np.linspace(0.1,1,10)\n",
    "\n",
    "for k in centroids:\n",
    "    print('The position of the median is ', k,'\\n')\n",
    "    for h in heights:\n",
    "        print('The height of the distribution is ', h)\n",
    "        yi = corrupt_cauchy(xi[idx], k, h)\n",
    "        wrong_pixels, assigned_pattern, sys = algorithm(xi, idx, yi)\n",
    "        print('The error of the algorithm is %f' %(wrong_pixels))\n",
    "        print('The algorithm recognised the pattern %i and the correct pattern is %i' %(assigned_pattern,idx))\n",
    "        plot(xi[idx], yi, sys)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fCiqkdEH1XWW"
   },
   "source": [
    "<img src = \".\\Images\\corrupted_cauchy.png\">\n",
    "\n",
    "The figure shows the original pattern, the corrupted one with the centroid of the cauchy in the middle of the grid (using $h = 1$) and the recovered one. \n",
    "\n",
    "As we expected, the flipped pixel are mostly in the middle, following the tendency of the Cauchy distribution, which is more spread than the gaussian one.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Error as a function of Cauchy curve's height\n",
    "\n",
    "In this section, we compare the results using MF and NMF, studying the error of the algorithm as a function of the height $h$ of the Cauchy distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kiWF75NO1XXa"
   },
   "outputs": [],
   "source": [
    "# Behaviour of Cauchy distribution changing height using MF\n",
    "MF = 1\n",
    "error_MF_cauchy = [[],[], [],[], []]\n",
    "i = 0\n",
    "\n",
    "if MF: J = MF_coupling(xi,N)\n",
    "else: J = R_coupling(xi,N,R)\n",
    "            \n",
    "for k in centroids:\n",
    "    for h in heights:\n",
    "        supp = []\n",
    "        for n in range(50):\n",
    "            yi = corrupt_cauchy(xi[idx], k, h)\n",
    "            wrong_pixels, assigned_pattern, sys = algorithm(xi, idx, yi)\n",
    "            supp.append(wrong_pixels)\n",
    "        supp = np.array(supp)\n",
    "        error_MF_cauchy[i].append(supp.mean())\n",
    "    i +=1 \n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TW8Re5bX1XXf"
   },
   "outputs": [],
   "source": [
    "# Behaviour of Cauchy distribution changing height using NMF\n",
    "MF = 0\n",
    "error_NMF_cauchy = [[],[], [],[], []]\n",
    "i = 0\n",
    "\n",
    "if MF: J = MF_coupling(xi,N)\n",
    "else: J = R_coupling(xi,N,R)\n",
    "            \n",
    "for k in centroids:\n",
    "    for h in heights:\n",
    "        supp = []\n",
    "        for n in range(50):\n",
    "            yi = corrupt_cauchy(xi[idx], k, h)\n",
    "            wrong_pixels, assigned_pattern, sys = algorithm(xi, idx, yi)\n",
    "            supp.append(wrong_pixels)\n",
    "        supp = np.array(supp)\n",
    "        error_NMF_cauchy[i].append(supp.mean())\n",
    "    i +=1 \n",
    "       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_YTjANV81XXj"
   },
   "outputs": [],
   "source": [
    "#plot the results\n",
    "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(15, 15))\n",
    "\n",
    "ax1.plot(heights, error_NMF_cauchy[0], '--bo', label ='Error behaviour in centroid [0,0]')\n",
    "ax1.plot(heights, error_NMF_cauchy[1], '--ro', label ='Error behaviour in centroid [0,L-1]')\n",
    "ax1.plot(heights, error_NMF_cauchy[2], '--go', label ='Error behaviour in centroid [L-1,0]')\n",
    "ax1.plot(heights, error_NMF_cauchy[3], '--yo', label ='Error behaviour in centroid [L-1,L-1]')\n",
    "ax1.plot(heights, error_NMF_cauchy[4], '--co', label ='Error behaviour in middle centroid')\n",
    "ax1.set_title('Dependence on the algorithm according to height $h$ of the cauchy with NO Mean Field')\n",
    "ax1.set_xlabel('Heights $h$')\n",
    "ax1.set_ylabel('Error');\n",
    "ax1.legend()\n",
    "\n",
    "\n",
    "ax2.plot(heights, error_MF_cauchy[0], '--bo', label ='Error behaviour in centroid [0,0]')\n",
    "ax2.plot(heights, error_MF_cauchy[1], '--ro', label ='Error behaviour in centroid [0,L-1]')\n",
    "ax2.plot(heights, error_MF_cauchy[2], '--go', label ='Error behaviour in centroid [L-1,0]')\n",
    "ax2.plot(heights, error_MF_cauchy[3], '--yo', label ='Error behaviour in centroid [L-1,L-1]')\n",
    "ax2.plot(heights, error_MF_cauchy[4], '--co', label ='Error behaviour in middle centroid')\n",
    "ax2.set_title('Dependence on the algorithm according to height $h$ of the cauchy with Mean Field')\n",
    "ax2.set_xlabel('Heights $h$')\n",
    "ax2.set_ylabel('Error');\n",
    "ax2.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./Images/cauchy_corruption_h.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "zqYH12fj1XXn"
   },
   "source": [
    "Again, just like the gaussian case, the MF model is not influenced by the Cauchy noise, as it is able to get a broad picture and not be mislead by local changes.\n",
    "\n",
    "On the contrary, the NMF is even more affected, especially if the centroid coincide with the middle of the grid. The Caushy distribution is indeed wider and hence impacts on more pixels than the gaussian. Anyway, the error increase with the Cauchy curve height, as expected."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Montecarlo simulation\n",
    "\n",
    "Montecarlo simulations are computational tools that use pseudorandom numbers to feign the evolution of a physical system. As we have stated before, a really interesting feature of the Hopfield model is that it gives us the possibility of mapping a neuron system into a spin glasses system, hence giving us the possibility to employ such techniques. \n",
    "\n",
    "For this particular task we aim at finding the ground state of a spin system using the Metropolis algorithm as update rule. \n",
    "\n",
    "Given the system energy $\\mathcal{H}$, we randomly flip a spin of the system and we compute the difference in energy $\\Delta\\mathcal{H}=\\mathcal{H}_{f}-\\mathcal{H}_{i}$. Then accept the updated system with the following probability:\n",
    "$$\n",
    "\\begin{equation}\n",
    "p_{acc}= \\min\\left( 1, e^{-\\beta\\Delta\\mathcal{H}} \\right)\n",
    "\\end{equation}\n",
    "$$\n",
    "where $\\beta=(K_{b}T)^{-1}$ is the inverse of the temperature of the system. In this way if the energy is decreasing, we update the system with probability 1, while if it is greater, with a probability inversely proportional to the increase in energy.\n",
    "From the theory we know that the critical temperature, i.e. the highest temperature at which the system is trapped in a minimum, is $T=1/K_b$, hence $\\beta=1$.\n",
    "\n",
    "In this section we will cover:\n",
    "\n",
    "- the stability of the Montecarlo methods;\n",
    "- the improvement in the time implementation of Montecarlo;\n",
    "- the dependance of the algorithm's performances w.r.t. the type of noise;\n",
    "- the dependance of the algorithm's performances w.r.t. the number of neighbors for the NMF version;\n",
    "- the distinguish criteria between similar patterns.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def H(J,sys):  #energy of the system\n",
    "    N = sys.shape[0]\n",
    "    energy = 0\n",
    "    for i in range(N):\n",
    "        for j in range(i):\n",
    "            energy -= J[i][j]*sys[i]*sys[j]\n",
    "    return energy\n",
    "\n",
    "# difference if energy when flipping the spin k\n",
    "def dH(J, sys, k): \n",
    "    N = sys.shape[0]\n",
    "    dh = 0\n",
    "    for i in range(N):\n",
    "        dh += sys[i]*J[k][i]\n",
    "    dh *= 2*sys[k]\n",
    "    return dh\n",
    "\n",
    "#metropolis update rule\n",
    "def metropolis(J, sys1, k, B): # B = 1/kbT temperature of the system\n",
    "    sys = deepcopy(sys1)\n",
    "    dh = dH(J, sys, k)\n",
    "    r = np.random.rand() # random variable between (0,1)\n",
    "    if r < np.exp( -B*dh ):\n",
    "        sys[k] = -sys[k]\n",
    "    return sys\n",
    "\n",
    "#actual algorithm\n",
    "def montecarlo(J, sys1, B, t ): # t number of iteration of the montecarlo\n",
    "    sys = deepcopy(sys1)\n",
    "    N = sys.shape[0]\n",
    "    for i in range(t):\n",
    "        k = np.random.randint(0,N)\n",
    "        sys = metropolis(J, sys, k, B)\n",
    "    return sys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stability for Mean Field Montecarlo method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section, we study the stability of the Montecarlo method w.r.t. its characteristical parameters: $\\beta$, $t$ number of iterations.\n",
    "To underline how the model loses significance if $p \\geq \\sqrt{N}$, we will display the results for both $p=5$ and $p=10$ for a system of size $N=100$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "xi = random_patterns(N,p)\n",
    "J = MF_coupling(xi,N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The error of the algorithm is 0.000000\n",
      "The algorithm recognised the pattern 2 and the correct pattern is 2\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "idx = np.random.randint(10)\n",
    "\n",
    "sys = montecarlo(J,xi[idx], 10, 1000)\n",
    "wrong_pixels = error_im(xi[idx],sys)\n",
    "assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(1,2, figsize = (10,6))\n",
    "ax[0].set_title('Pattern')\n",
    "ax[0].imshow(xi[idx].reshape(L,L), cmap='Greys')\n",
    "ax[1].set_title('Finishing configuration')\n",
    "ax[1].imshow(sys.reshape(L,L), cmap='Greys')\n",
    "print('The error of the algorithm is %f' %(wrong_pixels))\n",
    "print('The algorithm recognised the pattern %i and the correct pattern is %i' %(assigned_pattern,idx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Temperature analysis\n",
    "\n",
    "We fix the number of iterations to $t=1000$ and size of the system to $N=100$ ($L=10$), while changing the temperature in a range $\\beta=[0,1,10,25,50,100]$. For each point we consider the average over $100$ loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "beta = [0, 1, 10, 25, 50, 100]\n",
    "err_beta_mean = []\n",
    "err_beta_std = []\n",
    "success = []\n",
    "for b in beta:\n",
    "    errors = []\n",
    "    correct = 0\n",
    "    for j in range(100):\n",
    "        idx = np.random.randint(10)\n",
    "        sys = montecarlo(J,xi[idx], b, 1000)\n",
    "        wrong_pixels = error_im(xi[idx],sys)\n",
    "        assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "        if idx == assigned_pattern: correct += 1\n",
    "        errors.append(wrong_pixels) \n",
    "        \n",
    "    correct /= 100\n",
    "    errors = np.array(errors)\n",
    "    err_beta_mean.append( errors.mean() )\n",
    "    err_beta_std.append( errors.std() )\n",
    "    success.append(correct)\n",
    "    \n",
    "fig, ax = plt.subplots(1,2,figsize=(12,6))\n",
    "\n",
    "ax[0].set_title('Errors as function of T')\n",
    "ax[0].set_xlabel('Beta [$J^{-1}$]')\n",
    "ax[0].set_ylabel('Average error')\n",
    "ax[0].plot(beta, err_beta_mean, '--bo', label='Error')\n",
    "ax[0].errorbar(beta,err_beta_mean, yerr=err_beta_std,ecolor='red', label='Fluctuation of error',fmt='none')\n",
    "ax[0].legend()\n",
    "\n",
    "ax[1].set_title('Probability of success as function of T')\n",
    "ax[1].set_xlabel('Beta [$J^{-1}$]')\n",
    "ax[1].set_ylabel('Probability of success')\n",
    "ax[1].plot(beta, success, '--ro', label='Data')\n",
    "ax[1].legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$p=5$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src = \".\\Images\\temperature_MFM.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$p=10$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src = \".\\Images\\m_avge_beta.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see how a higher value of $\\beta$ leads to  higher probability of success, and a $\\beta<10$ leads to totally unacceptable results.\n",
    "\n",
    "Even if $\\beta>25$ seems to produce better results, we have to think about the functioning of the algorithm: with a very high beta, the probability of flipping a \"wrong\" spin is $\\sim0$ and, starting from a minimum, it probably means that it does not flip a spin at all. So, for the following analisys we will use $\\beta=10$.\n",
    "\n",
    "In this analysis we don't see big differences given by the number of patterns."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Number of iteration analysis\n",
    "\n",
    "Here we analyze the stability of the algorithm w.r.t. the number of iterations, chosen in a range $t=[10,25,50,100,200,500,750,1000,1250,1500,1750,2000]$, while the other parameters are kept fixed ($\\beta=[10,25]$ and $L=10$). For each point we consider the average over $100$ loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iterations=[10,25,50,100,200,500,750,1000,1250,1500,1750,2000]\n",
    "\n",
    "# Beta = 10\n",
    "err_t_mean = []\n",
    "err_t_std = []\n",
    "success_t = []\n",
    "for t in iterations:\n",
    "    errors = []\n",
    "    correct = 0\n",
    "    for j in range(100):\n",
    "        idx = np.random.randint(10)\n",
    "        sys = montecarlo(J,xi[idx], 10, t)\n",
    "        wrong_pixels = error_im(xi[idx],sys)\n",
    "        assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "        if idx == assigned_pattern: correct += 1\n",
    "        errors.append(wrong_pixels) \n",
    "        \n",
    "    correct /= 100\n",
    "    errors = np.array(errors)\n",
    "    err_t_mean.append( errors.mean() )\n",
    "    err_t_std.append( errors.std() )\n",
    "    success_t.append(correct)\n",
    "    \n",
    "# Beta = 25\n",
    "err_t1_mean = []\n",
    "err_t1_std = []\n",
    "success_t1 = []\n",
    "for t in iterations:\n",
    "    errors = []\n",
    "    correct = 0\n",
    "    for j in range(100):\n",
    "        idx = np.random.randint(10)\n",
    "        sys = montecarlo(J,xi[idx], 25, t)\n",
    "        wrong_pixels = error_im(xi[idx],sys)\n",
    "        assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "        if idx == assigned_pattern: correct += 1\n",
    "        errors.append(wrong_pixels) \n",
    "        \n",
    "    correct /= 100\n",
    "    errors = np.array(errors)\n",
    "    err_t1_mean.append( errors.mean() )\n",
    "    err_t1_std.append( errors.std() )\n",
    "    success_t1.append(correct)\n",
    "\n",
    "fig, ax = plt.subplots(1,2,figsize=(12,6))\n",
    "\n",
    "ax[0].set_title('Errors as function of iterations')\n",
    "ax[0].set_xlabel('Number of iteration t')\n",
    "ax[0].set_ylabel('Average error')\n",
    "ax[0].plot(iterations, err_t_mean, '--bo', label='Error with beta=10')\n",
    "ax[0].errorbar(iterations,err_t_mean, yerr=err_t_std,ecolor='blue',fmt='none')\n",
    "ax[0].plot(iterations, err_t1_mean, '--go', label='Error with beta=25')\n",
    "ax[0].errorbar(iterations,err_t1_mean, yerr=err_t1_std,ecolor='green',fmt='none')\n",
    "ax[0].legend()\n",
    "\n",
    "ax[1].set_title('Probability of success as function of the number of iterations t')\n",
    "ax[1].set_xlabel('Number of iteration t')\n",
    "ax[1].set_ylabel('Probability of success')\n",
    "ax[1].plot(iterations, success_t, '--bo', label='Data with beta=10')\n",
    "ax[1].plot(iterations, success_t1, '--go', label='Data with beta=25')\n",
    "ax[1].legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$p=5$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src = \".\\Images\\iterationsMFM.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$p=10$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src = \".\\Images\\m_s_iterations.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here the number of patterns influence in a huge way the results. We can see that, as we can expect, with $p=5$ the algorithm reaches convergence from the start. Instead, with $p=10$, increasing the number of iterations raises the error. We can expect this sort of behaviour, since there are too much patterns and the minima are not clearly distincted.\n",
    "\n",
    "In the $p=10$ graph we can observe  that a $\\beta=10$ leads to a unstable situation: in fact, the error reaches a plateau, but not the probability of success.\n",
    "On the other hand, with $\\beta=25$, both error and probability of success seems to reach a plateau. So in the following we will use $25$ as the value of $\\beta$.\n",
    "\n",
    "Given these results, we decide to set the optimal $t$ as the beginning of the plateau, namely $t=1000$, since for that value even the difficoult problem of classify too many patterns reaches a convergence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Corruption with uniform noise\n",
    "\n",
    "As the stability of the algorithm has been thoroughly studied, we proceed to corrupt and recover patterns, starting from a uniform distribution along the grid of height $q$.\n",
    "\n",
    "We only used this kind of noise because it was the most significant one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The error of the algorithm is 0.060000\n",
      "The algorithm recognised the pattern 3 and the correct pattern is 3\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "idx = 3\n",
    "\n",
    "yi = corrupt_uniform(xi[idx], 0.2)\n",
    "\n",
    "sys = montecarlo(J,yi, 10, 100)\n",
    "wrong_pixels = error_im(xi[idx],sys)\n",
    "assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(1,2, figsize = (10,6))\n",
    "ax[0].set_title('Pattern')\n",
    "ax[0].imshow(xi[idx].reshape(L,L), cmap='Greys')\n",
    "ax[1].set_title('Finishing configuration')\n",
    "ax[1].imshow(sys.reshape(L,L), cmap='Greys')\n",
    "print('The error of the algorithm is %f' %(wrong_pixels))\n",
    "print('The algorithm recognised the pattern %i and the correct pattern is %i' %(assigned_pattern,idx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Temperature analysis\n",
    "\n",
    "First of all, it is needed to be stated that in this section we start from a corrupted pattern. This observation seems trivial, but indeed it is not, because the starting configuration is not a minimum and as a consequence some iterations are required to reach one of the original patterns.\n",
    "\n",
    "Hence, we study the dependance of the algorithm on the temperature, with uniformly corrupted patterns using $q=0.2$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "beta = [0, 1, 10, 25, 50, 100]\n",
    "err_beta_mean_c = []\n",
    "err_beta_std_c = []\n",
    "success_beta_c = []\n",
    "\n",
    "for b in beta:\n",
    "    errors = []\n",
    "    correct = 0\n",
    "    for j in range(100):\n",
    "        idx = np.random.randint(10)\n",
    "        yi = corrupt_uniform(xi[idx], 0.2)\n",
    "        sys = montecarlo(J, yi, b, 1000)\n",
    "        wrong_pixels = error_im(xi[idx],sys)\n",
    "        assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "        if idx == assigned_pattern: correct += 1\n",
    "        errors.append(wrong_pixels) \n",
    "        \n",
    "    correct /= 100\n",
    "    errors = np.array(errors)\n",
    "    err_beta_mean_c.append( errors.mean() )\n",
    "    err_beta_std_c.append( errors.std() )\n",
    "    success_beta_c.append(correct)\n",
    "\n",
    "fig, ax = plt.subplots(1,2,figsize=(12,6))\n",
    "\n",
    "ax[0].set_title('Errors as function of T with uniform noise')\n",
    "ax[0].set_xlabel('Beta [$J^{-1}$]')\n",
    "ax[0].set_ylabel('Average error')\n",
    "ax[0].plot(beta, err_beta_mean_c, '--bo', label='Error')\n",
    "ax[0].errorbar(beta,err_beta_mean_c, yerr=err_beta_std_c,ecolor='red', label='Fluctuation of error',fmt='none')\n",
    "ax[0].legend()\n",
    "\n",
    "ax[1].set_title('Probability of success as function of T with uniform noise')\n",
    "ax[1].set_xlabel('Beta [$J^{-1}$]')\n",
    "ax[1].set_ylabel('Probability of success')\n",
    "ax[1].plot(beta, success_beta_c, '--ro', label='Data')\n",
    "ax[1].legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src = \".\\Images\\Temp_MFM_C.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observing these graphs, a further confirmation of the best choice for the temeperature parameter $\\beta$ can be found, just as stated in the stability section. \n",
    "\n",
    "Consequently, from now on we will use $\\beta = 25$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Number of iteration analysis\n",
    "\n",
    "Just as the previously, we analyze the performances of the algorithm w.r.t. the number of iterations, chosen in a range $t=[10,25,50,100,200,500,750,1000,1250,1500,1750,2000]$, while the other parameters are kept fixed ($\\beta=25$, $L=10$, $q=0.2$). For each point we consider the average over $100$ loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iterations = [10,25,50,100,200,500,750,1000,1250,1500,1750,2000]\n",
    "err_t_mean_c = []\n",
    "err_t_std_c = []\n",
    "success_t_c = []\n",
    "\n",
    "for t in iterations:\n",
    "    errors = []\n",
    "    correct = 0\n",
    "    for j in range(100):\n",
    "        idx = np.random.randint(10)\n",
    "        yi = corrupt_uniform(xi[idx], 0.2)\n",
    "        sys = montecarlo(J, yi, 25, t)\n",
    "        wrong_pixels = error_im(xi[idx],sys)\n",
    "        assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "        if idx == assigned_pattern: correct += 1\n",
    "        errors.append(wrong_pixels) \n",
    "        \n",
    "    correct /= 100\n",
    "    errors = np.array(errors)\n",
    "    err_t_mean_c.append( errors.mean() )\n",
    "    err_t_std_c.append( errors.std() )\n",
    "    success_t_c.append(correct)\n",
    "    \n",
    "    \n",
    "fig, ax = plt.subplots(1,2,figsize=(12,6))\n",
    "\n",
    "ax[0].set_title('Errors as function of iterations')\n",
    "ax[0].set_xlabel('Number of iteration t')\n",
    "ax[0].set_ylabel('Average error')\n",
    "ax[0].plot(iterations, err_t_mean_c, '--bo', label='Errors')\n",
    "ax[0].errorbar(iterations,err_t_mean_c, yerr=err_t_std_c, ecolor='blue',fmt='none')\n",
    "ax[0].legend()\n",
    "\n",
    "ax[1].set_title('Probability of success as function of the number of iterations t')\n",
    "ax[1].set_xlabel('Number of iteration t')\n",
    "ax[1].set_ylabel('Probability of success')\n",
    "ax[1].plot(iterations, success_t_c, '--bo', label='Data')\n",
    "ax[1].legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\".\\Images\\Iter_MFM_C.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is difficult to outline a clear trend in both graphs. Probably, increasing the number of tests and observations could lead to better results. \n",
    "In any case, the graphs seem to reach an oscillatory behaviour after $t=1000$, this is particularly evident by observing the tendency of the probability of success. \n",
    "\n",
    "For this reason we choose $t=500$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Varying the probability $q$ \n",
    "\n",
    "Last but not least, we analyse the behaviour of the algorithm with $t=500$, $\\beta=25$, changing the value of  $q \\in [0.1,1]$ in steps of $0.1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prob = np.linspace(0,1,10)\n",
    "err_q_mean_c = []\n",
    "err_q_std_c = []\n",
    "success_q_c = []\n",
    "\n",
    "for q in prob:\n",
    "    errors = []\n",
    "    correct = 0\n",
    "    for j in range(100):\n",
    "        idx = np.random.randint(10)\n",
    "        yi = corrupt_uniform(xi[idx], q)\n",
    "        sys = montecarlo(J, yi, 25, 500)\n",
    "        wrong_pixels = error_im(xi[idx],sys)\n",
    "        assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "        if idx == assigned_pattern: correct += 1\n",
    "        errors.append(wrong_pixels) \n",
    "        \n",
    "    correct /= 100\n",
    "    errors = np.array(errors)\n",
    "    err_q_mean_c.append( errors.mean() )\n",
    "    err_q_std_c.append( errors.std() )\n",
    "    success_q_c.append(correct)\n",
    "    \n",
    "fig, ax = plt.subplots(1,2,figsize=(12,6))\n",
    "\n",
    "ax[0].set_title('Errors as function of the flipping probability')\n",
    "ax[0].set_xlabel('Flipping probability q')\n",
    "ax[0].set_ylabel('Average error')\n",
    "ax[0].plot(prob, err_q_mean_c, '--bo', label='Errors')\n",
    "ax[0].errorbar(prob,err_q_mean_c, yerr=err_q_std_c, ecolor='blue',fmt='none')\n",
    "ax[0].legend()\n",
    "\n",
    "ax[1].set_title('Probability of success as function of the flipping probabiity')\n",
    "ax[1].set_xlabel('Flipping probability q')\n",
    "ax[1].set_ylabel('Probability of success')\n",
    "ax[1].plot(prob, success_q_c, '--bo', label='Data')\n",
    "ax[1].legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\".\\Images\\prob_MF_C.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We clearly see that, even if the error is still acceptable, the maximum value of the noise that we can accept to have good performances is $q=0.2$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Non Mean Field Montecarlo\n",
    "\n",
    "Up to now we used only the MF version, where all the spins interacts with each other. We will now use a version of the algorithm where the spins interacts only within a small range, indicated with $R$. <br>\n",
    "We will not repeat the analysis of the dependance on temperature, and so we will use $\\beta=25$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The error of the algorithm is 0.030000\n",
      "The algorithm recognised the pattern 3 and the correct pattern is 3\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "xi = random_patterns(N,p)\n",
    "J = R_coupling(xi,N,3)\n",
    "\n",
    "idx = 3\n",
    "\n",
    "sys = montecarlo(J,xi[idx], 25, 1000)\n",
    "wrong_pixels = error_im(xi[idx],sys)\n",
    "assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(1,2, figsize = (10,6))\n",
    "ax[0].set_title('Pattern')\n",
    "ax[0].imshow(xi[idx].reshape(L,L), cmap='Greys')\n",
    "ax[1].set_title('Finishing configuration')\n",
    "ax[1].imshow(sys.reshape(L,L), cmap='Greys')\n",
    "print('The error of the algorithm is %f' %(wrong_pixels))\n",
    "print('The algorithm recognised the pattern %i and the correct pattern is %i' %(assigned_pattern,idx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stability for the Non Mean Field Montecarlo\n",
    "\n",
    "In this section we study the stability of the algorithm as a function of the number of neighbors, $R = [1,2,3,4,5]$ and two different number of iterations, $t=[500,1000]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "R = [1, 2, 3, 4, 5]\n",
    "err_r_mean_c = []\n",
    "err_r_std_c = []\n",
    "success_r_c = []\n",
    "\n",
    "for r in R:\n",
    "    J = R_coupling(xi,N,r)\n",
    "    errors = []\n",
    "    correct = 0\n",
    "    for j in range(100):\n",
    "        idx = np.random.randint(10)\n",
    "        sys = montecarlo(J, xi[idx], 25, 500)\n",
    "        wrong_pixels = error_im(xi[idx],sys)\n",
    "        assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "        if idx == assigned_pattern: correct += 1\n",
    "        errors.append(wrong_pixels) \n",
    "        \n",
    "    correct /= 100\n",
    "    errors = np.array(errors)\n",
    "    err_r_mean_c.append( errors.mean() )\n",
    "    err_r_std_c.append( errors.std() )\n",
    "    success_r_c.append(correct)\n",
    "    \n",
    "err_r1_mean_c = []\n",
    "err_r1_std_c = []\n",
    "success_r1_c = []\n",
    "\n",
    "for r in R:\n",
    "    J = R_coupling(xi,N,r)\n",
    "    errors = []\n",
    "    correct = 0\n",
    "    for j in range(100):\n",
    "        idx = np.random.randint(10)\n",
    "        sys = montecarlo(J, xi[idx], 25, 1000)\n",
    "        wrong_pixels = error_im(xi[idx],sys)\n",
    "        assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "        if idx == assigned_pattern: correct += 1\n",
    "        errors.append(wrong_pixels) \n",
    "        \n",
    "    correct /= 100\n",
    "    errors = np.array(errors)\n",
    "    err_r1_mean_c.append( errors.mean() )\n",
    "    err_r1_std_c.append( errors.std() )\n",
    "    success_r1_c.append(correct)\n",
    "    \n",
    "fig, ax = plt.subplots(1,2,figsize=(12,6))\n",
    "\n",
    "ax[0].set_title('Errors as function of nearest neighbors')\n",
    "ax[0].set_xlabel('Number of nearest neighbors R')\n",
    "ax[0].set_ylabel('Average error')\n",
    "ax[0].plot(R, err_r_mean_c, '--bo', label='Error with t=500')\n",
    "ax[0].errorbar(R,err_r_mean_c, yerr=err_r_std_c,ecolor='blue',fmt='none')\n",
    "ax[0].plot(R, err_r1_mean_c, '--go', label='Error with t=1000')\n",
    "ax[0].errorbar(R,err_r1_mean_c, yerr=err_r1_std_c,ecolor='green',fmt='none')\n",
    "ax[0].legend()\n",
    "\n",
    "ax[1].set_title('Probability of success as function of nearest neighbors')\n",
    "ax[1].set_xlabel('Number of nearest neighbors R')\n",
    "ax[1].set_ylabel('Probability of success')\n",
    "ax[1].plot(R, success_r_c, '--bo', label='Data with t=500')\n",
    "ax[1].plot(R, success_r1_c, '--go', label='Data with t=1000')\n",
    "ax[1].legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\".\\Images\\NN_NMFM.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As expected, increasing the number of nearest neighbors enhances the performances of the algorithm, and makes the NMF model approach to the MF one.\n",
    "\n",
    "Actually, the error and the probability of success with $R=5$ are even better than the ones obtained thanks to the MF model. Another important thing to notice is that the algorithm for different $t$ converges to the same value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Corruption with noise\n",
    "\n",
    "We will see now how the noise affect the performances of the NMF Montecarlo method. This analysis is very interesting because we will see different behaviour between gaussian and uniform noise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uniform noise\n",
    "\n",
    "Here we analyse how different threshold probabilities $q$ affect the performances, with $\\beta=25$, $R=[3,5]$ and $t=1000$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The error of the algorithm is 0.030000\n",
      "The algorithm recognised the pattern 3 and the correct pattern is 3\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "idx = 3\n",
    "yi = corrupt_uniform(xi[idx], 0.2)\n",
    "\n",
    "sys = montecarlo(J,yi, 25, 1000)\n",
    "\n",
    "wrong_pixels = error_im(xi[idx],sys)\n",
    "assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "fig, ax = plt.subplots(1,2, figsize = (10,6))\n",
    "ax[0].set_title('Pattern')\n",
    "ax[0].imshow(xi[idx].reshape(L,L), cmap='Greys')\n",
    "ax[1].set_title('Finishing configuration')\n",
    "ax[1].imshow(sys.reshape(L,L), cmap='Greys')\n",
    "print('The error of the algorithm is %f' %(wrong_pixels))\n",
    "print('The algorithm recognised the pattern %i and the correct pattern is %i' %(assigned_pattern,idx))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xi = random_patterns(N,p)\n",
    "prob = np.linspace(0,1,10)\n",
    "err_rq_mean_c = []\n",
    "err_rq_std_c = []\n",
    "success_rq_c = []\n",
    "\n",
    "# R = 3\n",
    "for q in prob:\n",
    "    J = R_coupling(xi,N,3)\n",
    "    errors = []\n",
    "    correct = 0\n",
    "    for j in range(100):\n",
    "        idx = np.random.randint(10)\n",
    "        yi = corrupt_uniform(xi[idx], q)\n",
    "        sys = montecarlo(J, yi, 25, 1000)\n",
    "        wrong_pixels = error_im(xi[idx],sys)\n",
    "        assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "        if idx == assigned_pattern: correct += 1\n",
    "        errors.append(wrong_pixels) \n",
    "        \n",
    "    correct /= 100\n",
    "    errors = np.array(errors)\n",
    "    err_rq_mean_c.append( errors.mean() )\n",
    "    err_rq_std_c.append( errors.std() )\n",
    "    success_rq_c.append(correct)\n",
    "    \n",
    "err_rq1_mean_c = []\n",
    "err_rq1_std_c = []\n",
    "success_rq1_c = []\n",
    "\n",
    "# R = 5\n",
    "for q in prob:\n",
    "    J = R_coupling(xi,N,5)\n",
    "    errors = []\n",
    "    correct = 0\n",
    "    for j in range(100):\n",
    "        idx = np.random.randint(10)\n",
    "        yi = corrupt_uniform(xi[idx], q)\n",
    "        sys = montecarlo(J, yi, 25, 1000)\n",
    "        wrong_pixels = error_im(xi[idx],sys)\n",
    "        assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "        if idx == assigned_pattern: correct += 1\n",
    "        errors.append(wrong_pixels) \n",
    "        \n",
    "    correct /= 100\n",
    "    errors = np.array(errors)\n",
    "    err_rq1_mean_c.append( errors.mean() )\n",
    "    err_rq1_std_c.append( errors.std() )\n",
    "    success_rq1_c.append(correct)\n",
    "    \n",
    "fig, ax = plt.subplots(1,2,figsize=(12,6))\n",
    "\n",
    "ax[0].set_title('Errors as function of flipping probability')\n",
    "ax[0].set_xlabel('Flipping probability q')\n",
    "ax[0].set_ylabel('Average error')\n",
    "ax[0].plot(prob, err_rq_mean_c, '--bo', label='Error with R=3')\n",
    "ax[0].errorbar(prob,err_rq_mean_c, yerr=err_rq_std_c,ecolor='blue',fmt='none')\n",
    "ax[0].plot(prob, err_rq1_mean_c, '--go', label='Error with R=5')\n",
    "ax[0].errorbar(prob,err_rq1_mean_c, yerr=err_rq1_std_c,ecolor='green',fmt='none')\n",
    "ax[0].legend()\n",
    "\n",
    "ax[1].set_title('Probability of success as function of flipping probability')\n",
    "ax[1].set_xlabel('Flipping probability q')\n",
    "ax[1].set_ylabel('Probability of success')\n",
    "ax[1].plot(prob, success_rq_c, '--bo', label='Data with R=3')\n",
    "ax[1].plot(prob, success_rq1_c, '--go', label='Data with R=5')\n",
    "ax[1].legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\".\\Images\\prob_NMFM_C.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The behaviour outlined in the graphs is similar to the one of the MF, especially with the bigger number of neighbors ($R=5$).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gaussian noise\n",
    "\n",
    "We corrupted the original patterns with a gaussian distribution; in this section we use $h\\in[0,1]$ with steps of $0.1$ as gaussian heights, and the different centroid positions (corner or center of the grid).\n",
    "\n",
    "We study the behaviour of the corrupted system with $\\beta=25$, $R=5$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xi = random_patterns(N,p)\n",
    "heights = np.linspace(0,1,10)\n",
    "err_rh_mean_c = []\n",
    "err_rh_std_c = []\n",
    "success_rh_c = []\n",
    "\n",
    "for h in heights:\n",
    "    J = R_coupling(xi,N,5)\n",
    "    errors = []\n",
    "    correct = 0\n",
    "    for j in range(100):\n",
    "        idx = np.random.randint(10)\n",
    "        yi = corrupt_norm(xi[idx], np.array([0,0]), h)\n",
    "        sys = montecarlo(J, yi, 25, 1000)\n",
    "        wrong_pixels = error_im(xi[idx],sys)\n",
    "        assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "        if idx == assigned_pattern: correct += 1\n",
    "        errors.append(wrong_pixels) \n",
    "        \n",
    "    correct /= 100\n",
    "    errors = np.array(errors)\n",
    "    err_rh_mean_c.append( errors.mean() )\n",
    "    err_rh_std_c.append( errors.std() )\n",
    "    success_rh_c.append(correct)\n",
    "    \n",
    "err_rh1_mean_c = []\n",
    "err_rh1_std_c = []\n",
    "success_rh1_c = []\n",
    "for h in heights:\n",
    "    J = R_coupling(xi,N,5)\n",
    "    errors = []\n",
    "    correct = 0\n",
    "    for j in range(100):\n",
    "        idx = np.random.randint(10)\n",
    "        yi = corrupt_norm(xi[idx], np.array([L//2, L//2]), h)\n",
    "        sys = montecarlo(J, yi, 25, 1000)\n",
    "        wrong_pixels = error_im(xi[idx],sys)\n",
    "        assigned_pattern = assign_pattern(xi,sys)\n",
    "\n",
    "        if idx == assigned_pattern: correct += 1\n",
    "        errors.append(wrong_pixels) \n",
    "        \n",
    "    correct /= 100\n",
    "    errors = np.array(errors)\n",
    "    err_rh1_mean_c.append( errors.mean() )\n",
    "    err_rh1_std_c.append( errors.std() )\n",
    "    success_rh1_c.append(correct)\n",
    "\n",
    "fig, ax = plt.subplots(1,2,figsize=(12,6))\n",
    "\n",
    "ax[0].set_title('Errors as function of the height of the gaussian')\n",
    "ax[0].set_xlabel('Gaussian height h')\n",
    "ax[0].set_ylabel('Average error')\n",
    "ax[0].plot(heights, err_rh_mean_c, '--bo', label='Error with centroid in [0,0]')\n",
    "ax[0].errorbar(heights,err_rh_mean_c, yerr=err_rh_std_c,ecolor='blue',fmt='none')\n",
    "ax[0].plot(heights, err_rh1_mean_c, '--go', label='Error with centroid in [L/2,L/2]')\n",
    "ax[0].errorbar(heights,err_rh1_mean_c, yerr=err_rh1_std_c,ecolor='green',fmt='none')\n",
    "ax[0].legend()\n",
    "\n",
    "ax[1].set_title('Probability of success as function of the height of the gaussian')\n",
    "ax[1].set_xlabel('Gaussian height h')\n",
    "ax[1].set_ylabel('Probability of success')\n",
    "ax[1].plot(heights, success_rh_c, '--bo', label='Data with centroid in [0,0]')\n",
    "ax[1].plot(heights, success_rh1_c, '--go', label='Data with centroid in [L/2,L/2]')\n",
    "ax[1].legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\".\\Images\\gauss_MNMF_C.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The probability of success decrease with the increase of the height of the gaussian if the centroid is in the middle of the grid: despite this, there is still a 60% of probability of recognising the correct pattern even in the worst case scenario ($h=1$).\n",
    "\n",
    "On the other hand, the gaussian height does not affect too much the performance of the algorithm if the distribution is centered in one of the corners. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "## Time analisys\n",
    "\n",
    "The aim of this section is to quantify the time implementation of the Montecarlo methods, both MF and not MF, in function of the size of the system N."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lenght = np.array([5, 10, 15, 20, 25, 28, 30])\n",
    "size = lenght**2\n",
    "time_n_mean = []\n",
    "time_n_std = []\n",
    "for n in size:\n",
    "    xi = random_patterns(n,p)\n",
    "    J =  MF_coupling(xi,n)\n",
    "    time1 = []\n",
    "    for j in range(50):\n",
    "        start = time.time()\n",
    "        idx = np.random.randint(10)\n",
    "        sys = montecarlo(J, xi[idx], 25, 1000)\n",
    "        end = time.time()\n",
    "        time1.append(end-start)\n",
    "        \n",
    "    time1 = np.array(time1)\n",
    "    time_n_mean.append( time1.mean() )\n",
    "    time_n_std.append( time1.std() )\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(12,6))\n",
    "\n",
    "ax.set_title('Time implementation as function of the size of the system')\n",
    "ax.set_xlabel('Size of the system L')\n",
    "ax.set_ylabel('Average time implementation')\n",
    "ax.plot(lenght, time_n_mean, '--bo', label='Montecarlo')\n",
    "ax.errorbar(lenght,time_n_mean, yerr=time_n_std,ecolor='blue',fmt='none')\n",
    "ax.plot(np.arange(10,28,4), times[0], '--ro', label='Deterministic Hopfield')\n",
    "ax.legend()\n",
    "\n",
    "times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\".\\Images\\m_time.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparing the deterministic model and the Montecarlo one, we can see that the time implementation is way more efficient than the deterministic one, as we expected."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Distinguish criteria of similar patterns\n",
    "\n",
    "Finally, after discussing the performances and the advantages of the Hopfield model, we try to understand its limits.\n",
    "Therefore, in this section we will study when and why the algorithm cannot distinguish some kind of patterns.\n",
    "\n",
    "We define a set of $\\textit{p similar patterns}$ as a group of $p$ patterns which cannot be distinguished by the Hopfield model.\n",
    "\n",
    "Our first guess is that the similarity between two patterns is inversely proportional to the distance among the nearest different pixels.\n",
    "Hence, we define a new function, $w_{sim}$, based on this hypothesis, and try to implement the model on the two most similar patterns so defined: a chessboard configuration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we work with this parameters \n",
    "L = 10\n",
    "N = L**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def w_sim(sys11, sys22, alpha): \n",
    "    sys1 = deepcopy(sys11)\n",
    "    sys2 = deepcopy(sys22)\n",
    "    N = sys1.shape[0]\n",
    "    L = int(np.sqrt(N))\n",
    "    sys1 = sys1.reshape(L,L)\n",
    "    sys2 = sys2.reshape(L,L)\n",
    "    wrong1 = [] #wrong black pixels in sys1\n",
    "    wrong2 = [] # in sys2\n",
    "    min_dist = [] \n",
    "    for i in range(L):\n",
    "        for j in range(L):\n",
    "            if sys1[i][j] == sys2[i][j]: continue\n",
    "            elif sys1[i][j]== 1 : # if black in sys1\n",
    "                wrong1.append( np.array([i,j]) )\n",
    "            elif sys2[i][j]== 1: # if black in sys2\n",
    "                wrong2.append( np.array([i,j]) )\n",
    "    # compute distances between wrong pixels of the two systems\n",
    "    for i in wrong1:\n",
    "        distances = []\n",
    "        for j in wrong2:\n",
    "            if np.linalg.norm(i-j) !=0 :\n",
    "                distances.append( np.linalg.norm(i-j) )\n",
    "        min_dist.append( np.array(distances).min() )\n",
    "    min_dist = np.array(min_dist)\n",
    "    err =  (1/(min_dist)**alpha).sum()\n",
    "    err = err/((N+1)//2) #normalization due to worst case scenario (a chessboard with more black cells)\n",
    "    return err\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Similarity between the two patterns:  1.0\n"
     ]
    }
   ],
   "source": [
    "# chessboard\n",
    "chess = [np.zeros(N)-1 for j in range(2)]\n",
    "c = np.array([np.zeros((L,L))-1 for j in range(2)])\n",
    "\n",
    "for i in range(2):\n",
    "    if i == 0:\n",
    "        c[i][::2, ::2] = 1\n",
    "        c[i][1::2, 1::2] = 1\n",
    "    else:\n",
    "        c[i][1::2, ::2] = 1\n",
    "        c[i][::2, 1::2] = 1\n",
    "    chess[i] = c[i].reshape(1,N)[0]\n",
    "\n",
    "err_chess = []   \n",
    "\n",
    "fig, ax = plt.subplots(1, 2, figsize=(8,4))\n",
    "\n",
    "ax[0].set_title('Pattern 1')\n",
    "ax[0].imshow(chess[0].reshape(L,L),cmap='Greys')\n",
    "ax[1].set_title('Pattern 2')\n",
    "ax[1].imshow(chess[1].reshape(L,L),cmap='Greys')\n",
    "plt.show()    \n",
    "    \n",
    "for i in chess:    \n",
    "    err_chess.append(w_sim(chess[0],i,2))\n",
    "\n",
    "print(\"Similarity between the two patterns: \", err_chess[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The error of the algorithm using MF = 0 is 0.000000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 0\n",
      "\n",
      "The error of the algorithm using MF = 1 is 0.000000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 0\n",
      "\n",
      "The error of the algorithm using MF = 0 is 0.000000\n",
      "The algorithm recognised the pattern 1 and the correct pattern is 1\n",
      "\n",
      "The error of the algorithm using MF = 1 is 0.000000\n",
      "The algorithm recognised the pattern 1 and the correct pattern is 1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# we try our algorithm to see if the two chessboards are distinguishable.\n",
    "\n",
    "chess = np.array(chess)\n",
    "ind = [0,1]\n",
    "\n",
    "for idx in ind: \n",
    "    for MF in range(2):\n",
    "        if MF: J = MF_coupling(chess,N)\n",
    "        else: J = R_coupling(chess,N,R)\n",
    "\n",
    "        sys = deepcopy(chess[idx])\n",
    "\n",
    "        sys = montecarlo(J, sys, 25, 500)\n",
    "        wrong_pixels = error_im(chess[idx],sys)\n",
    "        assigned_pattern = assign_pattern(chess,sys)\n",
    "\n",
    "#         fig, ax = plt.subplots(1,2, figsize = (8,5))\n",
    "#         ax[0].set_title('Pattern')\n",
    "#         ax[0].imshow(chess[idx].reshape(L,L), cmap='Greys')\n",
    "#         ax[1].set_title('Finishing configuration')\n",
    "#         ax[1].imshow(sys.reshape(L,L), cmap='Greys')\n",
    "#         plt.show()\n",
    "        print('The error of the algorithm using MF = %i is %f' %(MF, wrong_pixels))\n",
    "        print('The algorithm recognised the pattern %i and the correct pattern is %i\\n' %(assigned_pattern,idx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On the contrary of what we thought, the distance criteria is not a good one to define similar patterns, as our algorithm can distinguish with no error the two chessboards. \n",
    "\n",
    "Hence, a new approach needs to be applied: an intuitive idea is that two patterns might be similar when they have only a few different pixels. As a consequence, we try with some regularly shaped patterns where the number of different pixels can be easily counted.\n",
    "\n",
    "In order to apply this idea, we choose some \"frames\" with shrinking size and some straight vertical lines moving along the grid and we perform the algorithm using them as patterns. Moreover we try our algorithm with random generated patterns with only $10$ black pixels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# frames\n",
    "frames = [np.zeros(N)-1 for j in range((L+1)//2)]\n",
    "\n",
    "for i in range((L+1)//2):\n",
    "    for j in range(N):\n",
    "        if j%L == i:\n",
    "            frames[i][j] = 1\n",
    "        if j%L == (L-i-1) :\n",
    "            frames[i][j] = 1\n",
    "        if j//L == i:\n",
    "            frames[i][j] = 1\n",
    "        if j//L == (L-i-1) :\n",
    "            frames[i][j] = 1\n",
    "    for k in range(i):\n",
    "        for j in range(N):\n",
    "            if j%L == k:\n",
    "                frames[i][j] = -1\n",
    "            if j%L == (L-k-1) :\n",
    "                frames[i][j] = -1\n",
    "            if j//L == k:\n",
    "                frames[i][j] = -1\n",
    "            if j//L == (L-k-1) :\n",
    "                frames[i][j] = -1\n",
    "\n",
    "fig, ax = plt.subplots(1, (L+1)//2 , figsize=(16,6))\n",
    "\n",
    "for i in range((L+1)//2):\n",
    "    ax[i].set_title('Pattern %i' %(i+1))\n",
    "    ax[i].imshow(frames[i].reshape(L,L),cmap='Greys')\n",
    "plt.show()    \n",
    "\n",
    "frames = np.array(frames)\n",
    "ind = np.arange(len(frames))\n",
    "\n",
    "images = [[],[]]\n",
    "\n",
    "for idx in ind: \n",
    "    for MF in range(2):\n",
    "        if MF: J = MF_coupling(frames,N)\n",
    "        else: J = R_coupling(frames,N,R)\n",
    "\n",
    "        sys = deepcopy(frames[idx])\n",
    "\n",
    "        sys = montecarlo(J, sys, 25, 500)\n",
    "        wrong_pixels = error_im(frames[idx],sys)\n",
    "        assigned_pattern = assign_pattern(frames,sys)\n",
    "        images[MF].append(sys)\n",
    "        \n",
    "#         print('The error of the algorithm using MF = %i is %f' %(MF, wrong_pixels))\n",
    "#         print('The algorithm recognised the pattern %i and the correct pattern is %i\\n' %(assigned_pattern,idx))\n",
    "\n",
    "fig, ax = plt.subplots(2, (L+1)//2 , figsize=(16,8))\n",
    "\n",
    "for i in range((L+1)//2):\n",
    "    ax[0][i].set_title('Pattern %i, Non Mean Field' %(i+1))\n",
    "    ax[0][i].imshow(images[0][i].reshape(L,L),cmap='Greys')\n",
    "    ax[1][i].set_title('Pattern %i, Mean Field' %(i+1))\n",
    "    ax[1][i].imshow(images[1][i].reshape(L,L),cmap='Greys')\n",
    "plt.show() \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1584x720 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The error of the algorithm using MF = 0 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 0\n",
      "\n",
      "The error of the algorithm using MF = 1 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 0\n",
      "\n",
      "The error of the algorithm using MF = 0 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 1\n",
      "\n",
      "The error of the algorithm using MF = 1 is 0.090000\n",
      "The algorithm recognised the pattern 1 and the correct pattern is 1\n",
      "\n",
      "The error of the algorithm using MF = 0 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 2\n",
      "\n",
      "The error of the algorithm using MF = 1 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 2\n",
      "\n",
      "The error of the algorithm using MF = 0 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 3\n",
      "\n",
      "The error of the algorithm using MF = 1 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 3\n",
      "\n",
      "The error of the algorithm using MF = 0 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 4\n",
      "\n",
      "The error of the algorithm using MF = 1 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 4\n",
      "\n",
      "The error of the algorithm using MF = 0 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 5\n",
      "\n",
      "The error of the algorithm using MF = 1 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 5\n",
      "\n",
      "The error of the algorithm using MF = 0 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 6\n",
      "\n",
      "The error of the algorithm using MF = 1 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 6\n",
      "\n",
      "The error of the algorithm using MF = 0 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 7\n",
      "\n",
      "The error of the algorithm using MF = 1 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 7\n",
      "\n",
      "The error of the algorithm using MF = 0 is 0.080000\n",
      "The algorithm recognised the pattern 8 and the correct pattern is 8\n",
      "\n",
      "The error of the algorithm using MF = 1 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 8\n",
      "\n",
      "The error of the algorithm using MF = 0 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 9\n",
      "\n",
      "The error of the algorithm using MF = 1 is 0.100000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 9\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# straight verical lines patterns\n",
    "\n",
    "patt = [np.zeros(N)-1 for j in range(L)]\n",
    "for i in range(L):\n",
    "    for j in range(L):\n",
    "        patt[i][i+L*j]=1\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(2, int(len(patt)/2), figsize=(22,10))\n",
    "\n",
    "for i in range(int(len(patt)/2)):\n",
    "    ax[0][i].set_title('Pattern %i' %(i+1))\n",
    "    ax[0][i].imshow(patt[i].reshape(L,L),cmap='Greys')\n",
    "    ax[1][i].set_title('Pattern %i' %(i+int(len(patt)/2)+1))\n",
    "    ax[1][i].imshow(patt[i+int(len(patt)/2)].reshape(L,L),cmap='Greys')\n",
    "plt.show()\n",
    "\n",
    "# we try our algorithm to see if the patterns are distinguishable.\n",
    "\n",
    "patt = np.array(patt)\n",
    "ind = np.arange(len(patt))\n",
    "\n",
    "for idx in ind: \n",
    "    for MF in range(2):\n",
    "        if MF: J = MF_coupling(patt,N)\n",
    "        else: J = R_coupling(patt,N,R)\n",
    "\n",
    "        sys = deepcopy(patt[idx])\n",
    "\n",
    "        sys = montecarlo(J, sys, 25, 500)\n",
    "        wrong_pixels = error_im(patt[idx],sys)\n",
    "        assigned_pattern = assign_pattern(patt,sys)\n",
    "\n",
    "#         fig, ax = plt.subplots(1,2, figsize = (8,5))\n",
    "#         ax[0].set_title('Pattern')\n",
    "#         ax[0].imshow(patt[idx].reshape(L,L), cmap='Greys')\n",
    "#         ax[1].set_title('Finishing configuration')\n",
    "#         ax[1].imshow(sys.reshape(L,L), cmap='Greys')\n",
    "#         plt.show()\n",
    "        print('The error of the algorithm using MF = %i is %f' %(MF, wrong_pixels))\n",
    "        print('The algorithm recognised the pattern %i and the correct pattern is %i\\n' %(assigned_pattern,idx))\n",
    "        \n",
    "fig, ax = plt.subplots(1,2, figsize = (8,5))\n",
    "ax[0].set_title('Pattern')\n",
    "ax[0].imshow(patt[-1].reshape(L,L), cmap='Greys')\n",
    "ax[1].set_title('Finishing configuration')\n",
    "ax[1].imshow(sys.reshape(L,L), cmap='Greys')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdoAAAD6CAYAAAAGP4YtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAATVUlEQVR4nO3de9BtdV3H8fcHjoiAiMXJOoAezFLJqZAn81JWYg6Yt5qmMLVkMrp5zTLtojaZTo15S6dC0C6Ql9AcKrw1ikUX8jmAk3jQELkczjEeJBXJIvLbH2s9tc/Dc55nH87+7bX28f2aeWaevfbaa3/35bs++7fW2munqpAkSW0cMnQBkiQdzAxaSZIaMmglSWrIoJUkqSGDVpKkhgxaSZIaMmglLawk903ypSSHzmreJM9McskG1783yU/clXqHkOSBSS5PcmuS5yb5gyS/PnRdqxbt+bwrtgxdgO4sybXAfYD/AW4DLgKeU1Vf2uA23wucV1XHT0x7OfCAqnp6y3ql1tb0xKpvrqrrgaOmWcb+zLvJck4/0GXM2YuAi6vq5KELWW+dtIDP535zRDteT6yqo4CHAt8B/Nq8C0jiBzGNyROr6qiJv91DF7Qg7gdc2fpOXF/sm0E7clV1I/Be4CFJzkyys98EdE2SnwZIcmQ/z7Z+09iXkvwY8CvAj/aXP9bPe68k5ybZk+TGJK9Y3ZTWbzL7+ySvTXIL8PLVzWhJXp3k35N8JslB/wlUiyHJ9iS1upJPcnGS3+zfx7cm+UCSY/cx7zP7Prq1f18/bc2y133P9/fxrIll7LM/kpyY5G/7+/ibJG9Kct4Gj+fJSa5I8sUkn05yWj99W5ILk9yS5OokPzVxm5cneWeSP+nv58okS/11HwK+D3hjvx745iR/lOQVE7d/Ub8+2J3kWf1z9IC1j3Xy8U5criQ/n+RfgX/tp70+yQ39Y9iR5Lv76aex/jpp8vk8JMmvJbkuyU39Y7rXmtfvJ5Jcn+TmJL+66ZtkBAzakUtyAvB44HLgJuAJwNHAmcBrkzy0qm4DTgd2T3za/zPglcA7+svf1i/yj4E7gAcAJwOPA541cZffCVwDfB3wWxPTPgkcC/wOcG6StHrM0gH6Mbr++DrgMOAX187Qfzh9A3B6Vd0TeCRwxcQs+/Oe32jePwP+Gfha4OXAM/ZVdJKHAX8C/BJwDPBo4Nr+6rcBu4BtwA8Dr0xy6sTNnwS8vb/dhcAbAarqMcDfAc/u1wOfWnOfpwG/ADyWbp3wPfuqbwNPoXsOTuovfxT4duBr6B7/nyc5vKrex/rrpEnP7P++D7g/3ab+N66Z57uABwKnAi9N8uC7UPNcGbTj9Z4knwcuAT4CvLKq/rqqPl2djwAfAL572gUmuQ9dID+/qm6rqpuA1wJnTMy2u6p+r6ruqKov99Ouq6o3V9X/0AX1N9DtL5Pm6T1JPt//vWeD+d5aVZ/q37/vpFvpr+crdFuK7lFVe6pqcvPq/rzn1503yX3pdvu8tKpur6pL6EJwX34SeEtVfbCqvlJVN1bVVf2H7e8Cfrmq/rOqrgDOYe/QvqSqLupr+FNgvRBbz4/QPV9XVtV/AL8x5e0mvaqqblldX1TVeVX1uX4d8rvA3emCcRpPA15TVdf0x6S8BDgje2+W/o2q+nJVfQz4GNM/1sEYtOP1lKo6pqruV1U/V1VfTnJ6kn/qNx99nm6ke+x+LPN+wN2APasrLOAP6T75r7phndt9dvWfvhlhBgeVSPtptSeOqaqnbDDfZyf+/w/Wea/2W4F+FPgZun746yQPWm8ZU7zn9zXvNuCWiWmwfn+tOgH49DrTV5dz68S064Dj1quB7jEfnun2mW5bU9NG9e3LXrdJ8sJ0u7i+0K9j7sX066ltdI9t1XV0B+1OfsjZ9PUdG4N2QSS5O/Au4NXAfarqGLqjkVc3Ua33M0xrp90A/Bdw7MQK6+iq+pYNbiMdlKrq/VX1/XQj0KuAN8/4LvYAX5PkiIlpJ2ww/w3AN64zfXe/nHtOTLsvcOOBl8ge4PiJy2vruw2YrP/r11nG/60z+v2xv0w3Ur53v576AhuvpybtphsQrLov3a6uf9vkdqNm0C6Ow+g2wawAd/QHXDxu4vp/A7529cCBiWnbkxwCUFV76DY3/26So/sDD74xyV3ZLyMtrCT3SfKkfl/tfwFfYu+vDh2wqroOWKY7qPCwJI8AnrjBTc4Fzkxyat+bxyV5UFXdAPwD8Kokhyf5VrrNzOfPoMx39vf54P4DwUvXXH8F8ENJjugPkPrJTZZ3T7pgXAG2JHkp3TElq/ZaJ63jbcAL0h1EdhT/v0/3jv17WONi0C6IfrPRc+ka49/pDvi4cOL6q+jepNf0m4W3AX/eX/25JJf1//84XWh/ol/OBXSf6KWvJocAL6QbQd1CdxDQzzW4n6cBjwA+B7wCeAddsN9JVf0z/UGOdKPAj/D/o7unAtv7ev8CeFlVffBAi6uq99IdFPZh4GrgH/urVmt8LXA7XUD+MZuH+/vpvgHxKbrNvv/J3puW11snTXoL3T7mvwU+09/+OdM/onGKP/wuSfOR5B3AVVX1sqFrWU9/BO/Hgbsv+ihyTBzRSlIjSb6j3z1zSP9VmicDGx0xPXdJfrDftH1v4LeBvzRkZ8uglaR2vh64mG4f8BuAn62qywet6M5+mm6f6qfp9lP/7LDlHHzcdCxJUkOOaCVJasiglSSpoSa/tnDsscfW9u3bWyx6Znbs2DHT5Z1yyikzXZ4Oftdeey0333zzqM8ZvQi9LI3Bjh07bq6qretd1yRot2/fzvLycotFz8ysz4k/9ser8VlaWhq6hE0tQi9LY5Dkun1d56ZjSZIaMmglSWrIoJUkqSGDVpKkhqYK2iSnJflkkquTvLh1UZLasJel+ds0aJMcCrwJOB04CXhqkpNaFyZptuxlaRjTjGgfBlxdVddU1e3A2+lOjC1psdjL0gCmCdrj2Pv3BHf10yQtFntZGsA0QbvemR3u9EsESc5KspxkeWVl5cArkzRr9rI0gGmCdhdwwsTl44Hda2eqqrOraqmqlrZuXfcsVJKGZS9LA5gmaD8KfFOSE5McBpwBXNi2LEkN2MvSADY913FV3ZHk2cD7gUOBt1TVlc0rkzRT9rI0jKl+VKCqLgIualyLpMbsZWn+PDOUJEkNGbSSJDVk0EqS1JBBK0lSQwatJEkNTXXU8f7asWMHyXonoblrqu508prRLXOWj7eFFs+hpM3Net1gLy8eR7SSJDVk0EqS1JBBK0lSQwatJEkNGbSSJDVk0EqS1JBBK0lSQwatJEkNGbSSJDVk0EqS1JBBK0lSQwatJEkNGbSSJDVk0EqS1JBBK0lSQwatJEkNGbSSJDVk0EqS1JBBK0lSQwatJEkNbWmx0FNOOYXl5eUWix6tqhq6BEkj5LpBjmglSWrIoJUkqSGDVpKkhgxaSZIaMmglSWpo06BNckKSDyfZmeTKJM+bR2GSZsteloYxzdd77gBeWFWXJbknsCPJB6vqE41rkzRb9rI0gE1HtFW1p6ou6/+/FdgJHNe6MEmzZS9Lw9ivfbRJtgMnA5e2KEbSfNjL0vxMHbRJjgLeBTy/qr64zvVnJVlOsryysjLLGiXNkL0szddUQZvkbnSNeX5VvXu9earq7KpaqqqlrVu3zrJGSTNiL0vzN81RxwHOBXZW1WvalySpBXtZGsY0I9pHAc8AHpPkiv7v8Y3rkjR79rI0gE2/3lNVlwCZQy2SGrKXpWF4ZihJkhoyaCVJasiglSSpIYNWkqSGDFpJkhqa5kcFdBDovkI5W1U182VK0sHGEa0kSQ0ZtJIkNWTQSpLUkEErSVJDBq0kSQ0ZtJIkNWTQSpLUkEErSVJDBq0kSQ0ZtJIkNWTQSpLUkEErSVJDBq0kSQ0ZtJIkNWTQSpLUkEErSVJDBq0kSQ0ZtJIkNWTQSpLU0JahC9B8VNXQJUjSVyVHtJIkNWTQSpLUkEErSVJDBq0kSQ0ZtJIkNWTQSpLU0NRBm+TQJJcn+auWBUlqy16W5mt/RrTPA3a2KkTS3NjL0hxNFbRJjgd+ADinbTmSWrKXpfmbdkT7OuBFwFf2NUOSs5IsJ1leWVmZSXGSZs5eluZs06BN8gTgpqrasdF8VXV2VS1V1dLWrVtnVqCk2bCXpWFMM6J9FPCkJNcCbwcek+S8plVJasFelgawadBW1Uuq6viq2g6cAXyoqp7evDJJM2UvS8Pwe7SSJDW0Xz+TV1UXAxc3qUTS3NjL0vw4opUkqSGDVpKkhgxaSZIaMmglSWpovw6GkhZJkpkvs6pmvkxJBzdHtJIkNWTQSpLUkEErSVJDBq0kSQ0ZtJIkNWTQSpLUkEErSVJDBq0kSQ0ZtJIkNWTQSpLUkEErSVJDBq0kSQ0ZtJIkNWTQSpLUkEErSVJDBq0kSQ0ZtJIkNWTQSpLUkEErSVJDBq0kSQ1tGbqAaSSZ+TKraubL1IGZ9evsayxpDBzRSpLUkEErSVJDBq0kSQ0ZtJIkNWTQSpLU0FRBm+SYJBckuSrJziSPaF2YpNmzl6X5m/brPa8H3ldVP5zkMOCIhjVJasdeluZs06BNcjTwaOCZAFV1O3B727IkzZq9LA1jmk3H9wdWgLcmuTzJOUmObFyXpNmzl6UBTBO0W4CHAr9fVScDtwEvXjtTkrOSLCdZXllZmXGZkmbAXpYGME3Q7gJ2VdWl/eUL6Jp1L1V1dlUtVdXS1q1bZ1mjpNmwl6UBbBq0VfVZ4IYkD+wnnQp8omlVkmbOXpaGMe1Rx88Bzu+PUrwGOLNdSZIaspelOZsqaKvqCmCpcS2SGrOXpfnzzFCSJDVk0EqS1JBBK0lSQwatJEkNGbSSJDU07dd7BlVVQ5egOZj165xkpssD34uS9p8jWkmSGjJoJUlqyKCVJKkhg1aSpIYMWkmSGjJoJUlqyKCVJKkhg1aSpIYMWkmSGjJoJUlqyKCVJKkhg1aSpIYMWkmSGjJoJUlqyKCVJKkhg1aSpIYMWkmSGjJoJUlqyKCVJKmhLUMXILVSVUOXIEmOaCVJasmglSSpIYNWkqSGDFpJkhoyaCVJasiglSSpoamCNskLklyZ5ONJ3pbk8NaFSZo9e1mav02DNslxwHOBpap6CHAocEbrwiTNlr0sDWPaTcdbgHsk2QIcAexuV5Kkhuxlac42DdqquhF4NXA9sAf4QlV9YO18Sc5KspxkeWVlZfaVSjog9rI0jGk2Hd8beDJwIrANODLJ09fOV1VnV9VSVS1t3bp19pVKOiD2sjSMaTYdPxb4TFWtVNV/A+8GHtm2LEkN2MvSAKYJ2uuBhyc5IkmAU4GdbcuS1IC9LA1gmn20lwIXAJcB/9Lf5uzGdUmaMXtZGsZUP5NXVS8DXta4FkmN2cvS/HlmKEmSGjJoJUlqyKCVJKkhg1aSpIYMWkmSGprqqOODUfc1wtmpqpkuT5J0cHBEK0lSQwatJEkNGbSSJDVk0EqS1JBBK0lSQwatJEkNGbSSJDVk0EqS1JBBK0lSQwatJEkNGbSSJDVk0EqS1JBBK0lSQwatJEkNGbSSJDVk0EqS1JBBK0lSQwatJEkNGbSSJDWUqpr9QpMV4LopZj0WuHnmBczO2OuD8dc49vpguBrvV1VbB7jfqR1EvQzjr3Hs9YE1bmSf/dwkaKeVZLmqlgYrYBNjrw/GX+PY64PFqHHsFuE5HHuNY68PrPGuctOxJEkNGbSSJDU0dNCePfD9b2bs9cH4axx7fbAYNY7dIjyHY69x7PWBNd4lg+6jlSTpYDf0iFaSpIPaIEGb5LQkn0xydZIXD1HDRpKckOTDSXYmuTLJ84auaT1JDk1yeZK/GrqW9SQ5JskFSa7qn8tHDF3TWkle0L/GH0/ytiSHD13TohlzPy9KL4P9fKDG3MtzD9okhwJvAk4HTgKemuSkedexiTuAF1bVg4GHAz8/whoBngfsHLqIDbweeF9VPQj4NkZWa5LjgOcCS1X1EOBQ4Ixhq1osC9DPi9LLYD/fZWPv5SFGtA8Drq6qa6rqduDtwJMHqGOfqmpPVV3W/38r3RvquGGr2luS44EfAM4Zupb1JDkaeDRwLkBV3V5Vnx+2qnVtAe6RZAtwBLB74HoWzaj7eRF6GeznGRltLw8RtMcBN0xc3sUI3/irkmwHTgYuHbaSO3kd8CLgK0MXsg/3B1aAt/abw85JcuTQRU2qqhuBVwPXA3uAL1TVB4atauEsTD+PuJfBfj4gY+/lIYI260wb5aHPSY4C3gU8v6q+OHQ9q5I8AbipqnYMXcsGtgAPBX6/qk4GbgPGtv/u3nSjrxOBbcCRSZ4+bFULZyH6eay9DPbzLIy9l4cI2l3ACROXj2dEQ/xVSe5G15jnV9W7h65njUcBT0pyLd2musckOW/Yku5kF7CrqlZHDxfQNeqYPBb4TFWtVNV/A+8GHjlwTYtm9P088l4G+3kWRt3LQwTtR4FvSnJiksPodlhfOEAd+5QkdPsidlbVa4auZ62qeklVHV9V2+mevw9V1Wg+vQFU1WeBG5I8sJ90KvCJAUtaz/XAw5Mc0b/mpzKiAzwWxKj7eey9DPbzjIy6l7fM+w6r6o4kzwbeT3dk2Fuq6sp517GJRwHPAP4lyRX9tF+pqosGrGkRPQc4v18BXwOcOXA9e6mqS5NcAFxGd3Tq5YzwrDJjtgD9bC/Pzmj7eey97JmhJElqyDNDSZLUkEErSVJDBq0kSQ0ZtJIkNWTQSpLUkEErSVJDBq0kSQ0ZtJIkNfS/gQXjfs9ev0YAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 576x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# random\n",
    "diff = [np.zeros(N)-1 for j in range(5)]\n",
    "\n",
    "for i in range(5):\n",
    "    for j in range(L):\n",
    "        k = np.random.randint(0,N)\n",
    "        diff[i][k] = 1\n",
    "        \n",
    "\n",
    "diff = np.array(diff)\n",
    "ind = np.arange(len(diff))\n",
    "\n",
    "for idx in ind: \n",
    "    for MF in range(2):\n",
    "        if MF: J = MF_coupling(diff,N)\n",
    "        else: J = R_coupling(diff,N,R)\n",
    "\n",
    "        sys = deepcopy(diff[idx])\n",
    "\n",
    "        sys = deterministic_hopfield(sys,100)\n",
    "        wrong_pixels = error_im(diff[idx],sys)\n",
    "        assigned_pattern = assign_pattern(diff,sys)\n",
    "        if idx == 0 or idx == len(diff)-1:\n",
    "            fig, ax = plt.subplots(1,2, figsize = (8,5))\n",
    "            ax[0].set_title('Pattern')\n",
    "            ax[0].imshow(diff[idx].reshape(L,L), cmap='Greys')\n",
    "            ax[1].set_title('Finishing configuration')\n",
    "            ax[1].imshow(sys.reshape(L,L), cmap='Greys')\n",
    "        plt.show()\n",
    "#         print('The error of the algorithm is %f' %(wrong_pixels))\n",
    "#         print('The algorithm recognised the pattern %i and the correct pattern is %i' %(assigned_pattern,idx))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In these three examples we have seen that not all patterns are recognised:\n",
    "- the frames show a flaw in the recognition after a certain point;\n",
    "- the lines are never correctly classified: the system falls into the same minimum every time;\n",
    "- the random patterns also fall always in the same minimum, but it is different from the others.\n",
    "This behaviour is not impossible, as our system is frustrated: not all the spins can be in their optimal state and there is the possibility that stronger equilibria suppress the weaker ones.\n",
    "\n",
    "The first thing to do is to understand why that configuration is a minimum, since it is not one of the given patterns. \n",
    "\n",
    "Our guess is to look at the mean of the patterns, and indeed it proves to be the right one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1f3aa68f320>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x360 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1,4, figsize = (16,5))\n",
    "ax[0].set_title('Average over lines\\' patterns')\n",
    "ax[0].imshow(np.sign(patt.mean(axis=0)).reshape(L,L), cmap='Greys')\n",
    "ax[1].set_title('Average over frames\\' patterns')\n",
    "ax[1].imshow(np.sign(frames.mean(axis=0)).reshape(L,L), cmap='Greys')\n",
    "ax[2].set_title('Average over random patterns')\n",
    "ax[2].imshow(np.sign(diff.mean(axis=0)).reshape(L,L), cmap='Greys')\n",
    "ax[3].set_title('Average over chessboards\\' patterns')\n",
    "ax[3].imshow(np.sign(chess.mean(axis=0)).reshape(L,L), cmap='Greys')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to find a quantitative way to describe this similarity and to know if $p$ patterns are similar without running the algorithm. Since we are talking about a physical system, the proper parameter to define the similarity can be the energy. \n",
    "\n",
    "Our hypothesis is that if the average of the possible $p$ patterns has the lowest energy, then the set of considered $p$ patterns is similar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "J_fr = R_coupling(frames, N, R)\n",
    "J_patt = R_coupling(patt, N, R)\n",
    "J_diff = R_coupling(diff, N, R)\n",
    "J_chess = R_coupling(chess, N, R)\n",
    "\n",
    "energy_fr = []\n",
    "energy_patt = []\n",
    "energy_diff = []\n",
    "energy_chess = []\n",
    "\n",
    "for i in frames:\n",
    "    energy_fr.append( H(J_fr, i) )\n",
    "energy_fr.append(H(J_fr,np.sign(frames.mean(axis=0)) ) )\n",
    "\n",
    "for i in patt:\n",
    "    energy_patt.append( H(J_patt, i) )\n",
    "energy_patt.append(H(J_patt,np.sign(patt.mean(axis=0)) ) )\n",
    "\n",
    "for i in diff:\n",
    "    energy_diff.append( H(J_diff, i) )\n",
    "energy_diff.append(H(J_diff,np.sign(diff.mean(axis=0)) ) )\n",
    "\n",
    "for i in chess:\n",
    "    energy_chess.append( H(J_chess, i) )\n",
    "energy_chess.append(H(J_chess,np.sign(chess.mean(axis=0)) ) )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Number of pattern')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1,4, figsize = (20,4))\n",
    "\n",
    "ax[0].set_title('Average over lines\\' patterns')\n",
    "ax[0].scatter(np.arange(10),energy_patt[:10], marker='x', c='r')\n",
    "ax[0].scatter(10, energy_patt[10], marker='o', c='b')\n",
    "ax[0].set_ylabel(\"Energy\")\n",
    "ax[0].set_xlabel(\"Number of pattern\")\n",
    "\n",
    "ax[1].set_title('Average over frames\\' patterns')\n",
    "ax[1].scatter(np.arange(5),energy_fr[:5], marker='x', c='r')\n",
    "ax[1].scatter(5, energy_fr[5], marker='o', c='b')\n",
    "ax[1].set_xlabel(\"Number of pattern\")\n",
    "\n",
    "ax[2].set_title('Average over random patterns')\n",
    "ax[2].scatter(np.arange(5), energy_diff[:5], marker='x', c='r')\n",
    "ax[2].scatter(5, energy_diff[5], marker='o', c='b')\n",
    "ax[2].set_xlabel(\"Number of pattern\")\n",
    "\n",
    "ax[3].set_title('Average over chessboards\\' patterns')\n",
    "ax[3].scatter(np.arange(2),energy_chess[:2], marker='x', c='r')\n",
    "ax[3].scatter(2, energy_chess[2], marker='o', c='b')\n",
    "ax[3].set_xlabel(\"Number of pattern\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In conclusion, we proved that our guess was correct, and we found a criteria to predict whether a set of $p$ patterns is undistinguishable for the Hopfield model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hand written digits\n",
    "\n",
    "Up to now, we have seen that our model recongize the simplest data that we generated. Now, we want to take a step further and try to implement the model in a more sophisticated dataset: the MINST. \n",
    "\n",
    "The MINST is a large database of handwritten digits of size 28x28 pixels that is commonly used for training various image processing. The aim of this section is to identify correctly the digits using the Hopfield Model. \n",
    "\n",
    "We will just use the test set to run our analysis since it is way smaller than the train one, but still have enough data to give meaningful results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Convert image to pixel\n",
    "#The value 0.2 was chosen arbitrary by considering the grey scale of the image. \n",
    "def from_minst_to_spin(X):\n",
    "    X = X/255 # Normalizing the values \n",
    "    X[ X<0.2 ] = -1  \n",
    "    X[ X>=0.2 ] = 1\n",
    "    return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_test = pd.read_csv('./mnist_test.csv')\n",
    "#data_train = pd.read_csv('./mnist_train.csv')\n",
    "\n",
    "L = 28\n",
    "N = L**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_train = []\n",
    "digits_train = []\n",
    "for i in range(data_train.shape[0]):\n",
    "    a = np.array( data_train.iloc[ [i] ])\n",
    "    label_train.append( a[0][0]) # Taking the digit\n",
    "    digits_train.append( a[0][1:] ) # Taking the image of the digit\n",
    "\n",
    "label_train = np.array(label_train)\n",
    "digits_train = np.array(digits_train)\n",
    "X_train = from_minst_to_spin(digits_train) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_test = []\n",
    "digits_test = []\n",
    "for i in range(data_test.shape[0]):\n",
    "    a = np.array( data_test.iloc[ [i] ])\n",
    "    label_test.append( a[0][0]) # Taking the digit\n",
    "    digits_test.append( a[0][1:] ) # Taking the image of the digit\n",
    "\n",
    "label_test = np.array(label_test)\n",
    "digits_test = np.array(digits_test)\n",
    "X_test = from_minst_to_spin(digits_test)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first thing that needs to be done is to decide which are the possible patterns of the Hopfield model. It seems reasonable to take the average of the images representing the same digit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try with patterns that are the average over all the digits.\n",
    "# For example take the all 0, sum over the pixel and divide for the number of images.\n",
    "# If the value is negative -> -1, the other case 1\n",
    "mean_patterns = []\n",
    "for i in range(10):\n",
    "    mean_patterns.append( np.sign(X_test[ label_test == i ].sum(axis=0)) )\n",
    "mean_patterns = np.array(mean_patterns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x576 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(2, 5, figsize=(20,8))\n",
    "\n",
    "for i in range(5):\n",
    "    ax[0][i].imshow( mean_patterns[i].reshape(L,L), cmap='Greys' )\n",
    "    ax[1][i].imshow( mean_patterns[i+5].reshape(L,L), cmap='Greys' )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The error of the algorithm is 0.127551\n",
      "The algorithm recognised the pattern 9 and the correct pattern is 6\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# we use MF Montecarlo\n",
    "idx = np.random.randint(0,9999)\n",
    "dgt = label_test[idx]\n",
    "\n",
    "J = MF_coupling(mean_patterns, N)\n",
    "sys = X_test[idx]\n",
    "\n",
    "res = montecarlo(J,sys,25,1000)\n",
    "\n",
    "wrong_pixels = error_im(mean_patterns[dgt],res)\n",
    "assigned_pattern = assign_pattern(mean_patterns,res)\n",
    "\n",
    "fig, ax = plt.subplots(1,4, figsize=(10,6))\n",
    "ax[0].set_title('Original pattern')\n",
    "ax[0].imshow(mean_patterns[dgt].reshape(L,L),cmap='Greys')\n",
    "ax[1].set_title('Handwritten digit')\n",
    "ax[1].imshow(sys.reshape(L,L),cmap='Greys')\n",
    "ax[2].set_title('Recovered digit')\n",
    "ax[2].imshow(res.reshape(L,L),cmap='Greys')\n",
    "ax[3].set_title('Recognised digit')\n",
    "ax[3].imshow(mean_patterns[assigned_pattern].reshape(L,L),cmap='Greys')\n",
    "print('The error of the algorithm is %f' %(wrong_pixels))\n",
    "print('The algorithm recognised the pattern %i and the correct pattern is %i' %(assigned_pattern,dgt))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As it can be seen the recovered digit is strangely shaped, and multiple runs outline that the recognised digit is always the same: our set of patterns is undistinguishable for our algorithm with the previoulsy explained meaning. Hence, a suitable choice of the patterns must be done: firstly, we decide to \"zip\" the images in order to have less pixels to analyze.\n",
    "\n",
    "Another important reason to zip the image is the gaining in term of time implementation: we will at least divide that time by $4$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zipping the images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The zipping function takes batches of four pixels and from them creates a single pixel\n",
    "that is black even if only one of the four is black. This divides by 4 the resolution of the image, lowering the size of the system from 28x28 to 14x14.\n",
    "\n",
    "This is a common technique used in neural networks when several features are involved: indeed the choice of generating a black pixel, even if only one in four is black, is given by the different relevance that the two colors have in the MNIST problem. The white pixels are only background, and the blacks contain the actual data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def zipping(sys1):\n",
    "    sys = deepcopy(sys1)\n",
    "    N = sys.shape[0]\n",
    "    L = int(np.sqrt(N))\n",
    "    sys = sys.reshape(L,L)\n",
    "    zipp = np.array([-1 for i in range(N//4)]).reshape(L//2,L//2)\n",
    "    for i in np.arange(0, L, 2):\n",
    "        for j in np.arange(0, L, 2):\n",
    "            if sys[i][j] + sys[i+1][j] + sys[i][j+1] + sys[i+1][j+1] > -4:\n",
    "                zipp[i//2,j//2] = 1\n",
    "    zipp = zipp.reshape(1,N//4)\n",
    "    return zipp[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we zip all the data\n",
    "X_zip = []\n",
    "for i in X_test:\n",
    "    X_zip.append( zipping(i) )\n",
    "X_zip = np.array(X_zip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x576 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mean_zip = []\n",
    "\n",
    "for i in mean_patterns:\n",
    "    mean_zip.append( zipping(i) )\n",
    "mean_zip = np.array(mean_zip)\n",
    "\n",
    "fig, ax = plt.subplots(2, 5, figsize=(20,8))\n",
    "\n",
    "for i in range(5):\n",
    "    ax[0][i].imshow( mean_zip[i].reshape(L//2,L//2), cmap='Greys' )\n",
    "    ax[1][i].imshow( mean_zip[i+5].reshape(L//2,L//2), cmap='Greys' )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "J = R_coupling(mean_zip, N//4, 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The error of the algorithm is 0.086735\n",
      "The algorithm recognised the pattern 9 and the correct pattern is 4\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "idx = np.random.randint(0,9999)\n",
    "dgt = label_test[idx]\n",
    "\n",
    "sys = X_zip[idx]\n",
    "\n",
    "new = montecarlo(J,sys,25,1000)\n",
    "#res = deterministic_hopfield(sys, 100)\n",
    "\n",
    "wrong_pixels = error_im(mean_zip[dgt],new)\n",
    "assigned_pattern = assign_pattern(mean_zip,new)\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(1,4, figsize=(10,6))\n",
    "ax[0].set_title('Original pattern')\n",
    "ax[0].imshow(mean_zip[dgt].reshape(L//2,L//2),cmap='Greys')\n",
    "ax[1].set_title('Handwritten digit')\n",
    "ax[1].imshow(sys.reshape(L//2,L//2),cmap='Greys')\n",
    "ax[2].set_title('Recovered digit')\n",
    "ax[2].imshow(new.reshape(L//2,L//2),cmap='Greys')\n",
    "ax[3].set_title('Recognised digit')\n",
    "ax[3].imshow(mean_zip[assigned_pattern].reshape(L//2,L//2),cmap='Greys')\n",
    "print('The error of the algorithm is %f' %(wrong_pixels))\n",
    "print('The algorithm recognised the pattern %i and the correct pattern is %i' %(assigned_pattern,dgt))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even if zipping the images reduces the implementation time, it does not solve the problem of the strange new minimum. Thus, we will see if the given patterns are stable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Find the real minima of the system"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To find all the minima of the system we start from the mean patterns: from the theory we are sure that they should be the only minima of the system. Indeed we know that it is not totally true from the similarity analysis.\n",
    "\n",
    "We will so see if the given pattern are stable, and if not in which minimum they fall. We will also print the average of those patterns, to see if the theory presented above is still valid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABH4AAAHdCAYAAABrBb7+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3df7Dtd13f+9e7HCjll4TmoJAgkcrkljK20HMpSkXGKI1UibXcNow/otJJnQ4VetsqjK30122rdhz1yi2Tixi0FCgRlHpBSVGLzkDkEH4lBiRgkEgghwIBpG2Ifd8/9gpuz9n7nH3W+q61Pvu7H4+ZPWf/+O613mvt88xO3vmutaq7AwAAAMD8/KltDwAAAADAelj8AAAAAMyUxQ8AAADATFn8AAAAAMyUxQ8AAADATFn8AAAAAMyUxc8hVFXXVtW/Wrz/tVX1/gN+34GPBc6fNmFM2oQxaRPGpM35sfg55Lr7N7v70mWOrarbquobzvY9VXVZVb2vqj5fVb9eVY9edWY4CtbZZlXdr6quWxzXVfW0CUaGI2HNbT65qq6vqk9W1amqek1VPWKKuWHu1tzm46rqZFV9avH2X6rqcVPMDXO37v/e3HXsixb/Xnug4zk/Fj/sq6ouTPLaJP80ycOSnEzy6q0OBdzrt5J8R5KPbXsQ4IsuSHJNkkuSPDrJZ5P87DYHApIkH03yrOz8++yFSV6f5FVbnQj4oqr6c9lp9I5tzzJXFj+HQFU9oapurKrPVtWrk9x/19eeVlW37/r4iVX1zsWxr6mqV+86Te+Lx1bVzyf58iT/uao+V1U/sMdVf1uSm7v7Nd39P5L8syR/sar+t/XdWjg8ttVmd9/d3T/R3b+V5I/WfTvhsNlim29c/M78THd/PslPJ3nKmm8uHBpbbPPT3X1bd3eSys7vzq9c762Fw2OL/715r59O8oNJ7l7H7cPiZ3hVdb8kv5jk57Pzfylek+RvnuXY1yW5dnHsK5P8jb2O7e7vTPL7Sb6lux/U3T+6x2F/Icm7d33PHyb54OLzcKRtuU1gH4O1+dQkN5/nTYBZGqHNqvp0kv+R5P9O8q+XvS0wJ9tus6r+jyR3d/cbVrslnI3Fz/ienOS+SX6iu7/Q3dcleftZjj2W5KcWx742yW+vcN0PSnLXaZ+7K8mDV7hMmItttgnsb4g2q+qrkvxwkn88xeXBDGy9ze5+aJIvSfLcJO9c9fJgJrbWZlU9KDtL2OcvexkczLFtD8A5PTLJHyxOTb3Xh8/j2I+scN2fS/KQ0z73kOw8ZwEcddtsE9jf1tusqq9M8sYkz+vu31z18mAmtt5msnMGe1W9JMmpqvrz3X3nFJcLh9g22/znSX6+u39vhcvgAJzxM747klxUVbXrc19+Hsc+6iyX3Wf5WrJzevpfvPeDqnpgkj8Xp61Dst02gf1ttc3aefXL/5LkX3b3z5/reDhCRvq9+aeSPCDJRef5fTBH22zzsiTfX1Ufq6qPLS7rP1XVD55raM6Pxc/43prknuwEcayqvi3Jk85y7B8lee7i2CvOcmySfDzJY87y9dcleXxV/c2qun92Tll/T3e/77xvBczPNttMVf3pRZdJcr+quv9pv4ThqNpam1V1UZJfS/Li7n7JUtPDfG2zzW9cPHntfarqIUl+PMmnktyyzA2Bmdnmv9NeluTxSf7S4u2jSf5ukhef303gXCx+Btfdd2fn1bW+Ozu/oP52dl5i/WzHPifJp7PzUs+/nOR/7nPx/ybJP6mqT1fVP9rj8k5l54m9/q/Fdf+VJFeucHNgNrbZ5sL7k/z37Pzfyl9dvP/oZW4LzMmW2/w72fkX3BctXsHkc1X1uRVuDszGltt8aHaehPau7LxQyVcmuXzxqrVwpG35vzf/W3d/7N637CyVPtXdfndOrP7kw/OYm6q6IclLuvtntz0L8Me0CWPSJoxJmzAmbR4OzviZmar6uqr6ssWpd1cl+aokv7LtueCo0yaMSZswJm3CmLR5OHlVr/m5NMl/ys5LsX8wybO6+47tjgREmzAqbcKYtAlj0uYh5KFeAAAAADPloV4AAAAAM2XxAwAAADBTG32OnwsvvLAvueSSTV4lDOO2227LJz7xidr2HHvRJkeZNmFM2oQxaRPGdLY2N7r4ueSSS3Ly5MlNXiUM48SJE9seYV/a5CjTJoxJmzAmbcKYztamh3oBAAAAzNRKi5+quryq3l9Vt1bVC6YaCliNNmFM2oQxaRPGpE2YxtKLn6q6T5IXJ/mmJI9L8uyqetxUgwHL0SaMSZswJm3CmLQJ01nljJ8nJbm1uz/U3XcneVWSK6YZC1iBNmFM2oQxaRPGpE2YyCqLn4uSfGTXx7cvPgdslzZhTNqEMWkTxqRNmMgqi5+9Xiaszzio6uqqOllVJ0+dOrXC1QEHpE0YkzZhTNqEMWkTJrLK4uf2JI/a9fHFST56+kHdfU13n+juE8ePH1/h6oAD0iaMSZswJm3CmLQJE1ll8fP2JI+tqq+oqvsluTLJ66cZC1iBNmFM2oQxaRPGpE2YyLFlv7G776mq5yb51ST3SfKy7r55ssmApWgTxqRNGJM2YUzahOksvfhJku5+Q5I3TDQLMBFtwpi0CWPSJoxJmzCNVR7qBQAAAMDALH4AAAAAZsriBwAAAGCmLH4AAAAAZsriBwAAAGCmLH4AAAAAZsriBwAAAGCmLH4AAAAAZsriBwAAAGCmLH4AAAAAZsriBwAAAGCmLH4AAAAAZsriBwAAAGCmLH4AAAAAZsriBwAAAGCmLH4AAAAAZurYtgdgc6pqqe/r7oknAYD58vsWABiJM34AAAAAZsriBwAAAGCmll78VNWjqurXq+qWqrq5qp435WDAcrQJY9ImjEmbMCZtwnRWeY6fe5L8w+6+saoenOQdVXV9d//ORLMBy9EmjEmbMCZtwpi0CRNZ+oyf7r6ju29cvP/ZJLckuWiqwYDlaBPGpE0YkzZhTNqE6UzyHD9VdUmSJyS5YYrLA6ahTRiTNmFM2oQxaRNWs/Lip6oelOQXkjy/uz+zx9evrqqTVXXy1KlTq14dcEDahDFpE8akTRiTNmF1Ky1+quq+2YnwFd392r2O6e5ruvtEd584fvz4KlcHHJA2YUzahDFpE8akTZjGKq/qVUl+Jskt3f3j040ErEKbMCZtwpi0CWPSJkxnlTN+npLkO5N8fVW9a/H2jInmApanTRiTNmFM2oQxaRMmsvTLuXf3byWpCWcBJqBNGJM2YUzahDFpE6Yzyat6AQAAADCepc/4YRo7D10d26Zn7O6NXh/s5TC0uWnaZARzbnPZ26ZNRjDnNpelTUagzTMdxTad8QMAAAAwUxY/AAAAADNl8QMAAAAwUxY/AAAAADNl8QMAAAAwUxY/AAAAADNl8QMAAAAwUxY/AAAAADNl8QMAAAAwUxY/AAAAADNl8QMAAAAwUxY/AAAAADNl8QMAAAAwUxY/AAAAADNl8QMAAAAwUxY/AAAAADO18uKnqu5TVe+sql+eYiBgGtqEMWkTxqRNGJM2YXVTnPHzvCS3THA5wLS0CWPSJoxJmzAmbcKKVlr8VNXFSf56kpdOMw4wBW3CmLQJY9ImjEmbMI1Vz/j5iSQ/kOR/TTALMB1twpi0CWPSJoxJmzCBpRc/VfXNSe7s7nec47irq+pkVZ08derUslcHHJA2YUzahDFpE8akTZjOKmf8PCXJM6vqtiSvSvL1VfUfTj+ou6/p7hPdfeL48eMrXB1wQNqEMWkTxqRNGJM2YSJLL366+4XdfXF3X5LkyiS/1t3fMdlkwFK0CWPSJoxJmzAmbcJ0pnhVLwAAAAAGdGyKC+nu30jyG1NcFjAdbcKYtAlj0iaMSZuwGmf8AAAAAMyUxQ8AAADATE3yUC+Sqtr2COfU3Ut932G4bbCfw/D3V5scRYfh7682OYoOw99fbXIUHYa/v9oclzN+AAAAAGbK4gcAAABgpix+AAAAAGbK4gcAAABgpix+AAAAAGbK4gcAAABgpix+AAAAAGbK4gcAAABgpix+AAAAAGbK4gcAAABgpix+AAAAAGbK4gcAAABgpix+AAAAAGbq2LYHYDndfd7fU1VrmGQcy9y+Ze5HDpdlf8ab7GXubcJeNt2m35twMH5vAonfm3PjjB8AAACAmbL4AQAAAJiplRY/VfXQqrquqt5XVbdU1VdPNRiwPG3CmLQJY9ImjEmbMI1Vn+PnJ5P8Snc/q6rul+QBE8wErE6bMCZtwpi0CWPSJkxg6cVPVT0kyVOTfHeSdPfdSe6eZixgWdqEMWkTxqRNGJM2YTqrPNTrMUlOJfnZqnpnVb20qh440VzA8rQJY9ImjEmbMCZtwkRWWfwcS/LEJP++u5+Q5A+TvOD0g6rq6qo6WVUnT506tcLVAQekTRiTNmFM2oQxaRMmssri5/Ykt3f3DYuPr8tOmH9Cd1/T3Se6+8Tx48dXuDrggLQJY9ImjEmbMCZtwkSWXvx098eSfKSqLl186rIkvzPJVMDStAlj0iaMSZswJm3CdFZ9Va+/n+QVi2dY/1CS71l9JGAC2oQxaRPGpE0YkzZhAistfrr7XUlOTDQLMBFtwpi0CWPSJoxJmzCNVZ7jBwAAAICBrfpQL7akqrY9wnC6e9sjADAovzcBGMFh+X10WObkYJzxAwAAADBTFj8AAAAAM2XxAwAAADBTFj8AAAAAM2XxAwAAADBTFj8AAAAAM2XxAwAAADBTFj8AAAAAM2XxAwAAADBTFj8AAAAAM2XxAwAAADBTFj8AAAAAM2XxAwAAADBTx7Y9wFx090avr6rO+3uWnXGZ69qGTd4nMIK5Nw3A4eF3EhyMVtgGZ/wAAAAAzJTFDwAAAMBMrbT4qap/UFU3V9VNVfXKqrr/VIMBy9MmjEmbMCZtwpi0CdNYevFTVRcl+f4kJ7r78Unuk+TKqQYDlqNNGJM2YUzahDFpE6az6kO9jiX5M1V1LMkDknx09ZGACWgTxqRNGJM2YUzahAksvfjp7j9I8u+S/H6SO5Lc1d1vmmowYDnahDFpE8akTRiTNmE6qzzU64IkVyT5iiSPTPLAqvqOPY67uqpOVtXJU6dOLT8pcCDahDFpE8akTRiTNmE6qzzU6xuS/F53n+ruLyR5bZKvOf2g7r6mu09094njx4+vcHXAAWkTxqRNGJM2YUzahImssvj5/SRPrqoHVFUluSzJLdOMBaxAmzAmbcKYtAlj0iZMZJXn+LkhyXVJbkzy3sVlXTPRXMCStAlj0iaMSZswJm3CdI6t8s3d/aIkL5poFmAi2oQxaRPGpE0YkzZhGqu+nDsAAAAAg7L4AQAAAJiplR7qxfZ093l/z85zos3XMvcJ7GfZv0+b7GzZ69IKh9lhaBOYF783GcFh+Hu46d+1h+E+GYUzfgAAAABmyuIHAAAAYKYsfgAAAABmyuIHAAAAYKYsfgAAAABmyuIHAAAAYKYsfgAAAABmyuIHAAAAYKYsfgAAAABmyuIHAAAAYKYsfgAAAABmyuIHAAAAYKYsfgAAAABm6ti2BxhNVW17BGBCmoYxaRPGpE0YkzZZhTN+AAAAAGbK4gcAAABgps65+Kmql1XVnVV1067PPayqrq+qDyz+vGC9YwKn0yaMSZswJm3CmLQJ63eQM36uTXL5aZ97QZI3d/djk7x58TGwWddGmzCia6NNGNG10SaM6NpoE9bqnIuf7n5Lkk+e9ukrkrx88f7Lk3zrxHMB56BNGJM2YUzahDFpE9Zv2ef4+dLuviNJFn8+fL8Dq+rqqjpZVSdPnTq15NUBB6RNGJM2YUzahDFpEya09id37u5ruvtEd584fvz4uq8OOCBtwpi0CWPSJoxJm3Buyy5+Pl5Vj0iSxZ93TjcSsAJtwpi0CWPSJoxJmzChZRc/r09y1eL9q5L80jTjACvSJoxJmzAmbcKYtAkTOsjLub8yyVuTXFpVt1fVc5L82yTfWFUfSPKNi4+BDdImjEmbMCZtwpi0Cet37FwHdPez9/nSZRPPApwHbcKYtAlj0iaMSZuwfmt/cmcAAAAAtsPiBwAAAGCmzvlQr6Omuzd6fVW10evbpE3fl7CXOTetMQ4zbcKYtAlj0iarcMYPAAAAwExZ/AAAAADMlMUPAAAAwExZ/AAAAADMlMUPAAAAwExZ/AAAAADMlMUPAAAAwExZ/AAAAADMlMUPAAAAwExZ/AAAAADMlMUPAAAAwExZ/AAAAADM1LFtD3DUdfe2RwAmpGkYkzZhTNqEMWlzXpzxAwAAADBTFj8AAAAAM3XOxU9Vvayq7qyqm3Z97seq6n1V9Z6qel1VPXS9YwKn0yaMSZswJm3CmLQJ63eQM36uTXL5aZ+7Psnju/urkvxukhdOPBdwbtdGmzCia6NNGNG10SaM6NpoE9bqnIuf7n5Lkk+e9rk3dfc9iw/fluTiNcwGnIU2YUzahDFpE8akTVi/KZ7j53uTvHGCywGmpU0YkzZhTNqEMWkTVrTS4qeqfijJPUlecZZjrq6qk1V18tSpU6tcHXBA2oQxaRPGpE0YkzZhGksvfqrqqiTfnOTbu7v3O667r+nuE9194vjx48teHXBA2oQxaRPGpE0YkzZhOseW+aaqujzJDyb5uu7+/LQjAcvSJoxJmzAmbcKYtAnTOsjLub8yyVuTXFpVt1fVc5L8dJIHJ7m+qt5VVS9Z85zAabQJY9ImjEmbMCZtwvqd84yf7n72Hp/+mTXMApwHbcKYtAlj0iaMSZuwflO8qhcAAAAAA7L4AQAAAJgpix8AAACAmbL4AQAAAJgpix8AAACAmbL4AQAAAJgpix8AAACAmbL4AQAAAJgpix8AAACAmbL4AQAAAJgpix8AAACAmbL4AQAAAJgpix8AAACAmbL4AQAAAJgpix8AAACAmbL4AQAAAJip6u7NXVnVqSQf3ufLFyb5xMaG2d8ocyTjzGKOMy0zy6O7+/g6hlmVNs/LKHMk48wyyhyJNrfBHGcaZZbDPoc2V2OOM40yy2Gf4zC2Ocp9nowziznONMosk7e50cXP2VTVye4+YY4/Nsos5jjTSLOs2yi31RxnGmWWUeZIxppl3Ua5reY40yizmGM7Rrm95jjTKLOYY/NGuq2jzGKOM40yyzrm8FAvAAAAgJmy+AEAAACYqZEWP9dse4CFUeZIxpnFHGcaaZZ1G+W2muNMo8wyyhzJWLOs2yi31RxnGmUWc2zHKLfXHGcaZRZzbN5It3WUWcxxplFmmXyOYZ7jBwAAAIBpjXTGDwAAAAAT2vjip6our6r3V9WtVfWCPb7+p6vq1Yuv31BVl6xhhkdV1a9X1S1VdXNVPW+PY55WVXdV1bsWbz889RyL67mtqt67uI6Te3y9quqnFvfHe6rqiWua49Jdt/VdVfWZqnr+aces5T6pqpdV1Z1VddOuzz2sqq6vqg8s/rxgn++9anHMB6rqqjXN8mNV9b7F/f+6qnroPt971p/lyEbocnE92jzzeo58m0e1y0Sb+8yiTW1unTb3nGXrbW6zy8Vla3PLtLnnLNrUZtLdG3tLcp8kH0zymCT3S/LuJI877Zi/l+Qli/evTPLqNczxiCRPXLz/4CS/u8ccT0vyyxu4T25LcuFZvv6MJG9MUkmenOSGDf2cPpbk0Zu4T5I8NckTk9y063M/muQFi/dfkORH9vi+hyX50OLPCxbvX7CGWZ6e5Nji/R/Za5aD/CxHfRuly8Vla/PcP6sj1+ZR7HLXz1ub5/kz1aY2N/Tz1uZ5/kw33eamu1xctja3+KbNfWfRpjY3fsbPk5Lc2t0f6u67k7wqyRWnHXNFkpcv3r8uyWVVVVMO0d13dPeNi/c/m+SWJBdNeR0TuiLJz/WOtyV5aFU9Ys3XeVmSD3b3h9d8PUmS7n5Lkk+e9undfw9enuRb9/jWv5bk+u7+ZHd/Ksn1SS6fepbuflN337P48G1JLl7lOgY0RJeJNg/gSLZ5RLtMtLksbWpz3bS5nE23udEuE20OQJvL0eYRaHPTi5+Lknxk18e358wAvnjM4g64K8mfXddAi9P7npDkhj2+/NVV9e6qemNV/YU1jdBJ3lRV76iqq/f4+kHus6ldmeSV+3xtE/dJknxpd9+R7PyDM8nD9zhmG/fN92ZnI76Xc/0sRzVcl4k296HNvc2xy0Sb+9Hm3rS5Odrc22htjtBlos1N0ubetLm3I9XmsZXGOn97bVNPf1mxgxwziap6UJJfSPL87v7MaV++MTunn32uqp6R5BeTPHYNYzyluz9aVQ9Pcn1VvW+xCfzimHt8z9peiq2q7pfkmUleuMeXN3WfHNSm75sfSnJPklfsc8i5fpajGqrLRJt70eY+VzTfLhNt7keby9PmNLS5t2HaPGRdJtqcijb3ps3lzabNTZ/xc3uSR+36+OIkH93vmKo6luRLcuZpWSurqvtmJ8JXdPdrT/96d3+muz+3eP8NSe5bVRdOPUd3f3Tx551JXpedUxR3O8h9NqVvSnJjd3/89C9s6j5Z+Pi9pxgu/rxzj2M2dt/UzhN5fXOSb+/uPWM/wM9yVMN0ubh8be5Nm6eZeZeJNvekzX1pc3O0uYfB2hyly0Sbm6TNPWhzX0eqzU0vft6e5LFV9RWLbd+VSV5/2jGvT3LV4v1nJfm1/W78sqqqkvxMklu6+8f3OebLFselqp6Unfvqv008xwOr6sH3vp+dJ3a66bTDXp/ku2rHk5Pcde8paWvy7Oxz6t0m7pNddv89uCrJL+1xzK8meXpVXVA7z8L+9MXnJlVVlyf5wSTP7O7P73PMQX6Woxqiy0Sb56DNXY5Al4k297oObe5Pm5ujzTOvY7Q2R+ky0eYmafPM69Dm/o5Wm73GZ+ze6y07zxr+u9l5xvUfWnzuXyxuaJLcP8lrktya5LeTPGYNM/zV7Jyi9Z4k71q8PSPJ9yX5vsUxz01yc3aeDf5tSb5mDXM8ZnH5715c1733x+45KsmLF/fXe5OcWOPP5gHZietLdn1u7fdJduK/I8kXsrNVfU52Hmv75iQfWPz5sMWxJ5K8dNf3fu/i78qtSb5nTbPcmp3Hdt77d+XeVwJ4ZJI3nO1neVjeRuhycT3a3HueI93mUe1ycRu0+Sfn0GZrc4Q3bZ4xxzBtbqvLxWVrc8tv2jxjDm22Nrs7tbggAAAAAGZm0w/1AgAAAGBDLH4AAAAAZsriBwAAAGCmLH4AAAAAZsriBwAAAGCmLH4AAAAAZsriBwAAAGCmLH4AAAAAZsriBwAAAGCmLH4AAAAAZsriBwAAAGCmLH4AAAAAZsri5xCqqmur6l8t3v/aqnr/Ab/vwMcC50+bMCZtwpi0CWPS5vxY/Bxy3f2b3X3pMsdW1W1V9Q37HV9Vl1RVV9Xndr390ynmhrlbZ5uLYx5QVf9PVX2iqu6qqresOjMcBWv+vfntp/3O/Pzi9+hfnmJ2mLMN/N78W1V1S1V9tqp+p6q+ddWZ4SjYQJt/p6puXfze/JWqeuSqM3Mmix8O4qHd/aDF27/c9jBAkuSaJA9L8ucXf/6D7Y4DdPcrdv2+fFCSv5fkQ0lu3PJocKRV1UVJ/kOS/zPJQ5L84yT/saoevtXB4Iirqq9L8q+TXJGdf5/9vSSv3OpQM2XxcwhU1ROq6sbF/6F4dZL77/ra06rq9l0fP7Gq3rk49jVV9epdp+l98diq+vkkX57kPy+2qz+w4ZsFh9622qyqS5M8M8nV3X2qu/+ou9+x5psLh8ZAvzevSvJz3d2T3kA4pLbY5sVJPt3db+wd/1+SP0zy59Z4c+HQ2GKb35LkNd19c3ffneRfJnlqVWlzYhY/g6uq+yX5xSQ/n50t6GuS/M2zHPu6JNcujn1lkr+x17Hd/Z1Jfj/Jtyz+z+SPnmWMD1fV7VX1s1V14bK3BeZky23+lSQfTvLPFw/1em9V7XndcNQM8nszVfXoJE9N8nNL3RCYmS23eTLJLVX1zKq6z+JhXv8zyXtWulEwA1tusxZvuz9Oksef9w3hrCx+xvfkJPdN8hPd/YXuvi7J289y7LEkP7U49rVJfnuF6/5Ekv89yaOT/OUkD07yihUuD+Zkm21enJ1fiHcleWSS5yZ5eVX9+RUuE+Zim23u9l1JfrO7f2+iy4PDbmttdvcfZWcJ+x+zs/D5j0n+bnf/4bKXCTOyzd+bb0jyt6rqq6rqzyT54SSd5AErXCZ7sPgZ3yOT/MFpp4l/+DyO/ciyV9zdn+vuk919T3d/PDv/cfn0qnrIspcJM7K1NpP89yRfSPKvuvvu7v6vSX49ydNXuEyYi222udt3JXn5RJcFc7C1NhdPLvujSZ6W5H5Jvi7JS6vqLy17mTAj2/zvzTcneVGSX1hc521JPpvk9rN8G0uw+BnfHUkuqqrdp8B9+Xkc+6izXPb5PufAvcfXWY+Co2GbbTo1Hfa39d+bVfWU7PzL8XUHOR6OiG22+ZeSvGXxPzT/V3e/PckNSc76akNwRGz192Z3v7i7H9vdD8/OAuhYkpvO9X2cH4uf8b01yT1Jvr+qjlXVtyV50lmO/aMkz10ce8VZjk2Sjyd5zH5frKq/UlWXVtWfqqo/m+SnkvxGd9+11C2Bedlam0nekp3HTL9wcXlPyc7/xfzV87wNMEfbbPNeVyX5he7+7HnMDXO3zTbfnuRr7z3Dp6qekORr43+kQLLd/968f1U9vnZ8eXZetfYnu/tTS90S9mXxM7jFs5t/W5LvTvKpJH87yWvPcexzknw6yXck+eXsPJZ5L/8myT+pqk9X1T/a4+uPSfIr2Tnd7qbF5Tx72dsCc7LNNrv7C9l52ctnZOd5fv7fJN/V3e9b4SbBLGz592aq6v5J/lY8zAv+hC3/3vyvSf5Zkuuq6rPZOavgX3f3m1a4STALW/69ef/sPOfW57LzXEFvTfJPl70t7K+8wui8VdUNSV7S3T+77VmAP6ZNGJM2YUzahDFp83Bwxs/MVNXXVdWXLU69uyrJV2XnrB1gi7QJY9ImjEmbMCZtHk7Htj0Ak7s0yX9K8qAkH0zyrO6+Y7sjAdEmjEqbMCZtwpi0eQh5qBcAAADATHmoFwAAAMBMWfwAAAAAzNRGn+Pnwgsv7EsuuWSTVwnDuO222/KJT3yitseLGG0AABS1SURBVD3HXrTJUaZNGJM2YUzahDGdrc2NLn4uueSSnDx5cpNXCcM4ceLEtkfYlzY5yrQJY9ImjEmbMKaztemhXgAAAAAztdLip6our6r3V9WtVfWCqYYCVqNNGJM2YUzahDFpE6ax9OKnqu6T5MVJvinJ45I8u6oeN9VgwHK0CWPSJoxJmzAmbcJ0Vjnj50lJbu3uD3X33UleleSKacYCVqBNGJM2YUzahDFpEyayyuLnoiQf2fXx7YvPAdulTRiTNmFM2oQxaRMmssriZ6+XCeszDqq6uqpOVtXJU6dOrXB1wAFpE8akTRiTNmFM2oSJrLL4uT3Jo3Z9fHGSj55+UHdf090nuvvE8ePHV7g64IC0CWPSJoxJmzAmbcJEVln8vD3JY6vqK6rqfkmuTPL6acYCVqBNGJM2YUzahDFpEyZybNlv7O57quq5SX41yX2SvKy7b55sMmAp2oQxaRPGpE0YkzZhOksvfpKku9+Q5A0TzQJMRJswJm3CmLQJY9ImTGOVh3oBAAAAMDCLHwAAAICZsvgBAAAAmCmLHwAAAICZsvgBAAAAmCmLHwAAAICZsvgBAAAAmCmLHwAAAICZsvgBAAAAmCmLHwAAAICZsvgBAAAAmCmLHwAAAICZsvgBAAAAmCmLHwAAAICZsvgBAAAAmCmLHwAAAICZOrbtAQAAAA6qqpb6vu6eeBKAw8EZPwAAAAAzZfEDAAAAMFNLL36q6lFV9etVdUtV3VxVz5tyMGA52oQxaRPGpE0YkzZhOqs8x889Sf5hd99YVQ9O8o6qur67f2ei2YDlaBPGpE0YkzZhTNqEiSx9xk9339HdNy7e/2ySW5JcNNVgwHK0CWPSJoxJmzAmbcJ0JnmOn6q6JMkTktwwxeUB09AmjEmbMCZtwpi0CatZefFTVQ9K8gtJnt/dn9nj61dX1cmqOnnq1KlVrw44IG3CmLQJY9ImjEmbsLqVFj9Vdd/sRPiK7n7tXsd09zXdfaK7Txw/fnyVqwMOSJswJm3CmLQJY9ImTGOVV/WqJD+T5Jbu/vHpRgJWoU0YkzZhTNqEMWkTprPKGT9PSfKdSb6+qt61eHvGRHMBy9MmjEmbMCZtwpi0CRNZ+uXcu/u3ktSEswAT0CaMSZswJm3CmLQJ05nkVb0AAAAAGM/SZ/wwjZ2HrrJbd297BNDmHrTJCLR5Jm0ygsPQ5qZn1CYjOAxtbtpRbNMZPwAAAAAzZfEDAAAAMFMWPwAAAAAzZfEDAAAAMFMWPwAAAAAzZfEDAAAAMFMWPwAAAAAzZfEDAAAAMFMWPwAAAAAzZfEDAAAAMFMWPwAAAAAzZfEDAAAAMFMWPwAAAAAzdWzbAwAAR09VbXsEAIAjwRk/AAAAADNl8QMAAAAwUysvfqrqPlX1zqr65SkGAqahTRiTNmFM2oQxaRNWN8UZP89LcssElwNMS5swJm3CmLQJY9ImrGilxU9VXZzkryd56TTjAFPQJoxJmzAmbcKYtAnTWPWMn59I8gNJ/tcEswDT0SaMSZswJm3CmLQJE1h68VNV35zkzu5+xzmOu7qqTlbVyVOnTi17dcABaRPGpE0YkzZhTNqE6axyxs9Tkjyzqm5L8qokX19V/+H0g7r7mu4+0d0njh8/vsLVAQekTRiTNmFM2oQxaRMmsvTip7tf2N0Xd/clSa5M8mvd/R2TTQYsRZswJm3CmLQJY9ImTGeKV/UCAAAAYEDHpriQ7v6NJL8xxWUB09EmjEmbMCZtwpi0Catxxg8AAADATFn8AAAAAMzUJA/1IqmqbY9wTt291PcdhtsG+zkMf3+1CWPSJkfRYfj7q02OosPw91eb43LGDwAAAMBMWfwAAAAAzJTFDwAAAMBMWfwAAAAAzJTFDwAAAMBMWfwAAAAAzJTFDwAAAMBMWfwAAAAAzJTFDwAAAMBMWfwAAAAAzJTFDwAAAMBMWfwAAAAAzJTFDwAAAMBMHdv2ACynu8/7e6pqDZMAu2kTDmaZVpLle9EmHIw2gUSbc+OMHwAAAICZsvgBAAAAmKmVFj9V9dCquq6q3ldVt1TVV081GLA8bcKYtAlj0iaMSZswjVWf4+cnk/xKdz+rqu6X5AETzASsTpswJm3CmLQJY9ImTGDpxU9VPSTJU5N8d5J0991J7p5mLGBZ2oQxaRPGpE0YkzZhOqs81OsxSU4l+dmqemdVvbSqHjjRXMDytAlj0iaMSZswJm3CRFZZ/BxL8sQk/767n5DkD5O84PSDqurqqjpZVSdPnTq1wtUBB6RNGJM2YUzahDFpEyayyuLn9iS3d/cNi4+vy06Yf0J3X9PdJ7r7xPHjx1e4OuCAtAlj0iaMSZswJm3CRJZe/HT3x5J8pKouXXzqsiS/M8lUwNK0CWPSJoxJmzAmbcJ0Vn1Vr7+f5BWLZ1j/UJLvWX0kYALahDFpE8akTRiTNmECKy1+uvtdSU5MNAswEW3CmLQJY9ImjEmbMI1VnuMHAAAAgIGt+lAvtqSqtj0CsAdtwpi0CWPSJoxJm/PijB8AAACAmbL4AQAAAJgpix8AAACAmbL4AQAAAJgpix8AAACAmbL4AQAAAJgpix8AAACAmbL4AQAAAJgpix8AAACAmbL4AQAAAJgpix8AAACAmbL4AQAAAJgpix8AAACAmTq27QHmoruX+r6qmngSYDdtAgAAR5kzfgAAAABmyuIHAAAAYKZWWvxU1T+oqpur6qaqemVV3X+qwYDlaRPGpE0YkzZhTNqEaSy9+Kmqi5J8f5IT3f34JPdJcuVUgwHL0SaMSZswJm3CmLQJ01n1oV7HkvyZqjqW5AFJPrr6SMAEtAlj0iaMSZswJm3CBJZe/HT3HyT5d0l+P8kdSe7q7jdNNRiwHG3CmLQJY9ImjEmbMJ1VHup1QZIrknxFkkcmeWBVfccex11dVSer6uSpU6eWnxQ4EG3CmLQJY9ImjEmbMJ1VHur1DUl+r7tPdfcXkrw2ydecflB3X9PdJ7r7xPHjx1e4OuCAtAlj0iaMSZswJm3CRFZZ/Px+kidX1QOqqpJcluSWacYCVqBNGJM2YUzahDFpEyayynP83JDkuiQ3Jnnv4rKumWguYEnahDFpE8akTRiTNmE6x1b55u5+UZIXTTQLMBFtwpi0CWPSJoxJmzCNVV/OHQAAAIBBWfwAAAAAzNRKD/Vidd29sevaeU60zdnkbYOpLfv3d9OdLUObHGbahPVathVtwnodhr+H/ntzXM74AQAAAJgpix8AAACAmbL4AQAAAJgpix8AAACAmbL4AQAAAJgpix8AAACAmbL4AQAAAJgpix8AAACAmbL4AQAAAJgpix8AAACAmbL4AQAAAJgpix8AAACAmbL4AQAAAJipY9seYC6qatsjAHvQJsyLpmFM2oT10hircMYPAAAAwExZ/AAAAADM1DkXP1X1sqq6s6pu2vW5h1XV9VX1gcWfF6x3TOB02oQxaRPGpE0YkzZh/Q5yxs+1SS4/7XMvSPLm7n5skjcvPgY269poE0Z0bbQJI7o22oQRXRttwlqdc/HT3W9J8snTPn1Fkpcv3n95km+deC7gHLQJY9ImjEmbMCZtwvot+xw/X9rddyTJ4s+HTzcSsAJtwpi0CWPSJoxJmzChtT+5c1VdXVUnq+rkqVOn1n11wAFpE8akTRiTNmFM2oRzW3bx8/GqekSSLP68c78Du/ua7j7R3SeOHz++5NUBB6RNGJM2YUzahDFpEya07OLn9UmuWrx/VZJfmmYcYEXahDFpE8akTRiTNmFCB3k591cmeWuSS6vq9qp6TpJ/m+Qbq+oDSb5x8TGwQdqEMWkTxqRNGJM2Yf2OneuA7n72Pl+6bOJZgPOgTRiTNmFM2oQxaRPWb+1P7gwAAADAdlj8AAAAAMzUOR/qxXp191LfV1UTTwLztGxjy9pkm5u+bTCCw/B7U5scZn5vwpi0ySqc8QMAAAAwUxY/AAAAADNl8QMAAAAwUxY/AAAAADNl8QMAAAAwUxY/AAAAADNl8QMAAAAwUxY/AAAAADNl8QMAAAAwUxY/AAAAADNl8QMAAAAwUxY/AAAAADN1bNsDzEV3z/r6gIPRJoxJmzAmbcKYtDkvzvgBAAAAmCmLHwAAAICZOufip6peVlV3VtVNuz73Y1X1vqp6T1W9rqoeut4xgdNpE8akTRiTNmFM2oT1O8gZP9cmufy0z12f5PHd/VVJfjfJCyeeCzi3a6NNGNG10SaM6NpoE0Z0bbQJa3XOxU93vyXJJ0/73Ju6+57Fh29LcvEaZgPOQpswJm3CmLQJY9ImrN8Uz/HzvUneOMHlANPSJoxJmzAmbcKYtAkrWmnxU1U/lOSeJK84yzFXV9XJqjp56tSpVa4OOCBtwpi0CWPSJoxJmzCNpRc/VXVVkm9O8u3d3fsd193XdPeJ7j5x/PjxZa8OOCBtwpi0CWPSJoxJmzCdY8t8U1VdnuQHk3xdd39+2pGAZWkTxqRNGJM2YUzahGkd5OXcX5nkrUkurarbq+o5SX46yYOTXF9V76qql6x5TuA02oQxaRPGpE0YkzZh/c55xk93P3uPT//MGmYBzoM2YUzahDFpE8akTVi/KV7VCwAAAIABWfwAAAAAzJTFDwAAAMBMWfwAAAAAzJTFDwAAAMBMWfwAAAAAzJTFDwAAAMBMWfwAAAAAzJTFDwAAAMBMWfwAAAAAzJTFDwAAAMBMWfwAAAAAzJTFDwAAAMBMWfwAAAAAzJTFDwAAAMBMWfwAAAAAzFR19+aurOpUkg/v8+ULk3xiY8Psb5Q5knFmMceZlpnl0d19fB3DrEqb52WUOZJxZhlljkSb22COM40yy2GfQ5urMceZRpnlsM9xGNsc5T5PxpnFHGcaZZbJ29zo4udsqupkd58wxx8bZRZznGmkWdZtlNtqjjONMssocyRjzbJuo9xWc5xplFnMsR2j3F5znGmUWcyxeSPd1lFmMceZRpllHXN4qBcAAADATFn8AAAAAMzUSIufa7Y9wMIocyTjzGKOM400y7qNclvNcaZRZhlljmSsWdZtlNtqjjONMos5tmOU22uOM40yizk2b6TbOsos5jjTKLNMPscwz/EDAAAAwLRGOuMHAAAAgAltfPFTVZdX1fur6taqesEeX//TVfXqxddvqKpL1jDDo6rq16vqlqq6uaqet8cxT6uqu6rqXYu3H556jsX13FZV711cx8k9vl5V9VOL++M9VfXENc1x6a7b+q6q+kxVPf+0Y9Zyn1TVy6rqzqq6adfnHlZV11fVBxZ/XrDP9161OOYDVXXVmmb5sap63+L+f11VPXSf7z3rz3JkI3S5uB5tnnk9R77No9plos19ZtGmNrdOm3vOsvU2t9nl4rK1uWXa3HMWbWoz6e6NvSW5T5IPJnlMkvsleXeSx512zN9L8pLF+1cmefUa5nhEkicu3n9wkt/dY46nJfnlDdwntyW58Cxff0aSNyapJE9OcsOGfk4fS/LoTdwnSZ6a5IlJbtr1uR9N8oLF+y9I8iN7fN/Dknxo8ecFi/cvWMMsT09ybPH+j+w1y0F+lqO+jdLl4rK1ee6f1ZFr8yh2uevnrc3z/JlqU5sb+nlr8zx/pptuc9NdLi5bm1t80+a+s2hTmxs/4+dJSW7t7g91991JXpXkitOOuSLJyxfvX5fksqqqKYfo7ju6+8bF+59NckuSi6a8jgldkeTnesfbkjy0qh6x5uu8LMkHu/vDa76eJEl3vyXJJ0/79O6/By9P8q17fOtfS3J9d3+yuz+V5Pokl089S3e/qbvvWXz4tiQXr3IdAxqiy0SbB3Ak2zyiXSbaXJY2tblu2lzOptvcaJeJNgegzeVo8wi0uenFz0VJPrLr49tzZgBfPGZxB9yV5M+ua6DF6X1PSHLDHl/+6qp6d1W9sar+wppG6CRvqqp3VNXVe3z9IPfZ1K5M8sp9vraJ+yRJvrS770h2/sGZ5OF7HLON++Z7s7MR38u5fpajGq7LRJv70Obe5thlos39aHNv2twcbe5ttDZH6DLR5iZpc2/a3NuRavPYSmOdv722qae/rNhBjplEVT0oyS8keX53f+a0L9+YndPPPldVz0jyi0keu4YxntLdH62qhye5vqret9gEfnHMPb5nbS/FVlX3S/LMJC/c48ubuk8OatP3zQ8luSfJK/Y55Fw/y1EN1WWizb1oc58rmm+XiTb3o83laXMa2tzbMG0esi4TbU5Fm3vT5vJm0+amz/i5Pcmjdn18cZKP7ndMVR1L8iU587SslVXVfbMT4Su6+7Wnf727P9Pdn1u8/4Yk962qC6eeo7s/uvjzziSvy84pirsd5D6b0jclubG7P376FzZ1nyx8/N5TDBd/3rnHMRu7b2rniby+Ocm3d/eesR/gZzmqYbpcXL4296bN08y8y0Sbe9LmvrS5Odrcw2BtjtJlos1N0uYetLmvI9Xmphc/b0/y2Kr6isW278okrz/tmNcnuWrx/rOS/Np+N35ZVVVJfibJLd394/sc82WL41JVT8rOffXfJp7jgVX14Hvfz84TO9102mGvT/JdtePJSe6695S0NXl29jn1bhP3yS67/x5cleSX9jjmV5M8vaouqJ1nYX/64nOTqqrLk/xgkmd29+f3OeYgP8tRDdFlos1z0OYuR6DLRJt7XYc296fNzdHmmdcxWpujdJloc5O0eeZ1aHN/R6vNXuMzdu/1lp1nDf/d7Dzj+g8tPvcvFjc0Se6f5DVJbk3y20kes4YZ/mp2TtF6T5J3Ld6ekeT7knzf4pjnJrk5O88G/7YkX7OGOR6zuPx3L67r3vtj9xyV5MWL++u9SU6s8WfzgOzE9SW7Prf2+yQ78d+R5AvZ2ao+JzuPtX1zkg8s/nzY4tgTSV6663u/d/F35dYk37OmWW7NzmM77/27cu8rATwyyRvO9rM8LG8jdLm4Hm3uPc+RbvOodrm4Ddr8k3Nos7U5wps2z5hjmDa31eXisrW55TdtnjGHNlub3Z1aXBAAAAAAM7Pph3oBAAAAsCEWPwAAAAAzZfEDAAAAMFMWPwAAAAAzZfEDAAAAMFMWPwAAAAAzZfEDAAAAMFMWPwAAAAAz9f8DxZb7zLmG0PAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1440x576 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "minima = []\n",
    "\n",
    "for k in mean_zip:\n",
    "    res = montecarlo(J, k, 25, 500)\n",
    "    minima.append(res)\n",
    "\n",
    "minima = np.array(minima)\n",
    "\n",
    "fig, ax = plt.subplots(2, 5, figsize=(20,8))\n",
    "\n",
    "for i in range(5):\n",
    "    ax[0][i].set_title('digit %i' %i)\n",
    "    ax[0][i].imshow( minima[i].reshape(L//2,L//2), cmap='Greys' )\n",
    "    ax[1][i].set_title('digit %i' %(i+5))\n",
    "    ax[1][i].imshow( minima[i+5].reshape(L//2,L//2), cmap='Greys' )\n",
    "plt.show()\n",
    "\n",
    "energy_dig = []\n",
    "\n",
    "for i in mean_zip:\n",
    "    energy_dig.append( H(J, i) )\n",
    "energy_dig.append(H(J,np.sign(mean_zip.mean(axis=0)) ) )\n",
    "\n",
    "fig, ax = plt.subplots(1, 2, figsize=(15,6))\n",
    "ax[0].set_title('Average digit')\n",
    "ax[0].imshow( np.sign(minima.mean(axis=0)).reshape(L//2,L//2), cmap='Greys' )\n",
    "ax[1].set_title('Energy landscape of the digits')\n",
    "ax[1].scatter(np.arange(len(energy_dig)-1),energy_dig[:len(energy_dig)-1], marker='x', c='r', label= 'Digit energy')\n",
    "ax[1].scatter( len(energy_dig)-1, energy_dig[len(energy_dig)-1], marker='o', c='b', label= 'Average energy')\n",
    "ax[1].set_xlabel(\"Patterns\")\n",
    "ax[1].set_ylabel('Energy')\n",
    "ax[1].legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can observe that all the minima found look almost the same: this means that the algorithm is unable to properly recognise the correct pattern, and we are in the very same situation discussed before. As a result, we develop a new method called \"Hopfield chain\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hopfield-chain algorithm\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our model consist of several layers that are computed by observing the so called \"error matrix\". This matrix represent the rate of error in classifing the data comparing only two patterns at a time. In this way, we combine the most different patterns and make the algorithm choose between the most easily distinguishable ones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.  , 0.29, 0.21, 0.2 , 0.25, 0.16, 0.2 , 0.23, 0.17, 0.22],\n",
       "       [0.29, 0.  , 0.18, 0.15, 0.16, 0.16, 0.18, 0.11, 0.17, 0.15],\n",
       "       [0.21, 0.18, 0.  , 0.12, 0.18, 0.18, 0.15, 0.19, 0.12, 0.16],\n",
       "       [0.2 , 0.15, 0.12, 0.  , 0.19, 0.09, 0.19, 0.14, 0.12, 0.15],\n",
       "       [0.25, 0.16, 0.18, 0.19, 0.  , 0.17, 0.12, 0.14, 0.19, 0.06],\n",
       "       [0.16, 0.16, 0.18, 0.09, 0.17, 0.  , 0.15, 0.14, 0.12, 0.12],\n",
       "       [0.2 , 0.18, 0.15, 0.19, 0.12, 0.15, 0.  , 0.17, 0.17, 0.12],\n",
       "       [0.23, 0.11, 0.19, 0.14, 0.14, 0.14, 0.17, 0.  , 0.13, 0.09],\n",
       "       [0.17, 0.17, 0.12, 0.12, 0.19, 0.12, 0.17, 0.13, 0.  , 0.13],\n",
       "       [0.22, 0.15, 0.16, 0.15, 0.06, 0.12, 0.12, 0.09, 0.13, 0.  ]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "err_mat = []\n",
    "for i in range(10):\n",
    "    err_mat.append([])\n",
    "    for j in range(10):\n",
    "        err_mat[i].append( round(error_im(mean_zip[i], mean_zip[j]),2) )\n",
    "err_mat = np.array(err_mat).reshape(10,10)\n",
    "err_mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [0, 2],\n",
       "       [0, 3],\n",
       "       [0, 4],\n",
       "       [0, 6],\n",
       "       [0, 7],\n",
       "       [0, 9],\n",
       "       [2, 5],\n",
       "       [4, 8]], dtype=int64)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Selecting couples with higher differences\n",
    "best = []\n",
    "for i in range(10):\n",
    "    best.append( [i ,np.argmax( err_mat[i] )] )\n",
    "\n",
    "# Eliminating symmetric couples\n",
    "best = np.unique(np.sort(best, axis=1), axis=0)\n",
    "\n",
    "best"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Computing the couplings for the various connections\n",
    "Ji = []\n",
    "for i in best:\n",
    "    patt = np.array( [  mean_zip[i[0]], mean_zip[i[1]] ] )\n",
    "    Ji.append( R_coupling( patt ,N//4, 7) ) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Average for each digits\n",
    "\n",
    "Now it is important to set a threshold error between layers. In order to derive it, we compute the speed of convergence for each digit as a function of the number of iterations. \n",
    "Finding the optimal value is crucial to avoid the incorrect classification of different patterns (i.e. all the patterns falling in the same minimum).\n",
    "We so first compute the speed of convergence of each digit in its layer, and then the speed of convergence of each digit in the first layer ( and so in a layer that doesn't have access to the correct classification)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Look at different digit convergence time\n",
    "ordered_digits = []\n",
    "for i in range(10):\n",
    "    ordered_digits.append( X_zip[ label_test == i ] )\n",
    "\n",
    "iterations = np.arange(200,600,50)\n",
    "\n",
    "err = []\n",
    "err_dev = []\n",
    "\n",
    "for i in range(10): # cycle over the digits\n",
    "    err.append( [] )\n",
    "    err_dev.append( [] )\n",
    "    for t in iterations: # cycle over iterations\n",
    "        temp_err = []\n",
    "        for n in range(10): # iterations\n",
    "            for j in range(len(best)): # Selection of correct coupling\n",
    "                if i in best[j]:\n",
    "                    sys = ordered_digits[i][n]\n",
    "                    res = montecarlo(Ji[j], sys ,25 , t)\n",
    "                    wrong_pixels = error_im(mean_zip[i], res)\n",
    "                    temp_err.append(wrong_pixels)\n",
    "                    break\n",
    "        temp_err = np.array(temp_err)\n",
    "        err[i].append( temp_err.mean() )\n",
    "        err_dev[i].append( temp_err.std() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure( figsize=(10,6) )\n",
    "for i in range(10):\n",
    "    label = ('Digit %i' %i)\n",
    "    plt.errorbar( iterations, err[i],fmt='--o', yerr=err_dev[i],  label = label )\n",
    "plt.xlabel('Number of iterations')\n",
    "plt.ylabel('Errors')\n",
    "plt.legend(loc='best')\n",
    "plt.title('Speed of convergence for each digit')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\".\\Images\\mnist_samedigit.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A convergence of all the digits can be observed, and it can be noticed that the maximum error is very low ($\\approx 7.5\\%$). By observing the graph, this value is set as threshold and the number of iterations is fixed to $400$.\n",
    "\n",
    "After that, we want to prove that the chosen values are correct, so we calculate the same plot but considering only the performances for every digit with respect to the first layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diff_digits = []\n",
    "\n",
    "for i in range(10):\n",
    "    diff_digits.append( X_zip[ label_test == i ] )\n",
    "\n",
    "iterations = np.arange(200,600,50)\n",
    "\n",
    "err = []\n",
    "err_dev = []\n",
    "\n",
    "for i in range(2,10): # cycle over the digits\n",
    "    err.append( [] )\n",
    "    err_dev.append( [] )\n",
    "    for t in iterations: # cycle over iterations\n",
    "        temp_err = []\n",
    "        for n in range(10): # iterations\n",
    "            sys = ordered_digits[i][n]\n",
    "            res = montecarlo(Ji[0], sys ,25 , t)\n",
    "            wrong_pixels = error_im(mean_zip[i], res)\n",
    "            temp_err.append(wrong_pixels)\n",
    "        temp_err = np.array(temp_err)\n",
    "        err[i-2].append( temp_err.mean() )\n",
    "        err_dev[i-2].append( temp_err.std() )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure( figsize=(10,6) )\n",
    "for i in range(2, 10):\n",
    "    label = ('Digit %i' %i)\n",
    "    plt.errorbar( iterations, err[i-2],fmt='--o', yerr=err_dev[i-2],  label = label )\n",
    "plt.xlabel('Number of iterations')\n",
    "plt.ylabel('Errors')\n",
    "plt.legend(loc='best')\n",
    "plt.title('Speed of convergence for each digit with respect to layer 0')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='.\\Images\\minst_diffdigit.png'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can observe that every curve in the graph above is clearly over the chosen threshold of $0.075$ and that a divergence can be noticed, which is the expected result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The score of the algorithm is 0.930000 with an average error of 0.017398\n"
     ]
    }
   ],
   "source": [
    "err = []\n",
    "score = 0\n",
    "\n",
    "for n in range(100):\n",
    "    idx = np.random.randint(0, 9999)\n",
    "    dgt = label_test[idx]\n",
    "\n",
    "    for i in range(len(best)):\n",
    "        sys = X_zip[idx]\n",
    "        res = montecarlo(Ji[i], sys, 25, 400)\n",
    "\n",
    "        wrong_pixels = error_im(mean_zip[dgt], res)\n",
    "\n",
    "        if wrong_pixels > 0.075 and i<8: \n",
    "            continue\n",
    "        patt = np.array( [  mean_zip[best[i][0]], mean_zip[best[i][1]] ] )\n",
    "        assigned_pattern = assign_pattern(patt, res) \n",
    "        assigned_pattern = best[i][assigned_pattern] \n",
    "        break\n",
    "    err.append(wrong_pixels)\n",
    "    if assigned_pattern == dgt: score += 1\n",
    "\n",
    "err = np.array(err)\n",
    "score /= 100\n",
    "print('The score of the algorithm is %f with an average error of %f' %(score, err.mean()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "err = []\n",
    "score = 0\n",
    "for n in range(len(X_zip)):\n",
    "    idx = n\n",
    "    dgt = label_test[idx]\n",
    "\n",
    "    for i in range(len(best)):\n",
    "        sys = X_zip[idx]\n",
    "        res = montecarlo(Ji[i], sys ,25 , 400)\n",
    "\n",
    "        wrong_pixels = error_im(mean_zip[dgt], res)\n",
    "\n",
    "        if wrong_pixels > 0.10 and i<8: \n",
    "            continue\n",
    "        patt = np.array( [  mean_zip[best[i][0]], mean_zip[best[i][1]] ] )\n",
    "        assigned_pattern = assign_pattern(patt, res) \n",
    "        assigned_pattern = best[i][assigned_pattern] \n",
    "        break\n",
    "    err.append(wrong_pixels)\n",
    "    if assigned_pattern == dgt: score += 1\n",
    "\n",
    "err = np.array(err)\n",
    "score /= len(X_zip)\n",
    "print('The score of the algorithm is %f with an average error of %f' %(score, err.mean()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusion \n",
    "\n",
    "In this project we underlined the capabilities and the flaws of the Hopfield model, by optimizing its parameters. \n",
    "As we expected, a similarity of the time implementation using MF and NMF was observed. On the other hand, we outlined the less fluctuations given by the MF. Moreover, we analyzed the influence of different types of noises on the performances of the algorithm, in order to get more accurate results.\n",
    "\n",
    "We concluded that the Montecarlo simulation leads to better results than the deterministic update rule, as well as a greater efficency given by a much faster implementation time.\n",
    "\n",
    "In addition, we saw that the mapping between the neural network and the physical system is well defined. According to this, we managed to describe the similarity between two patterns by using a physical quantity: the energy.\n",
    "\n",
    "After a long detailed analysis of the basic theory behind the model, we finally tried it on a real world task: the recognition of the MNIST digits. The simulation was adapted by considering sets of layers corresponding to different coupled patterns. The algorithm gives indeed amazing results after some trials: we managed to classify correctly the $90\\%$ of the digits, with an average error of $0.02\\pm 0.03$, really close and compatible to zero. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "name": "HopfieldModel.ipynb",
   "provenance": []
  },
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}