presentation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "from matplotlib import cm\n",
    "import random\n",
    "from scipy import misc\n",
    "from functools import reduce\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Ising Model, Spin Glasses, and Hopfield Networks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Hamiltonian\n",
    "\n",
    "$$\\mathcal{H}(\\ \\vec{s}; J, H) = -\\bigg[\\sum_{i,\\ j}J_{ij} s_i s_j + \\sum_i H s_i\\bigg]$$\n",
    "\n",
    "where the $J_{ij}$ are interaction strengths, $s_i = \\pm 1$ are spins, and $H$ is the external field strength\n",
    "\n",
    "As usual, the probability of the system having configuration $\\vec{s}$ is given by the Boltzmann distribution\n",
    "\n",
    "$$p(\\vec{s}; J, H) = \\frac{\\exp[-\\beta \\mathcal{H}(\\vec{s}; J, H)]}{Z}$$\n",
    "\n",
    "If we have the partition function we can calculate \n",
    "\n",
    "$$\\langle E \\rangle = -\\frac{\\partial \\ln Z}{\\partial \\beta}, \\ \\ \\ \\ var(E) = \\frac{\\partial^2 \\ln Z}{\\partial \\beta^2}$$\n",
    "\n",
    "The energy fluctuations are related to the heat capacity\n",
    "\n",
    "$$C = k_B \\beta^2 var(E)$$\n",
    "\n",
    "## The Ising Model\n",
    "\n",
    "![Ising Lattice](images/ising_lattice.png)\n",
    "\n",
    "## The Metropolis-Hastings Algorithm\n",
    "\n",
    "1. Pick a spin at random.\n",
    "2. Calculate the energy $\\Delta E$ that would be the result of flipping the spin.\n",
    "3. If $\\Delta E \\le 0$, flip the spin. Otherwise, flip it with probability $\\exp(-\\beta \\Delta E)$\n",
    "4. Repeat until you get good statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class IsingModel:\n",
    "    \n",
    "    def __init__(self, N, J=1.0, spins=None, beta=1.0, H=0.0, periodic=True):\n",
    "        self.lattice = nx.grid_graph([N,N], periodic=periodic)\n",
    "        self.lattice = nx.relabel_nodes(self.lattice,\n",
    "                                        {n : i for i, n in \n",
    "                                         enumerate(self.lattice.nodes())})\n",
    "        self.N = N\n",
    "        self.H = H\n",
    "        self.beta = beta\n",
    "        self.kT = 1 / beta\n",
    "        self.J  = J\n",
    "        self._init_spins(spins)\n",
    "            \n",
    "    def _init_spins(self, spins):\n",
    "        if spins is None:\n",
    "            spins = (2*(np.random.randn(self.N**2) > 0) - 1)\n",
    "        for n, s in zip(self.lattice, spins):\n",
    "            self.lattice.node[n][\"spin\"] = s\n",
    "            \n",
    "    def draw_network(self, node_size=300, ax=None):\n",
    "        dx = 1.0#/ self.N\n",
    "        pos = {n : map(lambda x: x*dx, n) for n in self.lattice.nodes()}\n",
    "        if ax is None: fig, ax = plt.subplots()\n",
    "        colors = [\"k\" if self.lattice.node[n][\"spin\"] > 0 \n",
    "                      else \"w\" for n in self.lattice] \n",
    "        nx.draw_networkx(self.lattice, \n",
    "                         pos=pos, node_color=colors, \n",
    "                         node_size=node_size, \n",
    "                         with_labels=False, \n",
    "                         ax=ax)\n",
    "        ax.set_xlim((0,self.N-1))\n",
    "        ax.set_ylim((0,self.N-1))\n",
    "        ax.set_yticks([])\n",
    "        ax.set_xticks([])\n",
    "        return ax\n",
    "    \n",
    "    def trace(self, N=10**5, thin=1000, burn_in=10**3):\n",
    "        energies = []\n",
    "        magnetizations = []\n",
    "        for j in range(burn_in):\n",
    "            self.metropolis_hastings_step()\n",
    "        for i in range(N):\n",
    "            self.metropolis_hastings_step()\n",
    "            if i % thin == 0:\n",
    "                energies.append(self.energy())\n",
    "                magnetizations.append(self.magnetization())\n",
    "                \n",
    "        return {\"energy\" : np.array(energies), \n",
    "                \"magnetization\" : np.array(magnetizations)}\n",
    "            \n",
    "        \n",
    "    def spin_matrix(self):\n",
    "        spins = [self.lattice.node[s][\"spin\"] for s in range(self.N**2)]\n",
    "        return np.reshape(spins, (self.N, self.N))\n",
    "    \n",
    "    def draw(self, ax=None):\n",
    "        M = self.spin_matrix()\n",
    "        if ax is None: fig, ax = plt.subplots()\n",
    "        ax.imshow(M, interpolation=\"none\", cmap=cm.binary)\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "        return ax\n",
    "    \n",
    "    def flip_spin(self, m):\n",
    "        self.lattice.node[m][\"spin\"] *= -1\n",
    "    \n",
    "    def energy(self):\n",
    "        field_energy = self.H * sum(self.lattice.node[m][\"spin\"] \n",
    "                                    for m in self.lattice.nodes())\n",
    "        interactions = self.J * sum(self.lattice.node[m][\"spin\"] * \\\n",
    "                                    self.lattice.node[n][\"spin\"] \n",
    "                               for m, n in self.lattice.edges())\n",
    "        return -(field_energy + interactions)\n",
    "    \n",
    "    def magnetization(self):\n",
    "        return np.sum([self.lattice.node[i][\"spin\"] \n",
    "                       for i in self.lattice.nodes()]) / self.N**2\n",
    "    \n",
    "    def metropolis_hastings_step(self):\n",
    "        m = np.random.randint(0, self.N**2)\n",
    "        s = self.lattice.node[m][\"spin\"]\n",
    "        neighbors = self.lattice.neighbors(m)\n",
    "        deltaE = 2 * s * ( self.J * sum(self.lattice.node[n][\"spin\"] \n",
    "                                         for n in neighbors) + self.H )\n",
    "        if deltaE < 0:\n",
    "            self.flip_spin(m)\n",
    "        else:\n",
    "            p = np.exp(-self.beta*deltaE)\n",
    "            if np.random.uniform(0,1) < p:\n",
    "                self.flip_spin(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x10e8dada0>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x109367f60>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = IsingModel(32, J=1.0, H=0.0, beta=1/2.26918531421) #critical temperature\n",
    "trace = model.trace(N=10**4, burn_in=10**3)\n",
    "model.draw();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Phase transition in the 2D Ising Magnet\n",
    "\n",
    "Recall that at a phase transition, one or more derivatives of the partition function are discontinuous.\n",
    "\n",
    "![](images/ising_sim.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Spin Glass\n",
    "\n",
    "We can generalize the Ising model to a system where spins are connected to each other randomly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SpinGlass:\n",
    "    \n",
    "    def __init__(self, graph, J=1.0, spins=None, beta=1.0, H=0.0, p=0.2):\n",
    "        self.lattice = graph\n",
    "        self.N =len(graph)\n",
    "        self.H = H\n",
    "        self.beta = beta\n",
    "        self.kT = 1 / beta\n",
    "        self.J  = J\n",
    "        self._init_spins(spins)\n",
    "            \n",
    "    def _init_spins(self, spins):\n",
    "        if spins is None:\n",
    "            spins = (2*(np.random.randn(self.N) > 0) - 1)\n",
    "        for n, s in zip(self.lattice, spins):\n",
    "            self.lattice.node[n][\"spin\"] = s\n",
    "        \n",
    "    def draw_network(self, node_size=300, ax=None, how=\"circular\"):\n",
    "        dx = 1.0#/ self.N\n",
    "        if ax is None: fig, ax = plt.subplots()\n",
    "        colors = [\"r\" if self.lattice.node[n][\"spin\"] > 0 \n",
    "                      else \"w\" for n in self.lattice] \n",
    "        if how==\"circular\":\n",
    "            nx.draw_circular(self.lattice, \n",
    "                             node_color=colors, \n",
    "                             node_size=node_size, \n",
    "                             with_labels=False, \n",
    "                             ax=ax)\n",
    "        else:\n",
    "            nx.draw_networkx(self.lattice, \n",
    "                             node_color=colors, \n",
    "                             node_size=node_size, \n",
    "                             with_labels=False, \n",
    "                             ax=ax)\n",
    "        ax.set_yticks([])\n",
    "        ax.set_xticks([])\n",
    "        return ax\n",
    "    \n",
    "    def trace(self, N=10**5, thin=1000, burn_in=10**3):\n",
    "        energies = []\n",
    "        magnetizations = []\n",
    "        for j in range(burn_in):\n",
    "            self.metropolis_hastings_step()\n",
    "        for i in range(N):\n",
    "            self.metropolis_hastings_step()\n",
    "            if i % thin == 0:\n",
    "                energies.append(self.energy())\n",
    "                magnetizations.append(self.magnetization())\n",
    "                \n",
    "        return {\"energy\" : np.array(energies), \n",
    "                \"magnetization\" : np.array(magnetizations)}\n",
    "            \n",
    "        \n",
    "    def spin_matrix(self):\n",
    "        M = np.zeros((self.N, self.N))\n",
    "        for (i, j), s in self.lattice.node.items():\n",
    "            M[i, j] = s[\"spin\"]\n",
    "        return M\n",
    "    \n",
    "    def draw(self, ax=None):\n",
    "        M = self.spin_matrix()\n",
    "        if ax is None: fig, ax = plt.subplots()\n",
    "        ax.imshow(M, interpolation=\"none\", cmap=cm.binary)\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "        return ax\n",
    "    \n",
    "    def flip_spin(self, m):\n",
    "        self.lattice.node[m][\"spin\"] *= -1\n",
    "    \n",
    "    def energy(self):\n",
    "        field_energy = self.H * sum(self.lattice.node[m][\"spin\"] \n",
    "                                    for m in self.lattice.nodes())\n",
    "        interactions = self.J * sum(self.lattice.node[m][\"spin\"] * \\\n",
    "                                    self.lattice.node[n][\"spin\"] \n",
    "                               for m, n in self.lattice.edges())\n",
    "        return -(field_energy + interactions)\n",
    "    \n",
    "    def magnetization(self):\n",
    "        return np.sum([self.lattice.node[i][\"spin\"] \n",
    "                       for i in self.lattice.nodes()]) / float(self.N)\n",
    "    \n",
    "    def metropolis_hastings_step(self):\n",
    "        m = np.random.randint(0, self.N)\n",
    "        s = self.lattice.node[m][\"spin\"]\n",
    "        neighbors = self.lattice.neighbors(m)\n",
    "        deltaE = 2 * s * ( self.J * sum(self.lattice.node[n][\"spin\"] \n",
    "                                         for n in neighbors) + self.H )\n",
    "        if deltaE < 0:\n",
    "            self.flip_spin(m)\n",
    "        else:\n",
    "            p = np.exp(-self.beta*deltaE)\n",
    "            if np.random.uniform(0,1) < p:\n",
    "                self.flip_spin(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net magnetization per spin: 0.62\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10ec94eb8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph = nx.barabasi_albert_graph(100, 1)\n",
    "sg = SpinGlass(graph, beta=1.0, H=0.0)\n",
    "for i in range(10000):\n",
    "    sg.metropolis_hastings_step()\n",
    "sg.draw_network(how=\"circular\", node_size=25);\n",
    "print(\"Net magnetization per spin:\", sg.magnetization())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Spontaneous Magnetization in a Spin Glass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.26\n",
      "0.18\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10ee019b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph = nx.barabasi_albert_graph(100, 1)\n",
    "sg = SpinGlass(graph, beta=1e-3, H=100.0)\n",
    "fig, ax = plt.subplots(nrows=1, ncols=2)\n",
    "for i in range(10000):\n",
    "    sg.metropolis_hastings_step()\n",
    "sg.draw_network(how=\"circular\", node_size=25, ax=ax[0]);\n",
    "\n",
    "print(sg.magnetization())\n",
    "sg.H = 0\n",
    "sg.beta = 100.0\n",
    "\n",
    "for i in range(10000):\n",
    "    sg.metropolis_hastings_step()\n",
    "sg.draw_network(how=\"circular\", node_size=25, ax=ax[1])\n",
    "\n",
    "ax[0].set_title(r\"$\\beta=10^{-3},\\ \\ \\  H = 100$\")\n",
    "ax[1].set_title(r\"$\\beta=100,\\ \\ \\  H = 0$\");\n",
    "\n",
    "print(sg.magnetization())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Some disappointing things\n",
    "\n",
    "![](images/ising_np_complete.png)\n",
    "![](images/spin_glass_np_hard.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Hopfield Network\n",
    "\n",
    "Spin glasses have many low-energy states and rugged landscapes.  Hopfield had a great idea: use these to embed memories.  The idea is to construct a spin glass where \"memories\" are low energy states.\n",
    "\n",
    "Any memories can be encoded as binary strings that correspond to firing patterns of neurons, for example:\n",
    "\n",
    "$$V_1 = 10110100,\\ \\ \\ \\ \\ \\ \\ V_2 = 00101001 , \\ \\ \\ \\ V_3 = 11110000 ,\\ \\ \\  .....$$\n",
    "\n",
    "We can turn these into vectors like this\n",
    "\n",
    "$$111000 \\to [+1, +1, +1 -1, -1, -1]$$\n",
    "\n",
    "If we want to store the memory $111000$, then what would it mean to remember it from incomplete or corrupted information?\n",
    "\n",
    "That means that if we observe $111001$, we would like our dynamics to evolve to $111000$.\n",
    "\n",
    "**We want a spin glass that has the memories as local minima!**\n",
    "\n",
    "If we can find a spin glass with these as local minima, then we can imagine rolling nearby strings down the energy landscape until they reach the memory.\n",
    "\n",
    "![Source: Nonequilibrium landscape theory of neural networks](images/energy_landscape.png)\n",
    "*Source: Nonequilibrium landscape theory of neural networks*\n",
    "\n",
    "\n",
    "# The memory problem redefined\n",
    "\n",
    "So now we have two questions:\n",
    "\n",
    "1. How can we make an energy landscape to store memories?\n",
    "2. How can we roll nearby points down to local minima?\n",
    "\n",
    "\n",
    "## Making the spin glass\n",
    "To come up with the weights between the spins, we use **Hebbian learning**.  This is based on the premise that when two neurons fire together, the connection between them is strengthened.\n",
    "\n",
    "$$w_{ij} \\propto Corr(x_i, x_j)$$\n",
    "\n",
    "This defines a $k \\times k$ weight matrix $T$, where $k$ is the length of the strings.  We set the diagonal equal to zero.\n",
    "\n",
    "## Rolling the memory down the hill\n",
    "\n",
    "Recall the Hamiltonian\n",
    "\n",
    "$$\\mathcal{H}(\\ \\vec{s}; J) = -\\sum_{i,\\ j}J_{ij} s_i s_j$$\n",
    "\n",
    "It is convenient to write this as\n",
    "\n",
    "$$\\mathcal{H}(\\ \\vec{s}; J) = -\\frac{1}{2}\\textbf{s}^T \\textbf{J} \\textbf{s}$$\n",
    "\n",
    "\n",
    "Iterate through neurons (or spins, if you like) **asychronously** with the following rule\n",
    "\n",
    "$$s_i = +1 \\text{      if       } \\sum_j J_{ij} s_i s_j > 0$$\n",
    "$$s_i = -1 \\text{      if       } \\sum_j J_{ij} s_i s_j \\le 0$$\n",
    "\n",
    "It can be shown that updating the neurons this way can never increase the energy; it will always stay the same or go down."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    " def random_binary_string(N):\n",
    "    return \"\".join(np.random.choice([\"0\", \"1\"], \n",
    "                                    p=[0.5,0.5]) \n",
    "                   for _ in range(N))\n",
    "\n",
    "def flip_random_bit(string):\n",
    "    newS = list(string)\n",
    "    i = random.choice(range(len(newS)))\n",
    "    newS[i] = str(int(not (int(newS[i]))))\n",
    "    return \"\".join(newS)\n",
    "\n",
    "def flip_random_bits(string, N):\n",
    "    new_string = \"\".join(list(string))\n",
    "    for i in range(N):\n",
    "        new_string = flip_random_bit(new_string)\n",
    "    return new_string\n",
    "\n",
    "def str2v(s):\n",
    "    return 2*np.array(list(s), dtype=int) - 1\n",
    "\n",
    "def v2str(V):\n",
    "    return \"\".join([str(int(v_i > 0)) for v_i in V])\n",
    "\n",
    "def weight_matrix(memories):\n",
    "    states = list(map(str2v, memories))\n",
    "    N = len(states[0])\n",
    "    W = np.zeros((N,N))\n",
    "    for i in range(N):\n",
    "        for j in range(i):\n",
    "            for s in states:\n",
    "                W[i,j] += s[i]*s[j]    \n",
    "    return (W + W.T) / float(N)\n",
    "\n",
    "def closest_minimum(s, W, maxiter=10**2, bias=0.0):\n",
    "    minE = np.inf\n",
    "    s_new = \"\".join(s_i for s_i in s)\n",
    "    for i in range(maxiter):\n",
    "        s_new = update_step(s_new, W)\n",
    "        if energy(s_new, W) -  energy(s, W) > 2*np.finfo(np.float64).eps:\n",
    "            raise Exception(\"WTF\")\n",
    "        if energy(s_new, W) <= minE:\n",
    "            minE = energy(s_new, W)\n",
    "            s_best = \"\".join(s_i for s_i in s_new)\n",
    "        if energy(s_new, W) ==  energy(s, W):\n",
    "            break\n",
    "    return s_best\n",
    "\n",
    "def update_step(s, W, bias=0):\n",
    "    V = str2v(s)\n",
    "    for i in range(len(V)):\n",
    "        V[i] = 2*int(np.dot(W[i,:], V) > bias) - 1\n",
    "    return v2str(V)\n",
    "        \n",
    "def energy(s, W):\n",
    "    V = str2v(s)\n",
    "    return -0.5 * V.T.dot(W).dot(V)\n",
    "\n",
    "def plot_string_to_digit(s, ax=None):\n",
    "    X = decode_image_string(s).reshape(50,50)\n",
    "    if ax is None:\n",
    "        fig, ax = plt.subplots()\n",
    "    ax.imshow(X, interpolation=\"none\", cmap=cm.binary)\n",
    "    ax.set_xticks([])\n",
    "    ax.set_yticks([])\n",
    "    return X\n",
    "    \n",
    "def encode_pixel(num, how=\"thresh:\"):        \n",
    "    return str(int(num))\n",
    "    \n",
    "def decode_image_string(s):\n",
    "    L = list(map(int, list(s)))\n",
    "    #X = np.zeros(len(L))\n",
    "    return np.array(L)\n",
    "\n",
    "def encode_image(img):\n",
    "    return reduce(lambda x, y: x+y, map(encode_pixel, img))\n",
    "\n",
    "def standardize_image(img, size=(50,50), thresh=100, plot=False, flatten=True):\n",
    "    import os\n",
    "    img = \"images\" + os.sep + img\n",
    "    image = misc.imresize(misc.imread(img), size, interp=\"nearest\")\n",
    "    image = (1 * (image < thresh))[:,:,0]\n",
    "    if plot: plt.imshow(image, cmap=cm.binary);\n",
    "    if flatten:\n",
    "        return image.flatten()\n",
    "    else:\n",
    "        return image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recalling images in the presence of noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/williamtrenfield/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:81: DeprecationWarning: `imread` is deprecated!\n",
      "`imread` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n",
      "Use ``imageio.imread`` instead.\n",
      "/Users/williamtrenfield/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:81: DeprecationWarning: `imresize` is deprecated!\n",
      "`imresize` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n",
      "Use ``skimage.transform.resize`` instead.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10e8df9e8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "images = list(map(standardize_image, \n",
    "                  [\"mad_emoji.jpg\", \n",
    "                   \"happy_emoji.png\", \n",
    "                   \"think_emoji.png\"])\n",
    "             )\n",
    "\n",
    "strings = list(map(encode_image, images))\n",
    "\n",
    "T = weight_matrix(strings)\n",
    "\n",
    "fig, ax = plt.subplots(nrows=len(strings), ncols=3, figsize=(6,6))\n",
    "for i, x in enumerate(strings):\n",
    "    #x = strings[i]\n",
    "    noisy_x = flip_random_bits(x, 1000)\n",
    "    x_hat = closest_minimum(noisy_x, T, bias=0.0, maxiter=100)\n",
    "    plot_string_to_digit(x, ax[i][0])\n",
    "    plot_string_to_digit(noisy_x, ax[i][1])\n",
    "    plot_string_to_digit(x_hat, ax[i][2])\n",
    "ax[0][0].set_title(\"Original\")\n",
    "ax[0][1].set_title(\"Observation\")\n",
    "ax[0][2].set_title(\"Memory\")\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recalling images from incomplete data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10eaa6898>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(nrows=len(strings), ncols=3, figsize=(6,6))\n",
    "for i, x in enumerate(strings):\n",
    "    #x = strings[i]\n",
    "    noisy_x = x[:1700] + (800*\"0\")\n",
    "    x_hat = closest_minimum(noisy_x, T, maxiter=100)\n",
    "    plot_string_to_digit(x, ax[i][0])\n",
    "    plot_string_to_digit(noisy_x, ax[i][1])\n",
    "    plot_string_to_digit(x_hat, ax[i][2])\n",
    "ax[0][0].set_title(\"Original\")\n",
    "ax[0][1].set_title(\"Observation\")\n",
    "ax[0][2].set_title(\"Memory\")\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Overloading the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/williamtrenfield/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:81: DeprecationWarning: `imread` is deprecated!\n",
      "`imread` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n",
      "Use ``imageio.imread`` instead.\n",
      "/Users/williamtrenfield/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:81: DeprecationWarning: `imresize` is deprecated!\n",
      "`imresize` is deprecated in SciPy 1.0.0, and will be removed in 1.2.0.\n",
      "Use ``skimage.transform.resize`` instead.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAM6CAYAAADUg9ehAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzt3X+sLlt91/HvF28FKr/Ec6q9Ve9u04JgFOI+1rYpqfZHWkgIDVZLBQsJrUbTaklVFBChsY01WEustv6IpoBQBFv8Cf42jQaMe5NiJdWm2HNa4AL30AKX8qNQln88z3Pvc58ze2bNzPrxWWver+SmZZ9nz6yZ+e7nu75r1qzxEIIBAKDmYbUbAADAEBIUAEASCQoAIIkEBQCQRIICAEgiQQEAJG06Qbn7S9z9H6X+bMS2grt/aYptYZq7v8LdX1e7HXO5+1vd/fm12wHU0lWCcvcXuPvPuvsn3P0D7v6j7v64qz4fQviBEMJ3xGx7zmdR3txrr2YoiYYQnh5C+PFabcKD3P2mu/+6u187+fnP7DucZ3Va1rduEpS7f6+Z/aCZ/UUze6yZfYWZ3WNm/8Hdf/PA5+8q20LkMvfaZ2oD8dS/XzSzbzv8D3f/fWb2yHrNeaAd3cZeFwnK3R9jZq80s+8OIbwthPCZEMJNM/vjtvuiet6+h/pmd3+du3/MzF5w2mt1929391vu/mF3/6v7XtPX7//tgc+6+9m+1/R8d/8ld7/t7i892s6Xu/vb3f0j7n6vu/9IqS/KrYm59vuPPsLd3+ju97v7O939KUfbeLG7v2//b//X3b9u//OHuftfdvf37GPin7n74/f/doiBF7r7L5nZf3b3t7n7d520713u/uz9//9qd/9ld/+Yu1+6+9P2P/8mM3uJmX2ru3/c3d+1//l/dffvOGrLy/bx+SF3f427P/akLYPxiGRea2bffvS/n29mrzn8D3d/uLu/an8NPujuP+buj9z/2x929/e6+1/aX7973f2b3f0Z7v7z7v4r7v6Sk239sLu/f//fD7v7w0+29WJ3/4CZ/RN3/9/u/syj3/+8fRw8NfdJyamLBGVmX2VmjzCznzz+YQjh42b2VjP7hv2PnmVmbzazx5nZPz3+rLs/2cz+npk918y+0HY98S+a2O9Xm9kTzezrzOzl7v6k/c9/w8xeZGbXzOwr9//+ZxccF6bNufZvMrPHm9nrzewt+z/iJ5rZd5nZHwwhPNrMvtHMbu5/58+Z2Teb2deY2d1m9qtm9ndP9v81Zvak/e+93h7aw36y7ZLkv9n/6H+a2VOP2vAmd39ECOFtZvYDZvbGEMKjQghPsTu9YP/fHzGzLzGzR5nZj5x85qp4RBrvMLPHuPuT3P03mdm3mtnxsOwPmtkTbHeNv9R23x8vP/r332G7WD38/B/argN1bmZPs901+5L9Z19qu5GAp5rZU8zsy83sZSfberzt4utP2S5RPu/o359hZveGEH5m3SHX1UuCumZmt0MInx34t3v3/25m9vYQwltCCJ8LIXzy5HPfYmb/KoTw30IIv267AJpaqPCVIYRPhhDeZWbvsl0gWQjhMoTwjhDCZ/e9+b9vuy8ypBd77S9DCG8OIXzGzH7Idl8UX2G7zsTDzezJ7v55IYSbIYT37H/nT5vZS0MI7w0hfNrMXmFm33IypPKKEMKv7ePpp8zsqe5+z/7fnmtmP7n/XQshvC6E8OF9XPyt/X6fGHmczzWzHwoh/L998v0rZvack7YMxiOSOlRR32Bm/8fM3rf/uZvZd5rZi0IIvxJCuN92nY7nHP3uZ8zs+/cx+BO2i81XhxDuDyG828zebWa/f//Z55rZ94UQPhRCuM92owR/8mhbnzOzvxZC+PQ+9l5nZs/YjyjY/rOvTXngNfSSoG6b2bUrxmK/cP/vZma/PLKNu4//PYTwCTP78MR+P3D0/3/Cdr1ac/cnuPu/9t3N+o/ZLlCvDW0Aq82+9iGEz5nZe83s7hDCL5jZ99gu+XzI3X/C3e/ef/QeM/up/VDtR8zs52yX0H770T6Ot3u/7aqlw5fSc+yoUnf373X3n3P3j+6391iLj4u7zezW0f++ZWZ3nbRlMB6R1GvN7E/Yrpp9zdHPr5vZ55vZ5VG8vG3/84MPhxB+Y///HzrIHzz690/ag9ds6HrfffS/7wshfOrwP0II7zez/25mf9R3k4OebiejRC3qJUG93cw+bWbPPv6hu/8W212o/7T/0VhFdK+Z/c6j332kmf22he35Udv1rr4shPAY291f8IXbwrjYa/+7jv7tYba71u83MwshvD6E8NW2S0jBdkM1Zrvk8/QQwuOO/ntECOHQaza7M6beYGbf5u5fabsb6P9lv8+nmdmLbXdv7LeGEB5nZh+1B+Niqlp//759B7/bzD5rD/2CQ2YhhFu2myzxDHvosPJt2yWY33sUK48NISztJAxd7/cfN2Xgd37cdsN8f8x2o0XvG/hMU7pIUCGEj9quBP477v5N+3sLZ7a75/Beiyt132xmz3T3r9pPaHilLU8qjzazj5nZx93995jZn1m4HUyYce3P3f3Z+0rre2yX1N7h7k9096/d34D+lO2+ZA693B8zs+8/DNm5+3V3f9ZEk/6t7b5Yvs9295Q+t//5o22XUO4zs7vc/eVm9pij3/ugmZ3tk+eQN5jZi9z9i939UfbgPauhoU3k9UIz+9oQwq8d/exztrun9Lfd/QvMzNz9i9z9Gxfu4w1m9rJ9zF2z3S2HqWf53mJmf8DM/rw9tLprVhcJyswshPA3bVepvMp2yeF/2K4H/HWHewATv/9uM/tu240N32tm95vZh2z3RTbXX7DdMMD9tgvaNy7YBiJFXvt/Ybub2r9qu/H5Z+/vBTzczP6G7XrAHzCzL9hvy8zs1Wb2L83s37v7/ba7Sf6HJtryadv1rL/edhMhDv6d7SZt/Lzthms+ZQ8dcn7T/v9+2N3fObDpf2y7ZPvTtuvBf8p28YrCQgjvCSFcDPzTi83sF2zX8fmYmf1Hi7/HeOqvm9mFmf0vM/tZM3vn/mdj7fqkmf1zM/tiO5k01CrnhYXD9r3Uj9humO4Xa7cHAKbsK/MnhBCeN/nhBnRTQaXg7s9098/f3794le16LjfrtgoApvnuGb0Xmtk/qN2WVEhQD/Us292IfL+ZfZmZPSdQYgIQ5+7fabsh47eGEH66dntSYYgPACCJCgoAIIkEBQCQNGsV3GvXroWzs7NMTSnj8vIy+z7Oz8+z7yOnmzdv2u3bt1c/WOzuwaz983GQK3ZUzs/x8Y21aehzl5eXt0MI16/6nRg9fL8gTmy8zLoHdePGjXBxMTT9vx3u+Rd0aP2+3o0bN+zi4iJZgmr9fBzkih2V83N8fGNtGvqcu1+GEG6s2X8P3y+IExsvXQ7xufuV/21h/yrOz88lvnynzv/Y9Spx7VTiJYTwwH8pPges1WWCAgC0jwQFAJDU5KuCa91HSrHfqW0wbJLO0LkueR9paF9H92yitrsmXg6/O9U2Ym6ZNbGU+vul12tIBQUAkNREBbW0Z5G6V7Fme0t7zL32jHJqLV7W9KbH4mVs/8f/NlZpYWesGk4l9fdLD9eTCgoAIIkEBQCQJDvEN3eYRr2cXTqMw83sOK3FS8yzRqdyxUvtc6GmxeGyuZN0WkEFBQCQJFFBtdb7TWVuL7mHHtEaQzfzY2Knt2nWsce/9XiJ1evEpJjvF/VjpYICAEgiQQEAJFUd4osd2lMvQ1M6Pdapc9TrMyyxqyAMiTkXtc9XqskMxMsyLQ/xrjEWL4rngQoKACCpeAVF1TTPkhviPZy7uWvWtXbMudq7Jl56i6EhVJAPpb6iCBUUAEASCQoAIKnYEF+vQzUlxQ57KZbqcxEv8wxd8y3FyxCeA5tnLF5qnTcqKACApKwVFL3gPHqdOEG8LDf31RpDWouXWD0dSwlzV2rJiQoKACCJBAUAkFR1JQlK7/XmPi/UspTxkmo4q7UJBoo3wlPqdZiyltrPyFFBAQAkZamgxnrz9GrymLqxqdzTrxEvqbY7th3lcz4ULy1XVcrnuge1VpygggIASCJBAQAkJRviS/EKhOPtUKrfKfbcjN0IV7mJnCpeSpobm7WPoad4GaLcthatiZdc558KCgAgqeo084MtTJFeinNzp1o381udELF1VFpxFM8NFRQAQNLqCirFFOGpKa+Kmb0FilPPe42XmOpq6nMprKm4ldZgG9PavcBelZh6TgUFAJBEggIASJKYJDFlizeglYdY1KnFS4l2pIiXrb7YcKnaw8pbQAUFAJCUpYJa05uIeWiw595KrnXpaq56nvOhXOJl2fUc6v0PnSeVSl6pWtlCXM2V6+FdKigAgCQSFABA0qIhvhJl/9gzGS2/FuBYzHksfYO9xfNott14OR1aKfFsUA/xMkZlWHOtHuKeCgoAICnZJImcmfl021OrLpdo01yxvbLcbW5ltYA1YuJl6N9bjJcDpbanVOPaxP6NKH3nDJ2n2iuqpLh2VFAAAEkkKACApCZWkliq5EvxUi3SuRW1jzl2mPjYFuNlC0PCpxSPM7ZNvU1goYICAEiaVUFdXl5K9i6WWnoTL/U5UOr1pDy2WvGS68Y68XKnnr4PeqM0iWMpKigAgCQSFABAUlOTJFSeDVmyXYZCyhlbXSHXYrwx7ZmDeNFXe7LKFiawUEEBACQ1VUG1ptdezRo1btK2ch1aaWfv1CuTua/OaW1ixDEqKACAJBIUAEASQ3xiFBcuTanE8SkOy+TSe7zUpnxelduWChUUAEDS6gpqC1m8V3NvtqbcZ4l9xLzg7ypjlYnSSg4l9RovyCPFtaOCAgBI4h5URkumq9JjzCvFdUhxjYaqsDXx0vu9qK1WrVtHBQUAkESCAgBIWp2g3L3YTdMQAuV9Qrmv3fn5+R3XK9c+D9s9HQraSryUONaSf+un+zwcX4nrORRLmC/FOaSCAgBI6nKSxFZ6zXjQ1HTw08/VvulOjLahxur3S/Q6CYsKCgAgiQQFAJDU5BDf1Mu7FMWsbtCby8vLWTdJY4fdYj+X61mm2tew1ESBUvuq7fRYWzzmFtscgwoKACCpyQrqWGs9h9baW1Lsuam9Pl7J9QRTi62MthinW6oaW0EFBQCQRIICAEialaCGVgZAX0IIdn5+nmRbJeNl7koDrawWkLqdqVdjaHW1jrHz2kpsLNHacVFBAQAkNT9JAliilV5/K+0EcqCCAgBIIkEBACQlG+KrvfjmEilvFm7xmNcgXrZ3zEvUWNy35EodpfebW+rrRAUFAJC0qIIaWgtPXe52ttwjKtkjTXEdSvSma8TLMeXYUW5brLGYbLG6j9Xa8VBBAQAkkaAAAJKyPAelsuhiyWGUq55Iz7GvJZSHYufGS61zOXe/sW/0VaTWvlqv2Mn1Rt3a3wep5bomVFAAAEldriRRY8LC1CsgVKpK3ClXvMx9YWKtqmXrsdlKVTsmV6VXGxUUAEASCQoAIGn1EN9YeVxykoDic0hDN3Zrn5NjNc4P8RInZfumzmvsEJfK+cm1uoTSsGsLSvy9UkEBACQ1P0lCvSd8MNTr2/rN6RTmnsOS8ZJi+nyKeNlSfNWqwrd0jkuiggIASEpWQU2tt0a1UE4LU063EC+ttL2FeBky9fBu7M9SUDyHKiMDa1BBAQAkkaAAAJKyTJJQmUq8Ja1MER6yJl6UjyvW2FBU7n1epbXzOjb1vNfvoakJPymH4mqdLyooAICkqtPMU2b4VnpBOV/e15IlPbKe4mVJZTh2rWPPTWy89DBJJbYyHTvWFA/v5qo+po5r6er7Si+kpYICAEgiQQEAJGUd4ostFeeWwLXLztRyHb/y8MzUcErteMk9xLXmZvbQ8Y/9bsmb6bXFrn+Z+jukxjp+udYiVFqdhwoKACCp2CSJ2J5LTG+uh56eWZpXiKfYbi6Xl5fm7ovaEzttOFe8xFYkJSdsjPXSl06qmLP/1ozFy5DYSjI2DnOv5FBiu7VjgwoKACCJBAUAkFQ8QYUQHvhvjLs/8N+WxZ6H2PNa0vn5+er2HB/X2HkoGS9K53ppO5SOIbe5x7rmb65EHB7vd+01HGqvUmxQQQEAJFVdSWLuxInT3+vR3J5Xz+fiFPFyJ+JlnrnTzGMnDrRyXhVfCzKGCgoAIIkEBQCQVHWI72DNMxxj21DH8MwyxEucuc9NbcncGGrxfPVwPFRQAABJEhXUkLlLvqv3kpdOO1U6hhpiVzwgXnZiV0HAnWJfcHj6eQWtrTITiwoKACCJBAUAkCQ7xHfstCxd8wzD0n2u3d6a/W5ZioVeiZfltrCo7KnYa6keLz1cLyooAICkJiqoUzHr+K2Vq/fbQ68m1uF1G8dqHD/x0u7+VZQ4D5zrO1FBAQAkkaAAAJK6TFBDy9GXXD6+9v5VHF63Ufv4p16BMNS2LcbL0HnitTeoqcsEBQBon8/ppbn7fWZ2K19zIOKeEML1tRshXjZldcwQL5sSFS+zEhQAAKUwxAcAkESCAgBIIkEBACSRoAAAkkhQAABJJCgAgCQSFABAEgkKACCJBAUAkESCAgBIIkEBACSRoAAAkkhQAABJJCgAgCQSFABAEgkKACCJBAUAkESCAgBIIkEBACSRoAAAkkhQAABJJCgAgCQSFABAEgkKACCJBAUAkESCAgBIIkEBACSRoAAAkkhQAABJJCgAgCQSFABAEgkKACCJBAUAkESCAgBIIkEBACSRoAAAkkhQAABJJCgAgCQSFABAEgkKACCJBAUAkESCAgBIumvOh69duxbOzs4yNQUqbt68abdv3/a12xmKl8vLSzMzOz8/X7v5ZGq06bDPY1P7H/qd2N/N7fLy8nYI4fqabfD9sh2x8eIhhOiN3rhxI1xcXKxqGPTduHHDLi4uVieooXhx3212TtzlVqNNh30em9r/0O/E/m5u7n4ZQrixZht8v2xHbLzMqqB6MPZHnkrtLwtlQ+emdtIa269SvBBX+pTipQfcgwIASCJBAQAkdTPEV6K0jhXbli2V6mNqnAfiBXMQL3VQQQEAJDVZQSn1ZtZYMpML8xEvbe2zNuJFBxUUAEASCQoAIKmpIb4UpXeJEndNO2s/E9QT4mW9LcXh3OugdG5i297a9wsVFABAkmwFtaZXWbt3kGJlgh5ucOZyfG4O56RkvAztf4258XL8+cO/Ey/ztFwtDRlboWVIK/FCBQUAkESCAgBIkhvi6630PjW3FB/6XGvHnNrQENeS302hxiQF4mW5mHPXy/laOuyndPxUUAAASRIVVO1ecG1zK4LUN+lbUzte1mwvRS+VeJlnS2vXTYmZVKQUL1RQAABJJCgAgKSqQ3yU3nc6Pdapc6R4YzOXHuIl93BjLwudpjB2LpRjpITYCRS1v1+ooAAAkopXUD30gkuKvSGudGMzJeJlnql4GVtBoIcYmoqXVo+rhLEJFLVigwoKACCJBAUAkFRsiI+hmvViF0atfWNzTGzbiJf1eoiXWEyISCd2mLjEeaWCAgBIklhJgh7OPGvWoqst9+spjpXo6alVH0M3s1uOlzVUrknLUrzOZg0qKACAJBIUAEBS1iE+nknIT/HZhaVSx0uKY546h2rndao9vcdLC+3uRYl4oYICAEjKUkFt6UZsK9Ru5h9TjhfF8zVXa5XRFOV46VWtqedUUAAAScWnmffQg1PU61Ti1l7Rrrj/qXtntR/GTKGVdvag5NRzKigAgCQSFABAUrIhvtrDSkprt9VuSwtTiWPPUer2zh2eiF0zMLZtYy+Kix2mzfXSwx7ipQSV6e0q7TiWOl6ooAAAkopNkkiZ2df0pnL1CJe0SbEHlNvcF+al6NX3Ei9Dv9t7vIypPRpS+9wPVdwlv1NKTMyiggIASCJBAQAkSbxuo5YUz3oo3bxtwdDQ3dxhFKVnmOa2ZexYc8USQ4LztPg33cJElyWooAAAklZXUCVvIrbYs5kr5RP8iqsFEC93Guv9Dl3DqZ+NbSOmHVe1RSVecu1/brwoTXKa+9hGiUcVUuyLCgoAIIkEBQCQtOlJEoBZ2sUvl9yQnjtxopWhy9akiAPF5+ZamxhxjAoKACCpqQqq5DLvtbTc28lhTY80Nl5SxtOS67cmrokXXSqPsTDNHACAxEhQAABJTQ3xoX2pX3exth1z2pJL7AK6KbeL9UqcyxSvZ2kZFRQAQFKWCip3zyJVz6HGC/BytSN2H7V7Wql79XNXUhh7LcGUXPGSYn3CNZ8b+93a8VKDemWiMgpRAhUUAEASCQoAIKn5SRIq5e6SYYGWS28VuZ6NWrr9ue1QaAuu1vJQZw/xQgUFAJDUfAV1oNRbUGoLhtW+Ri0+3d9KO3NQPHbFNqVGBQUAkNRNBQXkkKLSGdpG7Zf+HZu76voWeu7QQAUFAJBEggIASGKID5s3NnSVcvWIVG0qsf8ta3ECS6+ooAAAkuQqqBYfiCuNXt2DUsaLYuylaBPx8qC55zPFmogl1H7pZi5UUAAASSQoAICkLEN8PC+hR3H46kAxXsbWYFN/HUMKscfV6/GfUorNIS2vGTiGCgoAIElukkSvPQGsN1Rp5YqXse3Vjk2lCq61v1eV1exzGXtFfIuooAAAkkhQAABJckN8MVoru+do5bmLlGKPa+nx93repmz1uNfq7bzFDgkrHjcVFABAUpMVFPoyNs18S+uibelYgRhUUAAASSQoAICk1UN8Y88VMGRRV6o3qaY0N162FDdTx5p7xY1W4kVx5ZG5plYoaU2u46GCAgBIkp0kMTY1srfKrLWpn7XEvliwhXhZ0qaYVRBUjk9d7XhRuU4q7bgKFRQAQBIJCgAgSXaIL1bLN0xbXsSxhhTXeCheasTQkme+iJeHKjEU1/L3S24l4pEKCgAgKVkFNbXe05qeSMzNYcUb4UNKLPPfwk30qQpmi/GypmoaO4Y1lZnK6h45XzEyN16G2lTb3GvYyuQPKigAgCQSFABAUvFJEmuGB2Lfhql4YzP30F4PN9BTr0ZCvFz9maHz2vJbZlNcwy1MTEk50agEKigAgKQsFdTcHtnS7U/to/aNcKXel2Kv96CHeEnRg68VL+oTAE6prP+5pe+XWus0UkEBACRlvQeVc+r56T5i7zOMbWOJNb2Y3OPByr3gIS3HS2ybeoiX2pXD0L5zxUssvl/yoIICAEgiQQEAJEmsxZdiyGDNk+Ylbza2Ns1TydDwXIp4OYg9r1uPl9aGjmsPSdaKl6VDnErfL1RQAABJxSqokg9Nqjxwl7q31vKDlHONver7WMob4TnXe5u7/xTG1jjsTa7vlxKTX5aaaluuyqnk9wsVFABAEgkKACCp+CSJWqtA5B72y/3CtFr7r414mWdqdYXc+6+NeJlH/fuFCgoAIKnqNPOlT/WnyuaKvci5vS7FYxiT4kWEQ9sb+1mqFRIUz3Xv8bIG3y9XU6+cDqigAACSSFAAAEkSK0nMfU6j9pPhqW1pmKb2k/xj+2/lvG4pXlLY+vfLsZjjVzpmKigAgCSJCurY3JfXtTaFtvby+b0Zi5fY1SiUzyvxklbv3y/Heqi0qaAAAJJIUAAASXJDfAe5XodQ++2asRTL7drGnqEqGS9zb6JPfb61eOlhEkGKeFE69h6G84ZQQQEAJMlWUEPm3uAcov66gVZ6NrmlfO1Kznip/XLMGvHSa4ymmEChrrVrRwUFAJBEggIASGpqiO9A5Y25a7VWbpeUa7HWFMN+tRAvZfD9ooMKCgAgqckKasiSVyrk0kPPpYZc05eXTEsvWWkRL/r4fqmDCgoAIIkEBQCQ1M0QX6wtlcetqX1tFN+im3rVihRtqX1OlHFu0qKCAgBI8jkZ393vM7Nb+ZoDEfeEEK6v3QjxsimrY4Z42ZSoeJmVoAAAKIUhPgCAJBIUAEASCQoAIIkEBQCQRIICAEgiQQEAJJGgAACSSFAAAEkkKACAJBIUAEASCQoAIIkEBQCQRIICAEgiQQEAJJGgAACSSFAAAEkkKACAJBIUAEASCQoAIIkEBQCQRIICAEgiQQEAJJGgAACSSFAAAEkkKACAJBIUAEASCQoAIIkEBQCQRIICAEgiQQEAJJGgAACSSFAAAEkkKACAJBIUAEASCQoAIIkEBQCQRIICAEgiQQEAJJGgAACSSFAAAEkkKACAJBIUAEASCQoAIOmuOR++du1aODs7y9QUqLh586bdvn3b126HeNmOy8vL2yGE62u2QbxsR2y8zEpQZ2dndnFxsbxVaMKNGzeSbId42Q53v7V2G8TLdsTGC0N8AABJJCgAgCQSFABAEgkKACBp1iQJYI7Ly0tzdwsh1G6KDPfd5Mg15+SwjbXbidlurn0BMaigAACSSFAAAEkkKNsNYyz9D1c7Pz/vclhoTYyEEFafk8M2Up/boe0O/Yy/A5RCggIASOp6kkSJnl3sPnqsJHqTK16mJh8MUZ6kMNSOrVdRNY5fJR5yooICAEgiQQEAJHUzxKc01DbUlqGfbaFEn6PkcFbteDmddHBq60NmamrHy7FDW7bwnUIFBQCQ1GQFFXuDuZbYm8hb6AHNMVRVpDgfS+JlaQWz5JrWjpeU57oHLX+/qLd9LiooAIAkEhQAQFJTQ3xj5at66Tp3GEf9eHLLPbS3ZNgtRqrrVjJeth5rB3y/6KGCAgBIkq2gWu7NxIq52dnLsaY0d2UGxXO4ZEo98ZJOa/GyRA/xQgUFAJBEggIASJId4hsSW462Ur4OOR2yUlwsNFauN+quGRIbkuuZq7HtpZ5MMRYvLcdQSVs4N619v1BBAQAkySWomJe8xb4gruWXDQ69kK6Fdh8r8cJCtXjJ9TLB2P0eO7S7VpsU5XqJZGta+X6RS1AAAJiRoAAAoiQmScQugplisUy1EnbK0AKq6jc2cyNerka83Gnrxz9GPV6ooAAAkqpWUEt7uIrrjqXqacdMTT69sT/1e73oNV5iVsO4CvFytdaq39oU44UKCgAgSeIeVOoHL4fU6AlsoZeay9j16i1eavdS12ihSmnxvNY0dF+qFiooAIAkEhQAQFLxIb6SJePYC7vM0pb+tYYOFaeGprBm4sDSIbOS69ilGH6M3U7OeFlznXIo+XfQ29/cmFrHSgUFAJAkMUkitRq9ual99t7DihUr/XppAAAXxElEQVRb3ay5hikexo3df4pqbcjSldCnerpqFU9qTGpJq3a8UEEBACSRoAAAkooN8aVYF61luYYFFJ/+HqO4qoOipddwyTlSjpdYuY+h1yHRWEMTbUrECxUUAEBSl5MkgKuk7v2dVrClq5Aeqh9lY5WT0qhQr3FABQUAkESCAgBIKj7EV7sErbX/3PtVWuAxpVyTSlJ/vlY7l+63t3hJef4Vz8fc5/LM6n/XpkAFBQCQ1OUkiR56DrhabC8x9saxcrxMHWuvN8exXq5JHKzFBwDYPBIUAEBS1iE+xZuNudR60ronsfFSa+JCSrHxEjs8ucWYqz0hoPYrdnqb6DKECgoAIKnLSRK1qfRia/cwEUflxnVr8ZKrjeqVydxXYJRYnzDXPqigAACSSFAAAEkM8WFTWplM0Eo7e6d8/pXblgoVFABAEhUUIKh273isgmttMgXaRQUFAJBEBYVmpLgvMzRFd6pKGPtcr8aOtcZ5oGrTwyvfAQCbRYICAEhiiK9jvQ2FpDwe9Vdw1JhmXvuYx5RsG8OJOqigAACSslZQ6mtaQctUvGzp4dXcrzBPtf0e/65jv7e2EIe1UUEBACSRoAAAkpqYJJFyaCfFkASlfR1jzyuVeKXAUrXjJef+5776QdGaF0YiLyooAICk4hXUmimcKVcSSK321NSWe7Bjps5rzCoQqeIl5WQD4kXPlibhtIIKCgAgiQQFAJAkO0libAii9vDIEJV2bFWJeCm5kkUKDFldrbXvl1RaiwkqKACApGIV1NB01NayuaKeXgsx1HOtHS8le9Op9zX3NSI9Vw5oExUUAEASCQoAIEl2kgS2R3FYaUuvu6i9/y3paWg+JyooAICk4hVUK6/gmNu2Wjfua+x/rjU335fES4314YiXtrTyPZRaa9edCgoAIIkEBQCQJDFJIsUCstCVelhhKl5On5caepYKiMEbdeuiggIASKpaQbX6srNaPaet3+yeGy8qcdVyvGxhdYlWv4eO9VrpUUEBACSRoAAAkiQmSdR+JkG5BN7qsN7YwrDEy9VSx4vysaYWu7hurn3hTlRQAABJEhVUbYo3grdaOR0oH2tsvJR8PUjLN/hTavn1KCmotCMVKigAgCQqKDGnPeHeekS9GqqWalROW4+XofuTUz9Loddp3rVRQQEAJJGgAACSGOIzrSf9DxgW0NVavCy5mV9ygkcuYytEKE5wmGtqYkwP15AKCgAgiQrKyvSm5r5sD7qG4qXETfehiiBmv0vaNrfSUjb1YHfsQ+Fj2xiT6/tl6riWrruo9B1EBQUAkESCAgBIkhvia3Xp+yXtVSqla1oztFAjXlJct6Fhn9Zi3qy9tsdMnEg1JJr7nKQeOlT8PqKCAgBIkqugaiixOrZi70RFy+cmRbzMvcHd8vlqwdT1GKrCSq4k0kq1mgIVFABAEgkKACCJIT5bVzIz3NK3oeHfuc+01V61oPb+exB7zUuc6y1dQyooAIAk2QqKiQuYI1e8TPWIFZ++P6XctlpKfL9gPSooAIAkEhQAQJLsEN8xhigwR8l4iXnNBfGrjeujiwoKACCpiQoKSK3WdGDFqkqxTYAZFRQAQBQJCgAgiSE+bFKJhTxj39Cam2KbgBhUUAAASVRQQEK1q5Ghaql2m4ClqKAAAJJIUAAASQzxARXkeg6L4Tz0hAoKACDJ5/S43P0+M7uVrzkQcU8I4frajRAvm7I6ZoiXTYmKl1kJCgCAUhjiAwBIIkEBACSRoAAAkkhQAABJJCgAgCQSFABAEgkKACCJBAUAkESCAgBIIkEBACSRoAAAkkhQAABJJCgAgCQSFABAEgkKACCJBAUAkESCAgBIIkEBACSRoAAAkkhQAABJJCgAgCQSFABAEgkKACCJBAUAkESCAgBIIkEBACSRoAAAkkhQAABJJCgAgCQSFABAEgkKACCJBAUAkESCAgBIIkEBACSRoAAAkkhQAABJJCgAgCQSFABAEgkKACCJBAUAkESCAgBIIkEBACSRoAAAku6a8+Fr166Fs7OzTE2Bips3b9rt27d97XZKxMvl5aWZmZ2fn2fdzxqHNh5Tbu8Sl5eXt0MI19dsg++X7YiNl1kJ6uzszC4uLpa3Ck24ceNGku2UiBf3XR5VjstDG48pt3cJd7+1dht8v2xHbLzMSlCAmhBC7SZMaqGNgCLuQQEAJJGgAACSuh7iGxr7r4VhHn3Ey7jD+VFsWw3ES35UUAAASd1UUEq9mSFD7eu119OCqesxVC2UjLEa8XK8z6F9bTle+X6pgwoKACCJBAUAkNTkEF9sua1U4g61udeyXM2S4ZnaQ1xz4yXFBAZib4fvFx1UUAAASU1UUDE9GvWewVD7Yno96selKKaaUD+vsfGC9fh+0UUFBQCQRIICAEiSHeIbK7vVy9JYMWX51LMp2BkbzlA6b2vaRLykw/fLnf9b8bipoAAAkuQqqC30bMacThs+plgR1NZavKRu01i84E6txUtqrX2/UEEBACSRoAAAkqoO8W293B4zdoOzhyfEl1CMF5VhkbnPTdVubwlbP/4xrXy/UEEBACTJTZLYes9mzJZuiMdWJrXjpfb+x2wpXmIpX6/aFOOFCgoAIIkEBQCQVHyIT+kGXKuG3vKq/kT4XGPDDT0cX0mp4kVlQsgY4mU9pe8XKigAgKRiFRQ9mzyGKo0WerpT1sRLD8efC/GCOWrHCxUUAEASCQoAICnrEB9ld12tTZxYEi9Dww0xx9rauSlh6Jwonye+X+oqERtUUAAASXIrSWCZoamhKtb0tHL16lvpaefqpcbGSyvnCXnV+n6hggIASMpSQamMDdceP6+1/9pTQ69qz1XmxkuuYyh5vWIrwxLXa2xla8UKSuX7ZatKfr9QQQEAJJGgAACSupwkoTZJwEx7yCSXy8tLc/foV2YoXrdclkyfz21L538NlSFGlXbkRAUFAJCUrIKqlc2Vp8hOrQo89LmS+899fs7Pz+3i4mJyQkCp9ly135L7H7P1eBlDvIzvv9d4oYICAEgiQQEAJDUxSWLuzdvapfeQsaEt5WGEFJY8hb5mkgDxknf/vWvxmGPjRTHWx1BBAQAkra6gUtyU66HHG2vuqgpT5yb2XNRcXWLJMYytrrDVeBm6XnPjZWi7sVSmvudeSSS24lea5h17bXJdw1zfL1RQAABJJCgAgCSJSRItD8Gk1uO5WLNU/9jw39aUPBctThRYS3liyNzJRWZ9/O1QQQEAJElUUAC0KFcTiKM0iWMpKigAgCQSFABAEkN8gIiWn/jfohpvyTab/7xWy6igAACSqKDQtLlPq6d4uj1XpZNrdQcqs3nUK5O5E1havuZUUAAASSQoAIAkiSG+kkMQqZ8NqPGswZaGbKYWi405/jXnSz1eer/+tSmfX+W2pUIFBQCQJFFBHUvxMraSNw/Hlplfs0/Fm7M1zH09ydDvrtnGnLbM2QbxAkyjggIASJKooNa8IKw1KY5hC2PPY9OnYx9a7O1cLz0epWMA5qCCAgBIIkEBACRJDPGVlGu4Q/3p89akmA5eQ+yU9tTD2rweI50tPcahjgoKACCp6wqqVu9naL/0bPWlnEa+9nfmxgvxFSfleVWqrlJef6XjooICAEgiQQEAJEkM8a0pT5XK0TGxr0OIsfWbuMTL+PqEMZ9f06YtxV8rx5fy+0UJFRQAQJJEBQX0LGfFUbJ3nOJlj7UxHb8tVFAAAEkkKACAJIb4sHm5h65aHhJD+2JXLVGMUyooAIAkKijbxrRlFYo3qUuu+0e8APGooAAAkkhQAABJq4f4hoZsVG46lxhGmvs6hKl/y9Xmoe2qDDepPF/TYrzM3W4slXhR/n5ZQ+X8ppLreKigAACSqk6SKFktHNTqHeXq9alUHyUsjZepc1MyXoau15p4WbqOY+xx9RpXY+e/xFqDKudVpR1XoYICAEgiQQEAJCUb4hsqmUsuy69003HsJvZWz8mp2HhpbdLI1HaH9qEcLypqfb/Uvl2grMT3CxUUAEBS8ytJKPf6pmxpgsNSqafgx25j6bVJfS2Hjp94SUtxdZO55lZ6rcQQFRQAQBIJCgAgKcsQX66nv0su6llLiuEG5ckRB1M3uFXipXYMTe1/K/FyrOT3S+3rn1qJiUApUUEBACQVnyTRW49ERWvnNba3WqKC2KJez1etafk1Ks6S17BWvFBBAQAkZa2gSqzSjasp3kcYu1ewJF56iKsa9z56+Ntcsp5h7jUxh6zZV+2XY9Z+UJkKCgAgiQQFAJBUbJIEN7PLURzaO5j7moce4iV2KGqJmN+tvU5mCWPxMvWzntY4TDGcGTsxqQQqKACApObX4mu5p91Dz7U1NeIl1b7GJpaM7aPFv42SYifunH6+tqnKvIeFDaigAACSSFAAAEnND/GhfbxG4k4tD13XVOv5rtxDgVPbX/q3E9vGWn+bVFAAAEnFK6hcPZxWnozP1RNpufoYa3vJeFGKodxVZcvxEmtuFRp7zmNXU6/xGvrU26gdJ1RQAABJJCgAgKSmJknMLcGHfrekJeVx7aGlnqyJl6VSxV5sm1LGS2+rSxzMHbqNPQ+1VujIvfis0rWnggIASGqqgjpY8tS0Uq/ggGopr7Gb5HPXBEzRjrVKvoKjV0snTgxtY+pntc2NF8VjoIICAEgiQQEAJFUd4kv5tHyKxRJzyjU8o3SMMeY+3zN00znF23anbmbXPq/ES15rJrMornzSw3DeECooAICkLBWUys1/lXbktOYYa/SiUvRcU2tlRZMUIw6txUtJKSt0Va1dQyooAIAkEhQAQFKWIT6VlRwwTuVmr0q8pBieWzOpY86250g17KgSL7mpxONaPVwnKigAgKRi08x7yOYop3a85F6fb4j6Om5bxnmrgwoKACCJBAUAkNTkYrHAqR5eFTHV7q1MUgAOqKAAAJJ8Tm/M3e8zs1v5mgMR94QQrq/dCPGyKatjhnjZlKh4mZWgAAAohSE+AIAkEhQAQBIJCgAgiQQFAJBEggIASCJBAQAkkaAAAJJIUAAASSQoAIAkEhQAQBIJCgAgiQQFAJBEggIASCJBAQAkkaAAAJJIUAAASSQoAIAkEhQAQBIJCgAgiQQFAJBEggIASCJBAQAkkaAAAJJIUAAASSQoAIAkEhQAQBIJCgAgiQQFAJBEggIASCJBAQAkkaAAAJJIUAAASSQoAIAkEhQAQBIJCgAgiQQFAJBEggIASCJBAQAkkaAAAJJIUAAASSQoAIAkEhQAQBIJCgAg6a45H7527Vo4OzvL1BSouHnzpt2+fdvXbod42Y7Ly8vbIYTra7ZBvGxHbLzMSlBnZ2d2cXGxvFVowo0bN5Jsh3i5mvuD+T+EULElabj7rbXbIF62IzZeGOIDAEgiQQEAJM0a4gNK620o7GDqWA7HPfS5EudkbP9AKVRQAABJVFCQ1koPPnXFMbadEueklfOOvlFBAQAkkaAAAJIY4gMSOAyJpZrAwCQFgAoKACBqMxXUcc+2FHq/aS2tKpZUNSniZe42jts2t51T09HnbndoG8Tz1fh+yYMKCgAgiQQFAJDUzRBf6hI7dshkTIohFjxo6blLcS1L7GNJvOR+Xop43Ym9liXO16EtW/h+oYICAEhqsoKq1ZtZc4N57Gdr9tGTXDfkY7eb69wfb3fupAbipTz1cz4WO+ptn4sKCgAgiQQFAJDU1BDfWPmqWLouuXG+5RUEUh+zYrzMfV6pdrxs6TkoxXiJNXfIWP14DqigAACSZCuolnszY2JfVNdaT6c2xXiJ3e+aiRu546XX+FOMl9RiJlOoHysVFABAEgkKACBJbohvC6X3mNOb4y3fpL68vDR3z9pu4qWfeKltC+ertXihggIASJJIUO7+wH9DQgiS2T2noWMeO0eKzs/PLYQweX3nIl7uVCJeWou/IUPHQLzsKF5fiQQFAMApEhQAQFLVSRJbWC5+raGFRls7b0veYpvrDbG9yxkvrZ5r9YkANU3FS+3zRQUFAJBUvIJKcRNuzTZq9wjWiF2frVW5XixIvMQdv1LPOYVe/05yGYqX2itOUEEBACRJPKgbu95Y7OfnbGvt9mpQHzc+lbptxMs8sfHS2nHF6vW4chmKl1qooAAAkkhQAABJxYb4UgyVpB4eamF4rAdLzmnueIm95inihfgqp+S53tJ1rXWsVFAAAEnFJ0mkemgzZVuUplXO1cMxjMkVL6keVI0517GTOkpcr7F4mfpcC/FUoo09/X1Nqf1oCxUUAEASCQoAICnrEN+SsnBp+bzmprrSvP+lWp78seac14iX1JYOHc753Njne3jpY+5ht1a/F1IZipcSsUEFBQCQJLGSxBpjPZslveTTm4Kt9CBbVvJGbMl4WRNDS6r/HJ/futTxkkuv31dUUAAASSQoAICkYkN8KUvPFm9YKg0HtKBGvKSeLLPmWSLiZZ7ev1+2+soUKigAgKQsFZRiD6SkJb2dg5TrDbZyHVTamasdc18PMudzW4wXxMkdLyVQQQEAJJGgAACSmn8OSkWq4ZFczzP0+pxEbmtuOo+d89rxMnVcLcRL7QkBJfc59Xxdr8OzVFAAAElZK6jcr8kwWzaFOOXnc/VcWujBptZbvOSsnK7absnXTZTa31WU4qWkuZNaSqxPmGsfVFAAAEkkKACAJNlJErHlo8pkglztQJyS8ZLiDbS142XN/hl21qDctlSooAAAkuQqqBpPta/ZV4kbtVsUW8kOxUvNCSax7S29X6BFVFAAAEnJKqjUFU+JVwz3vmK08nTZqfasuQeY4lhjH4YkXspQmdqOB/HKdwDAZpGgAACSkg3x5RweGJs4wQvgrqY2THNMPV4OtjS01Eq85Lala66OCgoAIElumvmYNWub0RPq21Cvl3jBErHVPTGSHxUUAEASCQoAIKmpIb4hlNkwi4+DuWvm5ZJq/1t8LUtqY+eQ81oXFRQAQFLWCqp2LxVtKRkvteMxRdW0djtr9ltj/7lRjeqhggIASCJBAQAkNTVJQvlJ99RSDzMoD1vkesXKFuIl17BU7xMGxmKj51sTrQ1jUkEBACQ1VUEhTmuVQ0+9WeVXVlyllXZie6igAACSSFAAAElZhviGbnrXuDmX6lmTXNvDTsl4ybWSxGF7qVeISK21m+S96v2ZslSooAAAkpgkIYZeVDqxlVmKqiLXVPmpfcxtM/G10+JklhRau/5UUAAASSQoAICkrEN8qcvoEsMorerhpmuJYZe5MRR7XkvEZMp99BAvJfBG3bqooAAAkopPkmhtZYASOA9XSxEvayozxZcJjm0v599Xr1PUexiZ6bXSo4ICAEgiQQEAJBUb4ku5WkDJZxjUy+Neb3arrEYyV+22Te1/TbzUPrbcSk5+6f1cpkIFBQCQJLGSRIon41u5wZly3bfU220F8TLPluKl5CQsxQlfKu1IhQoKACCpeAU1df+ohftStWypJ3xAvCxHvORZd3FIr9O8a6OCAgBIIkEBACRVnSQxdsO69g3IXDenU2xjq0MGxMsyxItevKQwFS8tPJYxhQoKACBJYpp5rhvhLfeSer1xnwLxcifi5Wpr4iXFw7u54mrquJbGv1LsU0EBACSRoAAAkiSG+I7F3NhUKkFjxb4iYc7vgXiZ83vIFy81XmKZeuhQMXaooAAAkuQqqIOxHsnUDcHaK2GveZ34gWJvJqUSvb9c8ZK67WNxEBtLse2Y+3fQ8sSRpVLFS67ztaUJMVRQAABJJCgAgCTZIb4hsU+Gj8k1ZBH7VPeQrQydHFtyzHOHp4iX9b+7xdgcUjtejm3pmlBBAQAkNVVBHaSa0plixYG5ttT7SW3pueslXrZ0czw3zmsbqKAAAJJIUAAASU0O8Q2ZGnZJ8axJqragvlzxsmboqMQzV7gT51UXFRQAQFI3FdQUeknbkWLVEJW1zYhbbBkVFABAEgkKACBpM0N86NPcRTqHPt/yazkOejgG4BQVFABAEhUUpE1Ns06xtpxi1bF03UGgJ1RQAABJJCgAgCSG+CBp6zf9t3rcwDEqKACAJJ/TU3P3+8zsVr7mQMQ9IYTrazdCvGzK6pghXjYlKl5mJSgAAEphiA8AIIkEBQCQRIICAEgiQQEAJJGgAACSSFAAAEkkKACAJBIUAEASCQoAIOn/A/bN+3d/+SiMAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10eb1fa58>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "images = list(map(standardize_image, [\"mad_emoji.jpg\", \n",
    "                                      \"happy_emoji.png\", \n",
    "                                      \"think_emoji.png\",\n",
    "                                      \"sad_emoji.png\", \n",
    "                                      \"goofy_emoji.png\"])\n",
    "             )\n",
    "\n",
    "strings = list(map(encode_image, images))\n",
    "\n",
    "T = weight_matrix(strings)\n",
    "\n",
    "fig, ax = plt.subplots(nrows=len(strings), ncols=3, figsize=(6,12))\n",
    "for i, x in enumerate(strings):\n",
    "    #x = strings[i]\n",
    "    noisy_x = flip_random_bits(x, 100)\n",
    "    x_hat = closest_minimum(noisy_x, T, bias=0.0, maxiter=10)\n",
    "    plot_string_to_digit(x, ax[i][0])\n",
    "    plot_string_to_digit(noisy_x, ax[i][1])\n",
    "    plot_string_to_digit(x_hat, ax[i][2])\n",
    "ax[0][0].set_title(\"Original\")\n",
    "ax[0][1].set_title(\"Observation\")\n",
    "ax[0][2].set_title(\"Memory\")\n",
    "fig.tight_layout()"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}