Non-tradition_auto-association.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bb44be4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.cluster import KMeans\n",
    "import scipy\n",
    "import math\n",
    "from datetime import datetime\n",
    "import matplotlib.animation as animation\n",
    "from PIL import Image\n",
    "import random\n",
    "import pandas as pd\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "import os\n",
    "from sklearn.metrics.pairwise import euclidean_distances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5f7d29c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "epsilon = math.ulp(1.0)\n",
    "\n",
    "def softmax(x):\n",
    "    return np.nan_to_num((np.exp(x)+epsilon))/np.nan_to_num((sum(np.exp(x))+epsilon))\n",
    "\n",
    "def simulate_allstarts(eta,simlen,beta,a,h,noise,H):\n",
    "    m_log=np.zeros([simlen,P,P])\n",
    "    x_log=np.zeros([simlen,P,N])\n",
    "    x_last=np.zeros([N,P])\n",
    "    projection=((a*xi)+(h*(xi@H))).T # auto+hetero\n",
    "    for start_node in range(P):\n",
    "        x=xi[:,start_node]+noise*(np.random.rand(N)-0.5)\n",
    "        for t in range(simlen):\n",
    "            r=softmax(beta*(x@xi))@projection-((1/N)*(xi_mean.T))\n",
    "            r=softmax(beta*(x@xi))@projection-((1)*(xi_mean.T))\n",
    "            x+=eta*(r[0]-x)\n",
    "            m=np.zeros(P)\n",
    "            for i in range(P):\n",
    "                m[i] = np.corrcoef(x,xi[:,i])[0,1]\n",
    "            x_log[t,start_node,:]=x\n",
    "            m_log[t,start_node,:]=m\n",
    "        x_last[:,start_node]=x\n",
    "    autocorr = np.corrcoef(x_last.T) #correlation between attractors\n",
    "\n",
    "    return (autocorr, m_log, x_log)\n",
    "\n",
    "def simulate_allstarts_freq(eta,simlen,beta,a,h,freq,noise,H):\n",
    "    m_log=np.zeros([simlen,P,P])\n",
    "    x_last=np.zeros([N,P])\n",
    "    projection=((a*xi)+(h*(xi@H))).T # auto+hetero\n",
    "    for start_node in range(P):\n",
    "        x=xi[:,start_node]+noise*(np.random.rand(N)-0.5)\n",
    "        stim_node=start_node-freq\n",
    "        for t in range(simlen):\n",
    "            if (t>1) & (t%freq==0):\n",
    "                x+=xi[:,stim_node%P]+0.0\n",
    "                stim_node-=freq\n",
    "            r=softmax(beta*(x@xi))@projection-((1/N)*(xi_mean.T))\n",
    "            x+=eta*(r[0]-x)\n",
    "            m=np.zeros(P)\n",
    "            for i in range(P):\n",
    "                m[i] = np.corrcoef(x,xi[:,i])[0,1]\n",
    "            m_log[t,:,:]=m\n",
    "        x_last[:,start_node]=x\n",
    "    cor_activity=np.corrcoef(x_last.T) #correlation between attractors\n",
    "    return (m_log, cor_activity)\n",
    "\n",
    "def get_h(a):\n",
    "    return 1-a\n",
    "\n",
    "def get_a(h):\n",
    "    return h-1\n",
    "\n",
    "def corr_steps(x_log, xi, steps):\n",
    "    corrs1 = corr_step(x_log, xi, steps[0])\n",
    "    corrs2 = corr_step(x_log, xi, steps[1])\n",
    "    corrs3 = corr_step(x_log, xi, steps[2])\n",
    "    corrs4 = corr_step(x_log, xi, steps[3])\n",
    "    return (corrs1, corrs2, corrs3, corrs4)\n",
    "\n",
    "def corr_step(x_log, xi, step):\n",
    "    corrs = np.zeros((P,P))\n",
    "    for x_last in range(0,P):\n",
    "        for pattern in range(0,P):\n",
    "            corrs[x_last,pattern] = np.corrcoef(x_log[step,x_last,:],xi[:,pattern])[0][1]\n",
    "    return corrs\n",
    "\n",
    "def load_image( infilename ) :\n",
    "    img = Image.open( infilename )\n",
    "    img.load()\n",
    "    data = np.asarray( img, dtype=\"int32\" )\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9c8e5385",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fashionmnist\\fashion-mnist_test.csv\n",
      "fashionmnist\\fashion-mnist_train.csv\n",
      "fashionmnist\\t10k-images-idx3-ubyte\n",
      "fashionmnist\\t10k-labels-idx1-ubyte\n",
      "fashionmnist\\train-images-idx3-ubyte\n",
      "fashionmnist\\train-labels-idx1-ubyte\n"
     ]
    }
   ],
   "source": [
    "for dirname, _, filenames in os.walk('fashionmnist'):\n",
    "    for filename in filenames:\n",
    "        print(os.path.join(dirname, filename))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b55c6784",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 1000 rows and 785 columns\n"
     ]
    }
   ],
   "source": [
    "nRowsRead = 1000 # specify 'None' if want to read whole file\n",
    "# fashion-mnist_test.csv may have more rows in reality, but we are only loading/previewing the first 1000 rows\n",
    "df1 = pd.read_csv('fashionmnist/fashion-mnist_test.csv', delimiter=',', nrows = nRowsRead)\n",
    "df1.dataframeName = 'fashion-mnist_test.csv'\n",
    "nRow, nCol = df1.shape\n",
    "print(f'There are {nRow} rows and {nCol} columns')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1825680a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>label</th>\n",
       "      <th>pixel1</th>\n",
       "      <th>pixel2</th>\n",
       "      <th>pixel3</th>\n",
       "      <th>pixel4</th>\n",
       "      <th>pixel5</th>\n",
       "      <th>pixel6</th>\n",
       "      <th>pixel7</th>\n",
       "      <th>pixel8</th>\n",
       "      <th>pixel9</th>\n",
       "      <th>...</th>\n",
       "      <th>pixel775</th>\n",
       "      <th>pixel776</th>\n",
       "      <th>pixel777</th>\n",
       "      <th>pixel778</th>\n",
       "      <th>pixel779</th>\n",
       "      <th>pixel780</th>\n",
       "      <th>pixel781</th>\n",
       "      <th>pixel782</th>\n",
       "      <th>pixel783</th>\n",
       "      <th>pixel784</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>9</td>\n",
       "      <td>8</td>\n",
       "      <td>...</td>\n",
       "      <td>103</td>\n",
       "      <td>87</td>\n",
       "      <td>56</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>34</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>14</td>\n",
       "      <td>53</td>\n",
       "      <td>99</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>63</td>\n",
       "      <td>53</td>\n",
       "      <td>31</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>137</td>\n",
       "      <td>126</td>\n",
       "      <td>140</td>\n",
       "      <td>0</td>\n",
       "      <td>133</td>\n",
       "      <td>224</td>\n",
       "      <td>222</td>\n",
       "      <td>56</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 785 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   label  pixel1  pixel2  pixel3  pixel4  pixel5  pixel6  pixel7  pixel8  \\\n",
       "0      0       0       0       0       0       0       0       0       9   \n",
       "1      1       0       0       0       0       0       0       0       0   \n",
       "2      2       0       0       0       0       0       0      14      53   \n",
       "3      2       0       0       0       0       0       0       0       0   \n",
       "4      3       0       0       0       0       0       0       0       0   \n",
       "\n",
       "   pixel9  ...  pixel775  pixel776  pixel777  pixel778  pixel779  pixel780  \\\n",
       "0       8  ...       103        87        56         0         0         0   \n",
       "1       0  ...        34         0         0         0         0         0   \n",
       "2      99  ...         0         0         0         0        63        53   \n",
       "3       0  ...       137       126       140         0       133       224   \n",
       "4       0  ...         0         0         0         0         0         0   \n",
       "\n",
       "   pixel781  pixel782  pixel783  pixel784  \n",
       "0         0         0         0         0  \n",
       "1         0         0         0         0  \n",
       "2        31         0         0         0  \n",
       "3       222        56         0         0  \n",
       "4         0         0         0         0  \n",
       "\n",
       "[5 rows x 785 columns]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f1b7be76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 0.8\n",
      "20 0.8\n",
      "30 0.6666666666666666\n"
     ]
    }
   ],
   "source": [
    "for P in [10, 20, 30]:\n",
    "    N = 784\n",
    "    G_fmnist = nx.empty_graph(P) # memory graph\n",
    "    H = nx.adjacency_matrix(G_fmnist) # adjacency matrix\n",
    "    pos_fmnist = nx.circular_layout(G_fmnist, scale=1)\n",
    "\n",
    "    #memories\n",
    "    fmnist_pixel_data = df1.iloc[0:P].to_numpy().T[1:,:]\n",
    "    xi = fmnist_pixel_data/np.max(fmnist_pixel_data)\n",
    "    xi_mean=np.sum(xi, axis=1, keepdims=True)/P\n",
    "    xi_bias=xi-xi_mean\n",
    "\n",
    "    simlen = 100\n",
    "    beta = 1\n",
    "    eta = 0.1\n",
    "    noise = 1\n",
    "\n",
    "    a1=1\n",
    "    h1=0\n",
    "    autocorr1, m_log1, x_log1 = simulate_allstarts(eta,simlen,beta,a1,h1,noise,H)\n",
    "    \n",
    "    corrs = corr_step(x_log1, xi, simlen-1)\n",
    "    predictions = np.equal(corrs.max(axis=0),np.diagonal(corrs))\n",
    "    correct_fraction = np.sum(predictions)/P\n",
    "    \n",
    "    print(P,correct_fraction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "bddcda49",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 0.5\n",
      "20 0.15\n",
      "30 0.1\n"
     ]
    }
   ],
   "source": [
    "for P in [10, 20, 30]:\n",
    "    N = 784\n",
    "    G_fmnist = nx.empty_graph(P) # memory graph\n",
    "    H = nx.adjacency_matrix(G_fmnist) # adjacency matrix\n",
    "    pos_fmnist = nx.circular_layout(G_fmnist, scale=1)\n",
    "\n",
    "    #memories\n",
    "    fmnist_pixel_data = df1.iloc[0:P].to_numpy().T[1:,:]\n",
    "    xi = fmnist_pixel_data/np.max(fmnist_pixel_data)\n",
    "    xi_mean=np.sum(xi, axis=1, keepdims=True)/P\n",
    "    xi_bias=xi-xi_mean\n",
    "\n",
    "    simlen = 100\n",
    "    beta = 1\n",
    "    eta = 0.1\n",
    "    noise = 1\n",
    "\n",
    "    a1=0.5\n",
    "    h1=0.5\n",
    "    autocorr1, m_log1, x_log1 = simulate_allstarts(eta,simlen,beta,a1,h1,noise,H)\n",
    "    \n",
    "    corrs = corr_step(x_log1, xi, simlen-1)\n",
    "    predictions = np.equal(corrs.max(axis=0),np.diagonal(corrs))\n",
    "    correct_fraction = np.sum(predictions)/P\n",
    "    \n",
    "    print(P,correct_fraction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3a6268f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 1.0\n",
      "20 1.0\n",
      "30 1.0\n"
     ]
    }
   ],
   "source": [
    "for P in [10, 20, 30]:\n",
    "    N = 784\n",
    "    G_fmnist = nx.empty_graph(P) # memory graph\n",
    "    H = nx.adjacency_matrix(G_fmnist) # adjacency matrix\n",
    "    pos_fmnist = nx.circular_layout(G_fmnist, scale=1)\n",
    "\n",
    "    #memories\n",
    "    fmnist_pixel_data = df1.iloc[0:P].to_numpy().T[1:,:]\n",
    "    xi = fmnist_pixel_data/np.max(fmnist_pixel_data)\n",
    "    xi_mean=np.sum(xi, axis=1, keepdims=True)/P\n",
    "    xi_bias=xi-xi_mean\n",
    "\n",
    "    simlen = 100\n",
    "    beta = 1\n",
    "    eta = 0.1\n",
    "    noise = 1\n",
    "\n",
    "    a1=0.1\n",
    "    h1=0.9\n",
    "    autocorr1, m_log1, x_log1 = simulate_allstarts(eta,simlen,beta,a1,h1,noise,H)\n",
    "    \n",
    "    corrs = corr_step(x_log1, xi, simlen-1)\n",
    "    predictions = np.equal(corrs.max(axis=0),np.diagonal(corrs))\n",
    "    correct_fraction = np.sum(predictions)/P\n",
    "    \n",
    "    print(P,correct_fraction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3928f655",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 0.9\n",
      "20 0.75\n",
      "30 0.7666666666666667\n"
     ]
    }
   ],
   "source": [
    "for P in [10, 20, 30]:\n",
    "    N = 784\n",
    "    G_fmnist = nx.empty_graph(P) # memory graph\n",
    "    H = nx.adjacency_matrix(G_fmnist) # adjacency matrix\n",
    "    pos_fmnist = nx.circular_layout(G_fmnist, scale=1)\n",
    "\n",
    "    #memories\n",
    "    fmnist_pixel_data = df1.iloc[0:P].to_numpy().T[1:,:]\n",
    "    xi = fmnist_pixel_data/np.max(fmnist_pixel_data)\n",
    "    xi_mean=np.sum(xi, axis=1, keepdims=True)/P\n",
    "    xi_bias=xi-xi_mean\n",
    "\n",
    "    simlen = 100\n",
    "    beta = 1\n",
    "    eta = 0.1\n",
    "    noise = 1\n",
    "\n",
    "    a1=0.9\n",
    "    h1=0.1\n",
    "    autocorr1, m_log1, x_log1 = simulate_allstarts(eta,simlen,beta,a1,h1,noise,H)\n",
    "    \n",
    "    corrs = corr_step(x_log1, xi, simlen-1)\n",
    "    predictions = np.equal(corrs.max(axis=0),np.diagonal(corrs))\n",
    "    correct_fraction = np.sum(predictions)/P\n",
    "    \n",
    "    print(P,correct_fraction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "46f0e9dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f, axarr = plt.subplots(2,3)\n",
    "\n",
    "items = [0,1]\n",
    "\n",
    "axarr[0,0].imshow(xi[:,items[0]].reshape((28,28)), interpolation='nearest', cmap='binary')\n",
    "axarr[0,1].imshow(x_log1[0,items[0],:].reshape((28,28)), interpolation='nearest', cmap='binary')\n",
    "axarr[0,2].imshow(x_log1[-1,items[0],:].reshape((28,28)), interpolation='nearest', cmap='binary')\n",
    "\n",
    "axarr[1,0].imshow(xi[:,items[1]].reshape((28,28)), interpolation='nearest', cmap='binary')\n",
    "axarr[1,1].imshow(x_log1[0,items[1],:].reshape((28,28)), interpolation='nearest', cmap='binary')\n",
    "axarr[1,2].imshow(x_log1[-1,items[1],:].reshape((28,28)), interpolation='nearest', cmap='binary')\n",
    "\n",
    "axarr[0,0].axis('off')\n",
    "axarr[0,1].axis('off')\n",
    "axarr[0,2].axis('off')\n",
    "axarr[1,0].axis('off')\n",
    "axarr[1,1].axis('off')\n",
    "axarr[1,2].axis('off')\n",
    "\n",
    "plt.tight_layout()\n",
    "# plt.savefig(\"fmnist_examples.pdf\", format=\"pdf\", bbox_inches=\"tight\")\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}