Handwritten digits recognition.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We think of this if we reach it"
   ]
  },
  {
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameters\n",
    "L = 28  # Lenght of the edge of the image\n",
    "N = L**2 # Number of spins \n",
    "p = 10 # 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": [],
   "source": [
    "# Function that are in previous notebook\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",
    "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 # Look at indexes should be ok -1\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",
    "def update(sys1):\n",
    "    sys = deepcopy(sys1)\n",
    "    N = len(sys)\n",
    "    for i in range(N):\n",
    "        temp = 0\n",
    "        for j in range(N): #Maybe it is possible to set the cycle on J[i][j]!=0 only\n",
    "            temp +=  J[i][j]*sys[j] \n",
    "        sys[i] = np.sign(temp)\n",
    "    return np.sign(sys)\n",
    "\n",
    "def deterministic_hopfield(sys1, t):\n",
    "    sys = deepcopy(sys1)\n",
    "    for i in range(t):\n",
    "        sys = update(sys)\n",
    "    return sys\n",
    "\n",
    "def error_im(xi_idx, sys):\n",
    "    wrong_pixels = (np.abs( sys-xi_idx )/2).sum()\n",
    "    return wrong_pixels/len(sys)\n",
    "\n",
    "def assign_pattern(xi,sys):\n",
    "    errors = [ error_im(i,sys) for i in xi ]\n",
    "    correct = np.argmin(errors)\n",
    "    return correct\n",
    "\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\n",
    "\n",
    "def corrupt_uniform(sys, q): # q probability to flip the pixel\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",
    "def H(J,sys):\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",
    "# Mean Field version of dH\n",
    "def dH(J, sys, k): # k is the index of the spin flipped\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",
    "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",
    "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\n",
    "\n",
    "def perpendicolar_nn(J, sys, k, r):\n",
    "    dh = 0\n",
    "    l = int(np.sqrt(sys.shape[0]))\n",
    "    for i in range(k+1,k+r+1): # going right\n",
    "        if k%l == l-1: break # right bound\n",
    "        dh += J[i][k]*sys[i]\n",
    "        if i%l == l-1: break # last column bound\n",
    "            \n",
    "    for i in range(k-1,k-r-1,-1): # going left\n",
    "        if k%l == 0: break # left bound\n",
    "        dh += J[i][k]*sys[i]\n",
    "        if i%l == 0: break # first column bound\n",
    "            \n",
    "    for i in range(k+l,k+(r+1)*l,l): # going down\n",
    "        if k//l == l-1: break # low bound\n",
    "        dh += J[i][k]*sys[i]\n",
    "        if i//l ==l-1 : break # last row bound\n",
    "            \n",
    "    for i in range(k-l, k-l*(r+1), -l): # going up\n",
    "        if k//l == 0: break # up bound\n",
    "        dh += J[i][k]*sys[i]\n",
    "        if i//l == 0: break  # first row bound\n",
    "    return dh\n",
    "            \n",
    "def diagonal_nn(J, sys, k, r):\n",
    "    dh = 0\n",
    "    l = int(np.sqrt(sys.shape[0]))\n",
    "    for i in range(1,r):\n",
    "        if k%l == l-1 or k//l == l-1: break # right low bound\n",
    "        for j in range(1,r):\n",
    "            if i==j==r-1: continue\n",
    "            dh += J[k+j+i*l][k]*sys[k+j+i*l]  # right low\n",
    "            if (k+j+i*l)%l == l-1 : break # last column bound\n",
    "        if (k+j+i*l)//l ==l-1 : break # last row bound\n",
    "        \n",
    "    for i in range(1,r):\n",
    "        if k%l == 0 or k//l == l-1: break # left low bound\n",
    "        for j in range(1,r):\n",
    "            if i==j==r-1: continue\n",
    "            dh += J[k-j+i*l][k]*sys[k-j+i*l]  # left low\n",
    "            if (k-j+i*l)%l == 0 : break #  first column bound\n",
    "        if (k-j+i*l)//l ==l-1 : break # last row bound\n",
    "        \n",
    "    for i in range(1,r):\n",
    "        if k//l == 0 or k%l == l-1: break # up right bound\n",
    "        for j in range(1,r):\n",
    "            if i==j==r-1: continue\n",
    "            dh += J[k+j-i*l][k]*sys[k+j-i*l] # right up\n",
    "            if (k+j-i*l)%l == l-1: break  # last column bound\n",
    "        if (k+j-i*l)//l == 0: break # first row bound\n",
    "        \n",
    "    for i in range(1,r):\n",
    "        if k//l == 0 or k%l == 0 : break # up left bound\n",
    "        for j in range(1,r):\n",
    "            if i==j==r-1: continue\n",
    "            dh += J[k-j-i*l][k]*sys[k-j-i*l] # left up\n",
    "            if (k-j-i*l)%l == l-1: break  #last column bound\n",
    "        if (k-j-i*l)//l == 0 : break # first row bound\n",
    "    return dh\n",
    "\n",
    "def not_MF_dH(J, sys, k, R):\n",
    "    dh = perpendicolar_nn(J, sys, k, R) + diagonal_nn(J, sys, k, R)\n",
    "    dh *= 2*sys[k]\n",
    "    return dh\n",
    "\n",
    "def not_MF_metropolis(J, sys1, k, B, R): # B = 1/kbT temperature of the system\n",
    "    sys = deepcopy(sys1)\n",
    "    dh = not_MF_dH(J, sys, k, R)\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",
    "def not_MF_montecarlo(J, sys1, B, R, 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 = not_MF_metropolis(J, sys, k, B, R)\n",
    "    return sys\n",
    "\n",
    "def corrupt_norm(sys, k, h):\n",
    "    sys_temp = deepcopy(sys)\n",
    "    N = sys.shape[0]\n",
    "    L = int(np.sqrt(N))\n",
    "    sys_temp = sys_temp.reshape(L,L)\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",
    "def gaus(mu, sigma, h, x, y):\n",
    "    h = np.sqrt(h)\n",
    "    g_x = np.exp(-( (x-mu[0])**2 / ( 2.0 * sigma**2 ) ) )*h#/np.sqrt(2*np.pi*sigma**2)\n",
    "    g_y = np.exp(-( (y-mu[1])**2 / ( 2.0 * sigma**2 ) ) )*h#/np.sqrt(2*np.pi*sigma**2)\n",
    "    g = g_y * g_x\n",
    "    return g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Just rewrite the path if you want to try it\n",
    "data_train = pd.read_csv('/Users/Marco/Desktop/data/mnist_train.csv')\n",
    "data_test = pd.read_csv('/Users/Marco/Desktop/data/mnist_test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Actually I didn't use them since they are too much\n",
    "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])\n",
    "    digits_train.append( a[0][1:] )\n",
    "\n",
    "label_train = np.array(label_train)\n",
    "digits_train = np.array(digits_train)\n",
    "X_train = from_minst_to_spin(digits_train) # from value to {-1,1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Used them even if test since less\n",
    "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])\n",
    "    digits_test.append( a[0][1:] )\n",
    "\n",
    "label_test = np.array(label_test)\n",
    "digits_test = np.array(digits_test)\n",
    "X_test = from_minst_to_spin(digits_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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( from_minst_to_spin(X_test[ label_test == i ].sum(axis=0)) )\n",
    "mean_patterns = np.array(mean_patterns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Just select random samples as patterns\n",
    "rand_patterns = []\n",
    "for i in range(10):\n",
    "    temp = X_test[ label_test == i ].shape[0]\n",
    "    temp = np.random.randint(0,temp)\n",
    "    rand_patterns.append( X_test[ label_test == i ][temp] )\n",
    "rand_patterns = np.array(rand_patterns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x116647ac8>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAKvUlEQVR4nO3dT4ic9R3H8c+n/rmoh6QZliWGrpVQCIVGGUJBEYtVYi7Ri5iDpCCsBwUFDxV7qMdQqtJDEdYaTItVCirmEFrTIIhQxFHS/DG0UVkxYc1OyMF4stFvD/NExjizO87zPPOM+32/YJiZZ2Z3vg6+MzPPzM7PESEAa98Pmh4AwGQQO5AEsQNJEDuQBLEDSVw+yRvbsGFDzM3NTfImgVQWFxd19uxZD7qsVOy2t0v6g6TLJP0pIvasdP25uTl1Op0yNwlgBe12e+hlYz+Nt32ZpD9KulPSFkm7bG8Z9/cBqFeZ1+zbJH0QER9FxBeSXpK0s5qxAFStTOwbJX3Sd/5Use0bbM/b7tjudLvdEjcHoIza98ZHxEJEtCOi3Wq16r45AEOUif20pE19568ttgGYQmVif0fSZtvX2b5S0r2S9lczFoCqjf3WW0RcsP2QpH+o99bb3og4XtlkACpV6n32iDgg6UBFswCoER+XBZIgdiAJYgeSIHYgCWIHkiB2IAliB5IgdiAJYgeSIHYgCWIHkiB2IAliB5IgdiAJYgeSIHYgCWIHkiB2IAliB5IgdiAJYgeSmOiSzVh77IGrA1ciImr73RnxyA4kQexAEsQOJEHsQBLEDiRB7EASxA4kQexAEqU+VGN7UdJ5SV9KuhAR7SqGAlC9Kj5B94uIOFvB7wFQI57GA0mUjT0kvW77Xdvzg65ge952x3an2+2WvDkA4yob+80RcaOkOyU9aPuWS68QEQsR0Y6IdqvVKnlzAMZVKvaIOF0cL0t6VdK2KoYCUL2xY7d9le1rLp6WdIekY1UNBqBaZfbGz0h6tfh75ssl/TUi/l7JVPiG1f5mnL/7xijGjj0iPpL0swpnAVAj3noDkiB2IAliB5IgdiAJYgeS4Kukp0DZr2Ne6ed5Ww4X8cgOJEHsQBLEDiRB7EASxA4kQexAEsQOJEHsQBLEDiRB7EASxA4kQexAEsQOJEHsQBLEDiRB7EASxA4kQexAEsQOJEHsQBLEDiRB7EASxA4kQexAEqvGbnuv7WXbx/q2rbd90PbJ4nhdvWMCKGuUR/bnJW2/ZNtjkg5FxGZJh4rzAKbYqrFHxJuSzl2yeaekfcXpfZLuqnguABUb9zX7TEQsFac/lTQz7Iq25213bHe63e6YNwegrNI76KK3cuDQ1QMjYiEi2hHRbrVaZW8OwJjGjf2M7VlJKo6XqxsJQB3GjX2/pN3F6d2SXqtmHAB1GeWttxcl/UvST2yfsn2/pD2Sbrd9UtIvi/MAptjlq10hInYNuei2imcBUCM+QQckQexAEsQOJEHsQBLEDiRB7EASxA4kQexAEsQOJEHsQBLEDiRB7EASxA4kQexAEsQOJEHsQBLEDiRB7EASxA4kQexAEsQOJLHqt8ti+vUW5QFWxiM7kASxA0kQO5AEsQNJEDuQBLEDSRA7kATvs0+A7e/1729Kk/9da/GzC6Osz77X9rLtY33bnrB92vbh4rCj3jEBlDXK0/jnJW0fsP3piNhaHA5UOxaAqq0ae0S8KencBGYBUKMyO+gesn2keJq/btiVbM/b7tjudLvdEjcHoIxxY39G0vWStkpakvTksCtGxEJEtCOi3Wq1xrw5AGWNFXtEnImILyPiK0nPStpW7VgAqjZW7LZn+87eLenYsOsCmA6rvs9u+0VJt0raYPuUpN9KutX2VkkhaVHSAzXOCKACq8YeEbsGbH6uhlkA1IiPywJJEDuQBLEDSRA7kASxA0nwJ65Ys9bin6mWwSM7kASxA0kQO5AEsQNJEDuQBLEDSRA7kATvs0/AWn6/t86ve17L91sTeGQHkiB2IAliB5IgdiAJYgeSIHYgCWIHkiB2IAliB5IgdiAJYgeSIHYgCWIHkiB2IAliB5IgdiCJVWO3vcn2G7bft33c9sPF9vW2D9o+WRyvq39cAOMa5ZH9gqRHI2KLpJ9LetD2FkmPSToUEZslHSrOA5hSq8YeEUsR8V5x+rykE5I2StopaV9xtX2S7qprSADlfafX7LbnJN0g6W1JMxGxVFz0qaSZIT8zb7tju9PtdkuMCqCMkWO3fbWklyU9EhGf9V8WvW8GHPjtgBGxEBHtiGi3Wq1SwwIY30ix275CvdBfiIhXis1nbM8Wl89KWq5nRABVGGVvvCU9J+lERDzVd9F+SbuL07slvVb9eACqMsr3xt8k6T5JR20fLrY9LmmPpL/Zvl/Sx5LuqWdEAFVYNfaIeEvSsJUAbqt2HAB14RN0QBLEDiRB7EASxA4kQexAEsQOJEHsQBLEDiRB7EASxA4kQexAEsQOJEHsQBLEDiRB7EASxA4kQexAEsQOJEHsQBLEDiRB7EASo3yVNDBUbzEgfB/wyA4kQexAEsQOJEHsQBLEDiRB7EASxA4kMcr67Jtsv2H7fdvHbT9cbH/C9mnbh4vDjvrHBTCuUT5Uc0HSoxHxnu1rJL1r+2Bx2dMR8fv6xgNQlVHWZ1+StFScPm/7hKSNdQ8GoFrf6TW77TlJN0h6u9j0kO0jtvfaXjfkZ+Ztd2x3ut1uqWEBjG/k2G1fLellSY9ExGeSnpF0vaSt6j3yPzno5yJiISLaEdFutVoVjAxgHCPFbvsK9UJ/ISJekaSIOBMRX0bEV5KelbStvjEBlDXK3nhLek7SiYh4qm/7bN/V7pZ0rPrxAFRllL3xN0m6T9JR24eLbY9L2mV7q6SQtCjpgVomBFCJUfbGvyXJAy46UP04AOrCJ+iAJIgdSILYgSSIHUiC2IEkiB1IgtiBJIgdSILYgSSIHUiC2IEkiB1IgtiBJIgdSMKTXHLXdlfSx32bNkg6O7EBvptpnW1a55KYbVxVzvajiBj4/W8Tjf1bN253IqLd2AArmNbZpnUuidnGNanZeBoPJEHsQBJNx77Q8O2vZFpnm9a5JGYb10Rma/Q1O4DJafqRHcCEEDuQRCOx295u+z+2P7D9WBMzDGN70fbRYhnqTsOz7LW9bPtY37b1tg/aPlkcD1xjr6HZpmIZ7xWWGW/0vmt6+fOJv2a3fZmk/0q6XdIpSe9I2hUR7090kCFsL0pqR0TjH8CwfYukzyX9OSJ+Wmz7naRzEbGn+IdyXUT8ekpme0LS500v412sVjTbv8y4pLsk/UoN3ncrzHWPJnC/NfHIvk3SBxHxUUR8IeklSTsbmGPqRcSbks5dsnmnpH3F6X3q/c8ycUNmmwoRsRQR7xWnz0u6uMx4o/fdCnNNRBOxb5T0Sd/5U5qu9d5D0uu237U93/QwA8xExFJx+lNJM00OM8Cqy3hP0iXLjE/NfTfO8udlsYPu226OiBsl3SnpweLp6lSK3muwaXrvdKRlvCdlwDLjX2vyvht3+fOymoj9tKRNfeevLbZNhYg4XRwvS3pV07cU9ZmLK+gWx8sNz/O1aVrGe9Ay45qC+67J5c+biP0dSZttX2f7Skn3StrfwBzfYvuqYseJbF8l6Q5N31LU+yXtLk7vlvRag7N8w7Qs4z1smXE1fN81vvx5REz8IGmHenvkP5T0myZmGDLXjyX9uzgcb3o2SS+q97Tuf+rt27hf0g8lHZJ0UtI/Ja2fotn+IumopCPqhTXb0Gw3q/cU/Yikw8VhR9P33QpzTeR+4+OyQBLsoAOSIHYgCWIHkiB2IAliB5IgdiAJYgeS+D9/ZWQ7czf+vAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow( rand_patterns[4].reshape(L,L), cmap='Greys' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Average pattern try\n",
    "# It does not work. Look at it if you want. I think patterns are too much similar\n",
    "# Also average patterns are not too good. \n",
    "idx = np.random.randint(0,9999)\n",
    "dgt = label_test[idx]\n",
    "\n",
    "sys = X_test[idx]\n",
    "\n",
    "res = montecarlo(J,sys,10,1000)\n",
    "\n",
    "wrong_pixels = error_im(mean_patterns[dgt],sys)\n",
    "assigned_pattern = assign_pattern(mean_patterns,sys)\n",
    "\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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "J = MF_coupling(rand_patterns,N)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Random pattern try\n",
    "# Slightly better, still not good\n",
    "\n",
    "idx = np.random.randint(0,9999)\n",
    "dgt = label_test[idx]\n",
    "\n",
    "sys = X_test[idx]\n",
    "\n",
    "#res = montecarlo(J,sys,100,10000)\n",
    "res = deterministic_hopfield(sys, 500)\n",
    "\n",
    "wrong_pixels = error_im(rand_patterns[dgt],sys)\n",
    "assigned_pattern = assign_pattern(rand_patterns,sys)\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(1,4, figsize=(10,6))\n",
    "ax[0].set_title('Original pattern')\n",
    "ax[0].imshow(rand_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(rand_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": [
    "## Zipping the images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Just thought that maybe there was too much pixels to understand the behaviour.\n",
    "# This function takes batches of four pixels and from them create a single pixel\n",
    "# that is black if even only one of that four is black.\n",
    "# This divides by 4 the resolution of the image, 28x28->14x14\n",
    "\n",
    "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": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x11a6086d8>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAAEtCAYAAADHtl7HAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAb30lEQVR4nO3de5RlZZ3e8e8TLiqXERxaFre2UQkj4xrB1SF4WQ4z4ITxhmY5RBQHvKRN4gUMSkTHAUfNGMfrxAnaAoKCqEG8Bg0EJcQJkmkQpaHxhtwbaEQEdZaK/PLH2e0cy7qcXVV99j59vp+1atU579nn7F/tqnrrqXe/+z2pKiRJkjS6f9Z1AZIkSZPGACVJktSSAUqSJKklA5QkSVJLBihJkqSWDFCSJEktGaCmQJI3Jjl9ubcd4bUqyWOX47UkaViSLyU5toP9nprknBbb/7ofTPLBJG8e8Xkjb6tuxHWgJkuS44ATgccA9wGfAU6uqnu7rGs2SQrYr6q+t8yvexZwa1X9xVDbjcDLq+p/Lee+JI1fkhcBH5rloR2BU6rqr8Zc0q8lORV4bFUdM+L2S+4HkxwKnFNVey/2NbT8HIGaIElOBP4L8Hrg4cAhwKOAi5NsP8dzth1fhZMpA/4uSD1RVedW1U7DH8AJwJ3AhzsuTwIMUBMjye8AbwFeXVVfrqpfVtWNwFHAKuCYZrtTk5yf5Jwk9wHHzRxyTvLnSW5K8sMkb05yY5LDh55/TnN7VTP8fGySm5PcneRNQ69zcJLLk9ybZGOSD8wV5Gb5ei5N8tdJ/l+S+5J8Lskjhh7/70nuSPLjJJcl+f2mfQ3wIuCkJD9J8oUkHwNWAl9o2k5qtj0kyf9t6vtm81/c8P7fnuTvgZ8Bj27a3prk75Pcn+SiJLu1/FZJWmZJDgLeB7ygqjY2bZcmeXlz+7jm9/YDTZ9xfZLDhp6/UH8zX1+xb5L/3fQJFwPz9glJXt/0h7cneemMx85K8rah+ycNbfvyGaf7zkrytiQ7Al8C9mz6t58k2XPxR1PLxQA1OZ4MPBS4YLixqn4CXAg8faj5SOB8YBfg3OHtkxwA/DcGIWQPBiNZey2w76cC+wOHAX+Z5HFN+6+A1zLoUJ7UPP4fWnxNfw68tKnjAeBvhx77ErAf8Ejgqs1fR1WtbW6/s/nP9NlV9WLgZuDZTds7k+wF/A/gbcAjgNcBn06yYmgfLwbWADsDNzVtLwRe0ux3++Z5kjqSZBcG/dlbq+rSeTb9l8D3GfRHpwAXDIck5uhvRugrPg5c2bzuW4E5510lOaJ5/tMZ9F+HL7Dtf2y2eSxw6GzbVdVPgT8Fbh8akbt9rtfV+BigJsduwN1V9cAsj23kN/8ruryqPltVD1bVP87Y9vnAF6rqa1X1C+AvgYUmwr2lqv6xqr4JfBN4AkBVXVlVX6+qB5rRsA8Bf9jia/pYVa1vOog3A0cl2aZ57TOr6v6q+jlwKvCEJA9v8drHABdW1YXNcbgYWAc8Y2ibs6rq2qb+XzZtH6mq7zTH7VPAgS32KWkZJQnwUWA98M4FNr8LeF8zOv9J4NvAM4cen6u/mbOvSLIS+BfAm6vq51V1GfCFeWo4ikEfsnk/p46w7bVV9bMFtlUPGaAmx93AbnPMadqjeXyzW+Z5nT2HH29+cX+4wL7vGLr9M2AngCT/PMkXm1Nt9wH/mQWGt2cYrvMmYDsGX+M2Sd6R5PvN697YbNPmtR8F/FkzJH9vknsZjKTtMcf+N5v1a5XUif8E/D5wbC18xdNtM7a5iUF/t9ms/Q3z9xV7Aj9qwtDwc+fyG/1ry23n67fVQwaoyXE58HPgXw83JtmJwfDuJUPN83U0G4FfX8mR5GHA7y6yptOA6xlcYfI7wBuBtHj+PkO3VwK/ZBAEX8jgNOThDE4xrtpcbvN5tq9vZtstDP7j3GXoY8eqesc8z5HUE808pDcBzx/xKuO9mhGrzVYCw6e65upv5usrNgK7NvOQhp87l42z7Ge+bYevqttnrg2xr+olA9SEqKofM5hE/l+THJFkuySrGJxmuhX42IgvdT7w7CRPbiZ8n0q70DNsZwZLKfwkye8B/77l849JckCSHYC/As6vql81r/tzBiNjOzAY2Rp2J/DoBdrOYfB1/qtmROuhSQ5N4mXAUs8l2QP4BHBCVX1jxKc9EnhN0zf+GfA4BvNDN5urv5mzr6iqmxiczntLku2TPBV49jw1fIrBhTub93PKAtu+JMnjmm3nW/PpTuB3W05j0BZmgJogVfVOBqM872IQXK5g8N/TYc1coVFe41rg1Qw6p43ATxjMHRjp+TO8jsFo0f0MLi3+ZMvnfww4i8Fps4cCr2naP8pg6Ps24Drg6zOedwZwQDPc/tmm7a+Bv2jaXldVtzAYxXojsInBcXo9/sxLk+DfArsD7x+68mzzxwfneM4VDCZu3w28ncHI1fD0hFn7mxH6ihcymKB+D4NA9NG5iq6qLzG4WvArwPeaz/Nt+7fAV5ttN/dzv9UXV9X1wHnADU0f51V4PeBCmlOuOQV4L4PTcD8Y434vZbAw3LKsei5pemWwwPDLq+qpczx+KT3vb5qrm9cDD5njYiH1jP+NT6Ekz06yQ3Ne/13ANfzTRG1J0hgkeV6ShyTZlcEiyV8wPE0OA9R0OpLB5MrbGQx5v2CEK1wkScvrFQymUHyfwbp6beeRqkOewpMkSWrJEShJkqSWDFCSJEktzbaq9Raz22671apVq8a5S0kdu/LKK++uqhULb9lv9l/S9Jmv/1pSgGreDPH9wDbA6TNWef4tq1atYt26dUvZpaQJk2S+t7OYGPZf0vSZr/9a9Cm85k0Y/47B24gcAByd5IDFvp4kSdKkWMocqIOB71XVDVX1CwYrWx+5PGVJkiT111IC1F785rtH39q0SZIkbdW2+FV4SdYkWZdk3aZNm7b07iRpZM0bc387yfeSvKHreiRNjqUEqNuAfYbu7920/YaqWltVq6tq9YoVE38hjqSthPM4JS3FUgLUPwD7Jdk3yfbAC4DPL09ZkrTFOY9T0qItOkA1b3j4KuB/AhuAT1XVtctVmCRtYc7jlLRoS1oHqqouBC5cplokqVeSrAHWAKxcubLjaiT1iW/lImlaLTiP0zmckuZigJI0rZzHKWnRxvpeeJLUF1X1QJLN8zi3Ac50HqekURmgJE0t53FKWixP4UmSJLVkgJIkSWrJACVJktSSAUqSJKklA5QkSVJLBihJkqSWDFCSJEktGaAkSZJaMkBJkiS1ZICSJElqyQAlSZLUkgFKkiSpJQOUJElSSwYoSZKklgxQkiRJLRmgJEmSWjJASZIktWSAkiRJaskAJUmS1JIBSpIkqSUDlCRJUksGKEmSpJa27boASZL6LEnXJWwRVdV1CRPNEShJkqSWDFCSJEktGaAkSZJaMkBJkiS1ZICSNJWS7JPkq0muS3JtkuO7rknS5PAqPEnT6gHgxKq6KsnOwJVJLq6q67ouTFL/OQIlaSpV1caquqq5fT+wAdir26okTQoDlKSpl2QVcBBwRbeVSJoUnsLTWEziQnQuMjcdkuwEfBo4oarum/HYGmANwMqVKzuoTlJfLWkEKsmNSa5JcnWSdctVlCSNQ5LtGISnc6vqgpmPV9XaqlpdVatXrFgx/gIl9dZyjED9UVXdvQyvI0ljk8Gw6BnAhqp6T9f1SJoszoGSNK2eArwY+ONmFP3qJM/ouihJk2GpI1AFXJSkgA9V1dplqEmStriq+howeZPzJPXCUgPUU6vqtiSPBC5Ocn1VXTa8gZMwJUnS1mZJp/Cq6rbm813AZ4CDZ9nGSZiSJGmrsugAlWTHZvVekuwI/AmwfrkKkyRJ6qulnMLbHfhMs77PtsDHq+rLy1KVJElSjy06QFXVDcATlrEWTahJXCRzFKN8XS62KS2/rbVP6ZvlPM7T2Be6jIEkSVJLBihJkqSWDFCSJEktGaAkSZJaMkBJkiS1ZICSJElqyQAlSZLUkgFKkiSppaW+mbAmmIvVLZ2LbUrSdHIESpIkqSUDlCRJUksGKEmSpJYMUJIkSS0ZoCRJkloyQEmSJLVkgJIkSWrJACVJktSSAUqSJKklVyLfSvVtlfFRVuNerprHua9RjLovVyzXpOtbv6PxGWf/3ReOQEmSJLVkgJIkSWrJACVJktSSAUqSJKklA5SkqZZkmyTfSPLFrmuRNDkMUJKm3fHAhq6LkDRZDFCSplaSvYFnAqd3XYukyWKAkjTN3gecBDzYdSGSJosLaU6gvi1Wt1wLn41zAbW+LbY56v4maZG5vkvyLOCuqroyyaFzbLMGWAOwcuXKMVYnqe8cgZI0rZ4CPCfJjcAngD9Ocs7wBlW1tqpWV9XqFStWdFGjpJ4yQEmaSlV1clXtXVWrgBcAX6mqYzouS9KEMEBJkiS15BwoSVOvqi4FLu24DEkTxBEoSZKklgxQkiRJLRmgJEmSWjJASZIktbTgJPIkZwKbF5x7fNP2COCTwCrgRuCoqvrRlitTXZnmhRv7uNimpNFNc/81CvuvpRllBOos4IgZbW8ALqmq/YBLmvuSJElTYcEAVVWXAffMaD4SOLu5fTbw3GWuS5IkqbcWOwdq96ra2Ny+A9h9meqRJEnqvSVPIq/BSeY5TzQnWZNkXZJ1mzZtWuruJEmSOrfYAHVnkj0Ams93zbWhb8YpSZK2NosNUJ8Hjm1uHwt8bnnKkSRJ6r8FA1SS84DLgf2T3JrkZcA7gKcn+S5weHNfkiRpKiy4DlRVHT3HQ4ctcy2SJEkTYcEApfFyYbPJ4mKbkjSdfCsXSZKklgxQkiRJLRmgJEmSWjJASZIktWSAkiRJaskAJUmS1JIBSpIkqSUDlCRJUksupDnFRlkEUtLWzYVepcVxBEqSJKklA5QkSVJLBihJkqSWDFCSJEktGaAkTa0kuyQ5P8n1STYkeVLXNUmaDF6FJ2mavR/4clU9P8n2wA5dFyRpMhigJE2lJA8HngYcB1BVvwB+0WVNkiaHp/AkTat9gU3AR5J8I8npSXbsuihJk8EANSZJRvpYLlW14Ic05bYFngicVlUHAT8F3jC8QZI1SdYlWbdp06YuapTUUwYoSdPqVuDWqrqiuX8+g0D1a1W1tqpWV9XqFStWjL1ASf1lgJI0larqDuCWJPs3TYcB13VYkqQJ4iRySdPs1cC5zRV4NwAv6bgeSRPCACVpalXV1cDqruuQNHk8hSdJktSSAUqSJKklA5QkSVJLBihJkqSWnEQuSeoVF/rVJHAESpIkqSUDlCRJUksGKEmSpJYMUJIkSS0ZoCRJkloyQEmSJLVkgJIkSWrJACVJktSSAUqSJKmlBQNUkjOT3JVk/VDbqUluS3J18/GMLVumJElSf4wyAnUWcMQs7e+tqgObjwuXtyxJkqT+WjBAVdVlwD1jqEWSJGkiLGUO1KuSfKs5xbfrslUkSZLUc4sNUKcBjwEOBDYC755rwyRrkqxLsm7Tpk2L3J0kSVJ/LCpAVdWdVfWrqnoQ+DBw8Dzbrq2q1VW1esWKFYutU5IkqTcWFaCS7DF093nA+rm2lSRJ2tpsu9AGSc4DDgV2S3IrcApwaJIDgQJuBF6xBWuUJEnqlQUDVFUdPUvzGVuglomVpOsSJEnSGLkSuSRJUksGKEmSpJYMUJIkSS0ZoCRJkloyQEmaWklem+TaJOuTnJfkoV3XJGkyGKAkTaUkewGvAVZX1eOBbYAXdFuVpElhgJI0zbYFHpZkW2AH4PaO65E0IQxQkqZSVd0GvAu4mcF7ev64qi7qtipJk8IAJS1BkgU/1E9JdgWOBPYF9gR2THLMjG18M3RJszJASZpWhwM/qKpNVfVL4ALgycMb+GbokuZigJI0rW4GDkmyQwZDhYcBGzquSdKEMEBJmkpVdQVwPnAVcA2D/nBtp0VJmhgLvpmwJG2tquoU4JSu65A0eRyBkiRJaskAJUmS1JIBSpIkqSUDlCRJUktOIl8GVbXgNi6oKElaDv496QdHoCRJkloyQEmSJLVkgJIkSWrJACVJktSSAUqSJKklA5QkSVJLBihJkqSWDFCSJEktuZCmNIdxL1Y3yoKskqR+cARKkiSpJQOUJElSSwYoSZKklgxQkiRJLRmgJEmSWjJASZIktWSAkiRJaskAJUmS1JILaY7JqIskLtfijaO8zjQv3DjORTKn+Tir/5bz53Oc/dco+va7N+7Fecepb8d6HBYcgUqyT5KvJrkuybVJjm/aH5Hk4iTfbT7vuuXLlSRJ6t4op/AeAE6sqgOAQ4BXJjkAeANwSVXtB1zS3JckSdrqLRigqmpjVV3V3L4f2ADsBRwJnN1sdjbw3C1VpCRJUp+0mkSeZBVwEHAFsHtVbWweugPYfVkrkyRJ6qmRA1SSnYBPAydU1X3Dj9Vg9tisM8iSrEmyLsm6TZs2LalYSWoryZlJ7kqyfqjNOZySlmSkAJVkOwbh6dyquqBpvjPJHs3jewB3zfbcqlpbVauravWKFSuWo2ZJauMs4IgZbc7hlLQko1yFF+AMYENVvWfooc8Dxza3jwU+t/zlSdLSVNVlwD0zmp3DKWlJRlkH6inAi4FrklzdtL0ReAfwqSQvA24CjtoyJUrSsnMOp6QlWTBAVdXXgLlW/zpsecvROE3iYptb80J06kZVVZI553ACawBWrlw51rok9Ztv5SJpGjmHU9KSGKAkTSPncEpaEgOUpK1akvOAy4H9k9zazNt8B/D0JN8FDm/uS9LIfDNhSVu1qjp6joecwylp0RyBkiRJaskAJUmS1JIBSpIkqSUDlCRJUksGKEmSpJa8Cq9nRln5e5yrcU/zyt99W4VdUjvT3H+Nwj5uaRyBkiRJaskAJUmS1JIBSpIkqSUDlCRJUksGKEmSpJYMUJIkSS0ZoCRJkloyQEmSJLXkQpoTqG+LbUqSNG0cgZIkSWrJACVJktSSAUqSJKklA5QkSVJLBihJkqSWDFCSJEktGaAkSZJaMkBJkiS15EKaW6lRFtscxSQuyLlcX7ukdvr2uzeJ/dco+nacp5UjUJIkSS0ZoCRJkloyQEmSJLVkgJIkSWrJACVpq5bkzCR3JVk/1PY3Sa5P8q0kn0myS5c1Spo8BihJW7uzgCNmtF0MPL6q/gD4DnDyuIuSNNkMUJK2alV1GXDPjLaLquqB5u7Xgb3HXpikiWaAkjTtXgp8qesiJE2WBQNUkn2SfDXJdUmuTXJ8035qktuSXN18PGPLl6txq6qJ+5BGleRNwAPAuXM8vibJuiTrNm3aNN7iJPXaKCuRPwCcWFVXJdkZuDLJxc1j762qd2258iRpy0hyHPAs4LCaI3lX1VpgLcDq1atN55J+bcEAVVUbgY3N7fuTbAD22tKFSdKWkuQI4CTgD6vqZ13XI2nytJoDlWQVcBBwRdP0quYy4DOT7LrMtUnSkiU5D7gc2D/JrUleBnwA2Bm4uJmC8MFOi5Q0cUZ+M+EkOwGfBk6oqvuSnAa8Fajm87sZTMac+bw1wBqAlStXLkfNkjSyqjp6luYzxl6IpK3KSCNQSbZjEJ7OraoLAKrqzqr6VVU9CHwYOHi251bV2qpaXVWrV6xYsVx1S5IkdWaUq/DC4L+1DVX1nqH2PYY2ex6wfuZzJUmStkajnMJ7CvBi4JokVzdtbwSOTnIgg1N4NwKv2CIVSpIk9cwoV+F9DcgsD124/OVIkiT138iTyCVJmiQurKstybdykSRJaskAJUmS1JIBSpIkqSUDlCRJUksGKEmSpJYMUJIkSS0ZoCRJkloyQEmSJLVkgJIkSWrJACVJktSSAUqSJKklA5QkSVJLBihJkqSWDFCSJEktGaAkSZJaMkBJkiS1ZICSJElqKVU1vp0lm4Cbhpp2A+4eWwHLZxLrtubxmcS6t2TNj6qqFVvotcdmlv5rNn383vetJuuZX9/qgf7VNM565uy/xhqgfmvnybqqWt1ZAYs0iXVb8/hMYt2TWHMf9fE49q0m65lf3+qB/tXUl3o8hSdJktSSAUqSJKmlrgPU2o73v1iTWLc1j88k1j2JNfdRH49j32qynvn1rR7oX029qKfTOVCSJEmTqOsRKEmSpInTWYBKckSSbyf5XpI3dFVHG0luTHJNkquTrOu6nrkkOTPJXUnWD7U9IsnFSb7bfN61yxpnmqPmU5Pc1hzvq5M8o8saZ0qyT5KvJrkuybVJjm/ae3us56m518d6EvSpT5vr+9y1JNsk+UaSL3ZdC0CSXZKcn+T6JBuSPKnjel7bfL/WJzkvyUPHvP/e/e2Yo6a/ab5n30rymSS7jLOmzToJUEm2Af4O+FPgAODoJAd0Ucsi/FFVHdiHSyjncRZwxIy2NwCXVNV+wCXN/T45i9+uGeC9zfE+sKouHHNNC3kAOLGqDgAOAV7Z/Bz3+VjPVTP0+1j3Wg/7tPm+z106HtjQdRFD3g98uap+D3gCHdaWZC/gNcDqqno8sA3wgjGXcRb9+9sxW00XA4+vqj8AvgOcPOaagO5GoA4GvldVN1TVL4BPAEd2VMtWp6ouA+6Z0XwkcHZz+2zguWMtagFz1NxrVbWxqq5qbt/PoPPdix4f63lq1tL0qk/r4/c5yd7AM4HTu6xjsyQPB54GnAFQVb+oqnu7rYptgYcl2RbYAbh9nDvv49+O2Wqqqouq6oHm7teBvcdZ02ZdBai9gFuG7t/KZHTiBVyU5Moka7oupqXdq2pjc/sOYPcui2nhVc0w7Zl9OhU2U5JVwEHAFUzIsZ5RM0zIse6p3vZps3yfu/I+4CTgwY7r2GxfYBPwkea04ulJduyqmKq6DXgXcDOwEfhxVV3UVT1D+t6fvRT4Uhc7dhJ5O0+tqicyGKZ/ZZKndV3QYtTg0stJuPzyNOAxwIEMOpR3d1vO7JLsBHwaOKGq7ht+rK/HepaaJ+JYq535fjbHXMezgLuq6squapjFtsATgdOq6iDgp3R4ur35p+VIBsFuT2DHJMd0Vc9s+tafJXkTg9PV53ax/64C1G3APkP3927aeq35D4Gqugv4DINh+0lxZ5I9AJrPd3Vcz4Kq6s6q+lVVPQh8mB4e7yTbMfgDdW5VXdA09/pYz1bzJBzrnutdnzbHz2ZXngI8J8mNDE5v/nGSc7otiVuBW6tq88jc+QwCVVcOB35QVZuq6pfABcCTO6xns172Z0mOA54FvKg6Wo+pqwD1D8B+SfZNsj2DiXKf76iWkSTZMcnOm28DfwKsn/9ZvfJ54Njm9rHA5zqsZSSbf2kbz6NnxztJGMyf2FBV7xl6qLfHeq6a+36sJ0Cv+rR5fjY7UVUnV9XeVbWKwbH5SlV1OrpSVXcAtyTZv2k6DLiuw5JuBg5JskPz/TuMfky4711/luQIBqeDn1NVP+usjq4W0mwuk34fgysNzqyqt3dSyIiSPJrBqBMMhn4/3teak5wHHMrgHavvBE4BPgt8CljJ4B3lj6qq3kzanqPmQxmcUirgRuAVQ+fiO5fkqcD/Aa7hn+Z1vJHBXJNeHut5aj6aHh/rSdCnPm2u73Mfrq5Mcijwuqp6Vg9qOZDBpPbtgRuAl1TVjzqs5y3Av2FwWuobwMur6udj3H/v/nbMUdPJwEOAHzabfb2q/t24avp1ba5ELkmS1I6TyCVJkloyQEmSJLVkgJIkSWrJACVJktSSAUqSJKklA5QkSVJLBihJkqSWDFCSJEkt/X+lhZaPO1plyAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Simply look at the outcome\n",
    "idx = 100\n",
    "dgt = label_test[idx]\n",
    "sys = X_test[idx]\n",
    "\n",
    "zip_dgt = zipping(sys)\n",
    "\n",
    "fig, ax = plt.subplots(1,2, figsize=(10,6))\n",
    "ax[0].set_title('Original pattern')\n",
    "ax[0].imshow(sys.reshape(L,L),cmap='Greys')\n",
    "ax[1].set_title('Zipped digit')\n",
    "ax[1].imshow(zip_dgt.reshape(L//2,L//2),cmap='Greys')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Yeah, you know I really love to use the word stuff. I was only upset that this \n",
    "# stuff wasn't working. Here I zip all the test 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": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Inizialize the old variables using the new zipped samples.\n",
    "\n",
    "rand_patterns = []\n",
    "for i in range(10):\n",
    "    temp = X_zip[ label_test == i ].shape[0]\n",
    "    temp = np.random.randint(0,temp)\n",
    "    rand_patterns.append( X_zip[ label_test == i ][temp] )\n",
    "rand_patterns = np.array(rand_patterns)\n",
    "\n",
    "n = N//4\n",
    "J = R_coupling(rand_patterns[0:3],n,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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(rand_patterns[dgt],new)\n",
    "assigned_pattern = assign_pattern(rand_patterns,new)\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(1,4, figsize=(10,6))\n",
    "ax[0].set_title('Original pattern')\n",
    "ax[0].imshow(rand_patterns[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(rand_patterns[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": [
    "# Find the real minima of the system"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First I create 1000 random samples\n",
    "X_created = []\n",
    "for i in range(1000):\n",
    "    X_created.append( 2*np.random.randint(0,2,14*14)-1 )\n",
    "\n",
    "# The I run the algorithm for all of them, 500 iterations each\n",
    "X_hop = X_created\n",
    "for i in range(1000):\n",
    "    X_hop[i] = montecarlo(J, X_created[i], 25, 500)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ciao\n",
      "ciao\n",
      "ciao\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/ipykernel_launcher.py:7: DeprecationWarning: In future, it will be an error for 'np.bool_' scalars to be interpreted as an index\n",
      "  import sys\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "index 0 is out of bounds for axis 0 with size 0",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-97-fca6bb0359e4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mX_min\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdeepcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_hop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mwhile\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_hop\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m     \u001b[0mminima\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_min\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      7\u001b[0m     \u001b[0mX_min\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mX_min\u001b[0m\u001b[0;34m[\u001b[0m \u001b[0merror_im\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_min\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mX_min\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0.1\u001b[0m \u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'ciao'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mIndexError\u001b[0m: index 0 is out of bounds for axis 0 with size 0"
     ]
    }
   ],
   "source": [
    "# Now I look at the errors between each of them. I store all of them with error \n",
    "# greater than a certain amount.\n",
    "minima = []\n",
    "X_min = deepcopy(X_hop)\n",
    "while( len(X_hop) != 0 ):\n",
    "    minima.append(X_min[0])\n",
    "    X_min = X_min[ error_im(X_min[0],X_min) > 0.1 ]\n",
    "    print('ciao')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  1,\n",
       "       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n",
       "       -1,  1,  1,  1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  1,  1,  1,\n",
       "        1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  1,  1,  1,  1, -1, -1, -1,\n",
       "       -1, -1, -1, -1, -1, -1,  1,  1,  1,  1,  1,  1, -1, -1, -1, -1, -1,\n",
       "       -1, -1, -1, -1, -1,  1, -1,  1,  1, -1, -1, -1, -1, -1, -1,  1, -1,\n",
       "       -1, -1,  1,  1,  1,  1,  1, -1, -1, -1, -1, -1, -1, -1, -1,  1,  1,\n",
       "        1,  1,  1,  1, -1, -1, -1, -1, -1, -1, -1,  1,  1,  1,  1,  1,  1,\n",
       "        1, -1, -1, -1, -1, -1, -1, -1,  1,  1,  1,  1,  1,  1,  1, -1, -1,\n",
       "       -1, -1, -1, -1, -1,  1,  1,  1,  1, -1, -1,  1, -1, -1, -1, -1, -1,\n",
       "       -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n",
       "       -1, -1, -1, -1, -1,  1, -1, -1, -1])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minima[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# And now I can look at the true minima of the system:\n",
    "for i in range(0,len(minima),2):\n",
    "    plt.imshow( minima[i].reshape(14,14), cmap='Greys' )\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "err = []\n",
    "patt = []\n",
    "diff = []\n",
    "\n",
    "for n in range(100):\n",
    "    idx = np.random.randint(0,9999)\n",
    "    dgt = label_test[idx]\n",
    "    sys = X_zip[idx]\n",
    "    res = montecarlo(J,sys,100,1000)\n",
    "    inv = error_im(new ,res)\n",
    "    diff.append(inv)\n",
    "    wrong_pixels = error_im(rand_patterns[dgt],res)\n",
    "    err.append(wrong_pixels)\n",
    "    assigned_pattern = assign_pattern(rand_patterns,res)\n",
    "    patt.append(assigned_pattern)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "err = np.array(err)\n",
    "diff = np.array(diff)\n",
    "patt = np.array(patt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hopfield-chain algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.  , 0.3 , 0.26, 0.23, 0.24, 0.29, 0.24, 0.29, 0.22, 0.24],\n",
       "       [0.3 , 0.  , 0.24, 0.15, 0.12, 0.29, 0.19, 0.15, 0.18, 0.18],\n",
       "       [0.26, 0.24, 0.  , 0.22, 0.22, 0.35, 0.15, 0.31, 0.23, 0.25],\n",
       "       [0.23, 0.15, 0.22, 0.  , 0.22, 0.25, 0.2 , 0.21, 0.15, 0.22],\n",
       "       [0.24, 0.12, 0.22, 0.22, 0.  , 0.29, 0.14, 0.19, 0.16, 0.17],\n",
       "       [0.29, 0.29, 0.35, 0.25, 0.29, 0.  , 0.29, 0.29, 0.23, 0.26],\n",
       "       [0.24, 0.19, 0.15, 0.2 , 0.14, 0.29, 0.  , 0.21, 0.16, 0.17],\n",
       "       [0.29, 0.15, 0.31, 0.21, 0.19, 0.29, 0.21, 0.  , 0.21, 0.13],\n",
       "       [0.22, 0.18, 0.23, 0.15, 0.16, 0.23, 0.16, 0.21, 0.  , 0.16],\n",
       "       [0.24, 0.18, 0.25, 0.22, 0.17, 0.26, 0.17, 0.13, 0.16, 0.  ]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# First we want to abbine the most different patterns.\n",
    "# We compute so an \"error matrix\"\n",
    "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(rand_patterns[i], rand_patterns[j]),2) )\n",
    "err_mat = np.array(err_mat).reshape(10,10)\n",
    "err_mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 5],\n",
       "       [2, 7],\n",
       "       [2, 8],\n",
       "       [3, 5],\n",
       "       [4, 5],\n",
       "       [5, 6],\n",
       "       [5, 9]])"
      ]
     },
     "execution_count": 19,
     "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",
    "best "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Computing the couplings for the various connections\n",
    "Ji = []\n",
    "for i in best:\n",
    "    patt = np.array( [  rand_patterns[i[0]], rand_patterns[i[1]] ] )\n",
    "    Ji.append( R_coupling( patt ,N//4, 7) ) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x11f3794a8>"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow( treee[2].reshape(14,14), cmap='Greys' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Average for each digits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-55-e6257bb9e3b4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     24\u001b[0m                     \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m         \u001b[0mtemp_err\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtemp_err\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m         \u001b[0merr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mtemp_err\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     27\u001b[0m         \u001b[0merr_dev\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mtemp_err\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "# Look at different digit convergenge 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",
    "for i in range(3,4): # 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(rand_patterns[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": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Speed of convergence for each digit')"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "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": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The error of the algorithm is 0.000000\n",
      "The algorithm recognised the pattern 3 and the correct pattern is 3\n"
     ]
    }
   ],
   "source": [
    "# Try with just one sample\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 , 1000)\n",
    "\n",
    "    wrong_pixels = error_im(rand_patterns[dgt], res)\n",
    "\n",
    "    if wrong_pixels > 0.10 and i<8: \n",
    "        continue\n",
    "    patt = np.array( [  rand_patterns[best[i][0]], rand_patterns[best[i][1]] ] )\n",
    "    assigned_pattern = assign_pattern(patt, res) \n",
    "    assigned_pattern = best[i][assigned_pattern] \n",
    "    break\n",
    "\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": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "err = []\n",
    "score = 0\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 , 500)\n",
    "\n",
    "        wrong_pixels = error_im(rand_patterns[dgt], res)\n",
    "\n",
    "        if wrong_pixels > 0.10 and i<8: \n",
    "            continue\n",
    "        patt = np.array( [  rand_patterns[best[i][0]], rand_patterns[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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The score of the algorithm is 0.890000 with an average error of 0.030102\n"
     ]
    }
   ],
   "source": [
    "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": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The score of the algorithm is 0.933893 with an average error of 0.027611\n"
     ]
    }
   ],
   "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 , 500)\n",
    "\n",
    "        wrong_pixels = error_im(rand_patterns[dgt], res)\n",
    "\n",
    "        if wrong_pixels > 0.10 and i<8: \n",
    "            continue\n",
    "        patt = np.array( [  rand_patterns[best[i][0]], rand_patterns[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": [
    "## Old, non-optimized version of the hopfield-chain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "The error of the algorithm is 0.000000\n",
      "The algorithm recognised the pattern 0 and the correct pattern is 0\n"
     ]
    }
   ],
   "source": [
    "idx = np.random.randint(0,9999)\n",
    "dgt = label_test[idx]\n",
    "\n",
    "for i in range(0,10,2):\n",
    "    #sys = X_zip[idx]\n",
    "    sys = corrupt_norm(X_zip[idx], [L//4,L//4], 0.2 )\n",
    "    res = montecarlo(Ji[i//2],sys ,25 , 1000)\n",
    "\n",
    "    wrong_pixels = error_im(rand_patterns[dgt],res)\n",
    "    print(i)\n",
    "    if wrong_pixels > 0.10 and i<8: \n",
    "        continue\n",
    "    assigned_pattern = assign_pattern(rand_patterns[i:i+2],res) \n",
    "    #print(assigned_pattern)\n",
    "    assigned_pattern += i\n",
    "    #print(assigned_pattern)\n",
    "    break\n",
    "\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": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [],
   "source": [
    "err = []\n",
    "score = 0\n",
    "for n in range(100):\n",
    "    idx = np.random.randint(0,9999)\n",
    "    dgt = label_test[idx]\n",
    "\n",
    "    for i in range(0,10,2):\n",
    "        sys = X_zip[idx]\n",
    "        #sys = corrupt_norm(X_zip[idx], [L//4,L//4], 0.2 )\n",
    "        res = montecarlo(Ji[i//2],sys ,25 , 1000)\n",
    "        wrong_pixels = error_im(rand_patterns[dgt],res) \n",
    "        \n",
    "        if wrong_pixels > 0.10 and i<8: \n",
    "            continue\n",
    "            \n",
    "        assigned_pattern = assign_pattern(rand_patterns[i:i+2],res) \n",
    "        assigned_pattern += i\n",
    "        break\n",
    "    err.append(wrong_pixels)\n",
    "    if assigned_pattern == dgt: score += 1\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The score of the algorithm is 0.700000 with an average error of 0.056684\n"
     ]
    }
   ],
   "source": [
    "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": "markdown",
   "metadata": {},
   "source": [
    "# Error with vicinanza"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "def w_error(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 = []\n",
    "    wrong2 = []\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 : \n",
    "                wrong1.append( np.array([i,j]) )\n",
    "            elif sys2[i][j]== 1:\n",
    "                wrong2.append( np.array([i,j]) )\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",
    "        if len(distances)==0 : min_dist.append(np.exp(1000))\n",
    "        else: min_dist.append( np.array(distances).min() )\n",
    "    min_dist = np.array(min_dist)\n",
    "    err =  (1/(min_dist)**alpha).sum()\n",
    "    err /= (N+1)//2\n",
    "    return err\n",
    "\n",
    "def tot_err(sys11, sys22):\n",
    "    err = error_im(sys11, sys22) + 2*w_error(sys11, sys22, 2)\n",
    "    return err/2\n",
    "\n",
    "def assign_digit(xi,sys):\n",
    "    errors = [ tot_err(i,sys) for i in xi ]\n",
    "    correct = np.argmin(errors)\n",
    "    return correct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First we want to abbine the most different patterns.\n",
    "# We compute so an \"error matrix\"\n",
    "err_mat = []\n",
    "for i in range(10):\n",
    "    err_mat.append([])\n",
    "    for j in range(10):\n",
    "        err_mat[i].append( round(tot_err(rand_patterns[i], rand_patterns[j]),2) )\n",
    "err_mat = np.array(err_mat).reshape(10,10)\n",
    "\n",
    "# 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",
    "# Computing the couplings for the various connections\n",
    "Ji = []\n",
    "for i in best:\n",
    "    patt = np.array( [  rand_patterns[i[0]], rand_patterns[i[1]] ] )\n",
    "    Ji.append( R_coupling( patt ,N//4, 7) ) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/ipykernel_launcher.py:23: RuntimeWarning: overflow encountered in exp\n"
     ]
    }
   ],
   "source": [
    "# Look at different digit convergenge 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",
    "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 = tot_err(rand_patterns[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": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Speed of convergence for each digit')"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "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": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/ipykernel_launcher.py:23: RuntimeWarning: overflow encountered in exp\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The score of the algorithm is 0.910000 with an average error of 0.024372\n"
     ]
    }
   ],
   "source": [
    "err = []\n",
    "score = 0\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 , 450)\n",
    "\n",
    "        wrong_pixels = tot_err(rand_patterns[dgt], res)\n",
    "\n",
    "        if wrong_pixels > 0.1 and i<8: \n",
    "            continue\n",
    "        patt = np.array( [  rand_patterns[best[i][0]], rand_patterns[best[i][1]] ] )\n",
    "        assigned_pattern = assign_digit(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": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}