3.Hopfield.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hopfield 🫠\n",
    "\n",
    "https://towardsdatascience.com/hopfield-networks-neural-memory-machines-4c94be821073\n",
    "\n",
    "To use an Hopfield Network for a Binary image classification task we stored in the network some labeled patterns and then predict the label of a new image with the label of the pattern to which it converges."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import seaborn as sns\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pygame 2.1.2 (SDL 2.0.18, Python 3.10.2)\n",
      "Hello from the pygame community. https://www.pygame.org/contribute.html\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pathlib\n",
    "\n",
    "from tqdm import tqdm\n",
    "import random\n",
    "import pygame\n",
    "from scipy.spatial import distance\n",
    "\n",
    "import tensorflow as tf\n",
    "from keras import utils, layers\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.spatial import distance\n",
    "\n",
    "def H2(a ,b):\n",
    "    return (2 * distance.hamming(a, b) - 1) ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hopfield Class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definition of the Hopfield network class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Hopfield_Net:\n",
    "    \"\"\"\n",
    "    n (int): number of neurons / pixel\n",
    "    state (ndarray): state to work on\n",
    "    energies (list): history of energy\n",
    "    pointer (int): track neuron execution\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, input):\n",
    "\n",
    "        # patterns for network training / retrieval\n",
    "        self.memory = np.array(input)\n",
    "        # single vs. multiple memories\n",
    "        if self.memory.size > 1:\n",
    "            self.n = self.memory.shape[1]\n",
    "        else:\n",
    "            self.n = len(self.memory)\n",
    "\n",
    "        # network construction\n",
    "        self.energies = []  # container for tracking of energy\n",
    "\n",
    "        self.is_stable = False\n",
    "\n",
    "        self.pointer = 0\n",
    "        self.order = list(range(self.n))\n",
    "        random.shuffle(self.order)\n",
    "\n",
    "        # learn the pattern / patterns\n",
    "        self.weights = (\n",
    "            (1 / self.memory.shape[0]) * self.memory.T @ self.memory\n",
    "        )  # hebbian learning\n",
    "        np.fill_diagonal(self.weights, 0)\n",
    "\n",
    "\n",
    "    def set_state(self, state):\n",
    "        self.state = np.array(state)  # state vector\n",
    "\n",
    "\n",
    "    def update_network_state(self, n_update = None):  # update network\n",
    "        if n_update is None:\n",
    "            n_update = self.n\n",
    "\n",
    "        for _ in range(n_update):\n",
    "\n",
    "            self.rand_index = self.order[self.pointer]\n",
    "\n",
    "            # Compute activation for randomly indexed neuron\n",
    "            self.index_activation = np.dot(self.weights[self.rand_index, :], self.state)\n",
    "\n",
    "            # threshold function for binary state change\n",
    "            self.state[self.rand_index] = -1 if self.index_activation < 0 else 1\n",
    "\n",
    "        self.pointer = (self.pointer + 1) % self.n\n",
    "\n",
    "    def compute_energy(self):  # compute energy\n",
    "        self.energy = -0.5 * np.dot(np.dot(self.state.T, self.weights), self.state)\n",
    "        self.energies.append(self.energy)\n",
    "\n",
    "    def let_converge(self, max_iter=200):\n",
    "        while max_iter and self.is_stable:\n",
    "            max_iter -= 1\n",
    "            prev_state = np.array(self.state)\n",
    "\n",
    "            self.update_network_state(self.n)\n",
    "            # self.compute_energy()\n",
    "            if np.all(self.state == prev_state):\n",
    "                self.is_stable = True\n",
    "                break\n",
    "\n",
    "    def check_memory(self):\n",
    "        counters = {i: 0 for i in [\"error\", \"spourious\", \"ok\"]}\n",
    "        for i in range(len(self.memory)):\n",
    "            self.set_state(self.memory[i])\n",
    "            self.let_converge()\n",
    "\n",
    "            ax = \"spourious\"\n",
    "    \n",
    "            for j, mem in enumerate(self.memory):\n",
    "                if np.all(self.state == mem):  # converge\n",
    "                    ax = (\n",
    "                        \"ok\" if i == j else \"error\"\n",
    "                    )  # NOTE ignore there could be duplicates inside self.memory\n",
    "                    break\n",
    "\n",
    "            counters[ax] += 1\n",
    "\n",
    "        return counters\n",
    "\n",
    "    def mx_reg(self):\n",
    "        X, Y = self.memory, self.state\n",
    "        a = np.linalg.inv(np.dot(X,X.T))\n",
    "        c = np.dot(X,Y)\n",
    "        beta = np.dot(a,c)\n",
    "        return beta\n",
    "\n",
    "    def lookup(self, spourious = True, ):\n",
    "        if spourious:\n",
    "            beta2 = self.mx_reg()**2\n",
    "            idx = np.argmax(beta2) # NOTE a threshold on beta shoudld take place and therefore return a None whenever\n",
    "            return idx\n",
    "        else:\n",
    "            for j, mem in enumerate(self.memory):\n",
    "                if np.all(self.state == mem):  # converge\n",
    "                    return j\n",
    "            return None\n",
    "\n",
    "    def test(self, x):\n",
    "        self.set_state(x)\n",
    "        self.let_converge()\n",
    "        return self.lookup()\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## HyperParam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "img_size = 64\n",
    "train_size, test_size = 50, 50\n",
    "max_risk_size = 120\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_directory = pathlib.Path(\"downloads\", \"CatsDogs\")\n",
    "seed = 123\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Downloading the dataset: as a big dataset is not needed for this network we focus just on a small sample."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 24770 files belonging to 2 classes.\n"
     ]
    }
   ],
   "source": [
    "ds_gen = utils.image_dataset_from_directory(\n",
    "    data_directory,\n",
    "    color_mode=\"grayscale\",\n",
    "    seed=seed,\n",
    "    image_size=(img_size, img_size),\n",
    "    batch_size=1,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "ds = ds_gen.take(train_size + test_size + max_risk_size)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Converting pixels to bits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "normalization_layer = layers.Rescaling(scale=1.0 / 255, offset=-0.5001)\n",
    "normalized_ds = ds.map(lambda x, y: (normalization_layer(x), y))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "images = []\n",
    "labels = np.array([])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 220/220 [00:00<00:00, 556.50it/s]\n"
     ]
    }
   ],
   "source": [
    "for batch in tqdm(normalized_ds):\n",
    "    # sobel=tf.image.sobel_edges(batch[0])\n",
    "    # sobel_x=np.asarray(sobel[0,:,:,:,1])\n",
    "    arr = np.squeeze(tf.math.sign(batch[0]))\n",
    "    images.append(arr)\n",
    "    labels = np.append(labels, (int(batch[1][0])))\n",
    "images = np.array(images)\n",
    "images = images.reshape((-1, img_size * img_size))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "memories_indexes = np.array(range(train_size))\n",
    "test_indexes = np.array(range(train_size, train_size + test_size))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(images[9].reshape((img_size, img_size)))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing step by step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "memories_list = images[memories_indexes]\n",
    "memories_labels = labels[memories_indexes]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_image = images[9]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initializing the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H_Net = Hopfield_Net(memories_list)\n",
    "H_Net.test(test_image)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plotting weights matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.figure(\"weights\", figsize=(10, 7))\n",
    "# plt.imshow(H_Net.weights, cmap=\"RdPu\")  #\n",
    "# plt.xlabel(\"Each row/column represents a neuron, each square a connection\")\n",
    "\n",
    "# plt.title(\n",
    "#     f\" {img_size*img_size} Neurons - {img_size*img_size*img_size*img_size} unique connections\",\n",
    "#     fontsize=15,\n",
    "# )\n",
    "# plt.setp(plt.gcf().get_axes(), xticks=[], yticks=[])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computing the stable state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # plot energies\n",
    "# plt.figure(\"Energy\", figsize=(6, 4))\n",
    "# x = np.arange(len(H_Net.energies))\n",
    "# plt.scatter(x, np.array(H_Net.energies), s=1, color=\"red\")\n",
    "# plt.xlabel(\"Generation\")\n",
    "# plt.ylabel(\"Energy\")\n",
    "# plt.title(\"Network Energy over Successive Generations\", fontsize=15)\n",
    "# plt.setp(plt.gcf().get_axes(), xticks=[], yticks=[])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tested image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(test_image.reshape((img_size, img_size)))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stable state reached"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(H_Net.state.reshape((img_size, img_size)))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> *Binary Hopfield networks (BHNs) are prone to ‘spurious’ minima. If memories learned by a BHN are too similar, or if too many pattern vectors are learned, the network risks converging to an in-between memory, some combination of learned patterns; in other words, the network will fail to discriminate between patterns and becomes useless.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Checking if it is a spurius state or if the network predicted well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'error': 0, 'spourious': 0, 'ok': 50}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H_Net.check_memory()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exploratory experiments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As any pattern stored define a stable state, this network should have always zero training error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PERFORMANCE ON THE TRAINING SET: {'error': 0, 'spourious': 0, 'ok': 50}\n"
     ]
    }
   ],
   "source": [
    "H_Net = Hopfield_Net(memories_list)\n",
    "print(f\"PERFORMANCE ON THE TRAINING SET: {H_Net.check_memory()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 50/50 [00:00<00:00, 473.64it/s]\n"
     ]
    }
   ],
   "source": [
    "not_guessed = 0\n",
    "spurius_states = []\n",
    "\n",
    "for index in tqdm(test_indexes):\n",
    "    result = H_Net.test(images[index])\n",
    "\n",
    "    if result is None:\n",
    "        spurius_states.append(index)\n",
    "    else:\n",
    "        if memories_labels[result] == labels[index]:\n",
    "            pass\n",
    "        else:\n",
    "            not_guessed += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PERFORMANCE ON THE TEST SET:\n",
      "Number of spurius states reached: 0\n",
      "Net 0:1 loss: 0.58\n"
     ]
    }
   ],
   "source": [
    "print(\"PERFORMANCE ON THE TEST SET:\")\n",
    "print(f\"Number of spurius states reached: {len(spurius_states)}\")\n",
    "\n",
    "try:\n",
    "    loss = not_guessed / (test_size-len(spurius_states))\n",
    "except ZeroDivisionError:\n",
    "    print(f\"Loss cannot be computed right now\")\n",
    "else:\n",
    "    print(f\"Net 0:1 loss: {loss}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In practice, even with a small number of patterns stored there is the risk that a some of the learned pattern converge instead to a spurius pattern.\n",
    "\n",
    "It seems necessary to choose the patterns stored trying to minimizing the risk of spurius states. To do so the patterns stored need to be as dissimilar as possible.\n",
    "\n",
    "So, we define an enreached algorithm using an Hopfield Network for binary image classification:\n",
    "\n",
    "It take as inputs a training set of labeled images.\n",
    "It has one parameters: **p** that is the number of patterns to be stored >=2.\n",
    "\n",
    "First it choose **p** images from the training set, ensuring that there is at least one pattern for each label and maximizing the dissimilarity examples.\n",
    "\n",
    "Then it stored these patterns with an Hopfield Network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pattern_chooser(training_images, training_labels, p: int):\n",
    "    \"\"\"\n",
    "    this procedure ensure that at least one pattern per label is keeped as long as p>=2\n",
    "\n",
    "    Args:\n",
    "        p (int): number of pattern to choose\n",
    "\n",
    "    Returns:\n",
    "        this procedure delete one pattern at time\n",
    "        and if there is just one pattern with a label value it can't be deleted as:\n",
    "        its label count is 1 so:\n",
    "        or the other label has a higher count than one,\n",
    "        or it already reach the minimum number of patterns left that is 2 and will not delete any pattern\n",
    "    \"\"\"\n",
    "    \n",
    "    patterns = np.array(training_images)\n",
    "    patterns_labels = np.array(training_labels)\n",
    "\n",
    "    # build dinstance matrix\n",
    "    dists = np.array([[H2(a, b) for a in patterns] for b in patterns])\n",
    "    np.fill_diagonal(dists, 1)\n",
    "\n",
    "    while len(patterns_labels) > p:\n",
    "        # a, b = np.where(dists == dists.min())[0]\n",
    "        a, b = np.unravel_index(np.argmin(dists, axis=None), dists.shape)\n",
    "        label_a, label_b = patterns_labels[[a, b]]\n",
    "\n",
    "        # delete the pattern with the most represented label\n",
    "        idx = b if sum(patterns_labels == label_a) < sum(patterns_labels == label_b) else b\n",
    "\n",
    "        patterns = np.delete(patterns, idx, 0)\n",
    "        patterns_labels = np.delete(patterns_labels, idx, 0)\n",
    "        dists = np.delete(dists, idx, 0)\n",
    "        dists = np.delete(dists, idx, 1)\n",
    "\n",
    "        # print(patterns_labels, patterns.shape)\n",
    "\n",
    "    return patterns, patterns_labels\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hyperparameter tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 50/50 [00:00<00:00, 4050.51it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 3525.28it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 2678.42it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 2694.39it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 2297.82it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 2623.05it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 1848.07it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 2080.49it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 1565.30it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 1543.21it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 1384.17it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 1303.13it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 1136.71it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 1063.72it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 802.92it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 868.45it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 783.53it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 768.27it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 670.42it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 691.48it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 577.27it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 572.17it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 534.19it/s]\n",
      "100%|██████████| 50/50 [00:00<00:00, 566.78it/s]\n",
      "100%|██████████| 24/24 [00:03<00:00,  6.80it/s]\n"
     ]
    }
   ],
   "source": [
    "stats = dict()\n",
    "\n",
    "for p in tqdm(range(2, train_size, 2)):\n",
    "    perf = {i+'_val':0 for i in [\"error\", \"spourious\", \"ok\"]}\n",
    "    # choose patterns\n",
    "    memories_list, memories_labels = pattern_chooser(images[memories_indexes], labels[memories_indexes], p)\n",
    "    H_Net = Hopfield_Net(memories_list)\n",
    "    \n",
    "    for index in tqdm(test_indexes):\n",
    "        result = H_Net.test(images[index])\n",
    "\n",
    "        if result is None:\n",
    "            perf['spourious_val'] += 1\n",
    "        else:\n",
    "            if memories_labels[result] == labels[index]:\n",
    "                perf['ok_val'] += 1\n",
    "            else:\n",
    "                perf['error_val'] += 1\n",
    "\n",
    "    stats[p] = (H_Net.check_memory(), perf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0.5, 0, 'N of patterns'), Text(0, 0.5, 'Loss')]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = sns.lineplot(x=list(stats.keys()), y=[v[1]['error_val'] /(test_size) for v in stats.values()])\n",
    "ax.set(xlabel=\"N of patterns\", ylabel='Loss')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "N_PATTERN = 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Risk estimation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "K = 5\n",
    "cherry_picking = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "tt_size = train_size + test_size\n",
    "risk_size = max_risk_size if cherry_picking else N_PATTERN * K\n",
    "risk_indexes = np.arange(tt_size, tt_size + risk_size)\n",
    "fold_size = risk_size // K"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fold nº 1...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 96/96 [00:00<00:00, 2393.11it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fold nº 2...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 96/96 [00:00<00:00, 2441.08it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fold nº 3...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 96/96 [00:00<00:00, 2795.76it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fold nº 4...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 96/96 [00:00<00:00, 2597.06it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fold nº 5...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 96/96 [00:00<00:00, 2659.04it/s]\n"
     ]
    }
   ],
   "source": [
    "loss = [0] * K\n",
    "\n",
    "for i in range(K):\n",
    "    mem_slice = np.arange(i * fold_size, (i + 1) * fold_size)\n",
    "    memories_indexes = risk_indexes[mem_slice]\n",
    "    if cherry_picking:\n",
    "        memories_list, memories_labels = pattern_chooser(images[memories_indexes], labels[memories_indexes], N_PATTERN)\n",
    "    else:\n",
    "        memories_list, memories_labels = images[memories_indexes], labels[memories_indexes]\n",
    "    \n",
    "    test_indexes = np.delete(risk_indexes, mem_slice, 0)\n",
    "\n",
    "    H_Net = Hopfield_Net(memories_list)\n",
    "    print(f\"Fold nº {i+1}...\")\n",
    "\n",
    "    for index in tqdm(test_indexes):\n",
    "        result = H_Net.test(images[index])\n",
    "        if memories_labels[result] != labels[index]:\n",
    "            loss[i] += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Risk estimation (average zero one loss):  0.38166666666666665\n"
     ]
    }
   ],
   "source": [
    "avg_loss = sum(loss) / K / risk_size\n",
    "print(\"Risk estimation (average zero one loss): \", avg_loss)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Animation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H_Net.set_state(images[9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cellsize = 5\n",
    "\n",
    "pygame.init() \n",
    "surface = pygame.display.set_mode((img_size * cellsize, img_size * cellsize))\n",
    "pygame.display.set_caption(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# kill pygame if user exits window\n",
    "Running = True\n",
    "# main animation loop\n",
    "try:\n",
    "    while Running:\n",
    "        for event in pygame.event.get():\n",
    "            pygame.time.wait(1)\n",
    "            if event.type == pygame.QUIT:\n",
    "                Running = False\n",
    "\n",
    "                # # plot weights matrix\n",
    "                # plt.figure(\"weights\", figsize=(10, 7))\n",
    "                # plt.imshow(H_Net.weights, cmap=\"RdPu\")  #\n",
    "                # plt.xlabel(\"Each row/column represents a neuron, each square a connection\")\n",
    "\n",
    "                # plt.title(\" 4096 Neurons - 16,777,216 unique connections\", fontsize=15)\n",
    "                # plt.setp(plt.gcf().get_axes(), xticks=[], yticks=[])\n",
    "\n",
    "                # # plot energies\n",
    "                # plt.figure(\"Energy\", figsize=(10, 7))\n",
    "                # x = np.arange(len(H_Net.energies))\n",
    "                # plt.scatter(x, np.array(H_Net.energies), s=1, color=\"red\")\n",
    "                # plt.xlabel(\"Generation\")\n",
    "                # plt.ylabel(\"Energy\")\n",
    "                # plt.title(\"Network Energy over Successive Generations\", fontsize=15)\n",
    "                # plt.setp(plt.gcf().get_axes(), xticks=[], yticks=[])\n",
    "\n",
    "                # quit pygame\n",
    "                pygame.quit()\n",
    "\n",
    "        cells = H_Net.state.reshape(img_size, img_size).T\n",
    "\n",
    "        # fills surface with color\n",
    "        surface.fill((211, 211, 211))\n",
    "\n",
    "        # loop through network state array and update colors for each cell\n",
    "        for r, c in np.ndindex(cells.shape):  # iterates through all cells in cells matrix\n",
    "            if cells[r, c] == -1:\n",
    "                col = (135, 206, 250)\n",
    "\n",
    "            elif cells[r, c] == 1:\n",
    "                col = (0, 0, 128)\n",
    "\n",
    "            else:\n",
    "                col = (255, 140, 0)\n",
    "            pygame.draw.rect(\n",
    "                surface, col, (r * cellsize, c * cellsize, cellsize, cellsize)\n",
    "            )  # draw new cell_\n",
    "\n",
    "        # update network state\n",
    "        H_Net.update_network_state(img_size*img_size//20)\n",
    "        # H_Net.compute_energy()\n",
    "        pygame.display.update()  # updates display from new .draw in update function\n",
    "except Exception as inst:\n",
    "    print(inst.args)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H_Net.lookup()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.2 ('venv': venv)",
   "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.10.2"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "0c89f70f669f0ea3789c57a403510e9f71ee3829d9d70c9b2bdd58feb836f7dd"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}