weight_update_algo, 3x3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this file is to update weights of 3x3 patterns\n",
    "# chemical naming: AHL is the same as OC6, CHL is the same as OHC14\n",
    "# more comments added on 06-01-2022"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import RandomState\n",
    "import numpy as np\n",
    "np.set_printoptions(precision=2,suppress=True)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.optimize as opt\n",
    "from math import *\n",
    "\n",
    "from scipy.optimize import basinhopping,minimize,differential_evolution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# basis functions, phi_pos, phi_neg, as explained in Supp page 6, eq 2 and 3\n",
    "# these transfer functions are ym*basis\n",
    "def transf_pos(x,K=2.0,y0=0.001,ym=1.5,n=2):\n",
    "    result=ym*((x/K)**n)/(1+(x/K)**n)+ym*y0\n",
    "    return result\n",
    "\n",
    "def transf_neg(x,K=2.0,y0=0.001,ym=1.5,n=2):\n",
    "    result=ym/(1+(x/K)**n)+y0*ym\n",
    "    return result\n",
    "\n",
    "#------------\n",
    "# added during revision\n",
    "\n",
    "# to discretize data according to available levels, allowing to udpate weights in a discrete manner\n",
    "def quant(data,levels):\n",
    "    results=[]\n",
    "    for i in range(0,len(data)):\n",
    "        ind=np.argmin(abs(data[i]-np.array(levels)))\n",
    "        results.append(levels[ind])\n",
    "    return results\n",
    "\n",
    "\n",
    "# discrete weight update for a given set of weights w, the sign of errors\n",
    "# used in function train_step1_dt()\n",
    "def wt_update(w,h,err_sign,levels):\n",
    "    # h is a hidden variable\n",
    "    w_=w.copy()\n",
    "    for i in range(0,len(w)):\n",
    "        indx_=levels.index(w[i])\n",
    "        \n",
    "        if err_sign[i]>0 and indx_<len(levels)-1:\n",
    "            if h[i]>levels[indx_+1]:\n",
    "                w_[i]=levels[indx_+1]\n",
    "                \n",
    "        if err_sign[i]<0 and indx_>0:\n",
    "            if h[i]<levels[indx_-1]:\n",
    "                w_[i]=levels[indx_-1]       \n",
    "    return w_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define 3x3 patterns \n",
    "zv=[1,1,0,0,1,0,0,1,1]\n",
    "vv=[1,0,1,1,0,1,0,1,0]\n",
    "nv=[0,1,0,1,0,1,1,0,1]\n",
    "\n",
    "# adding noisy bits to these patterns by flipping a particular bit\n",
    "def noisy(vector):\n",
    "    result=[]\n",
    "    for i in range(0,len(vector)):\n",
    "        v=vector.copy()\n",
    "        v[i]=np.logical_not(vector[i]).astype(int)\n",
    "        #print(i,vector[i],v[i])\n",
    "        result.append(v)\n",
    "    return result\n",
    "\n",
    "zpatterns=([zv]+noisy(zv))\n",
    "vpatterns=([vv]+noisy(vv))\n",
    "npatterns=([nv]+noisy(nv))\n",
    "\n",
    "start=0\n",
    "end=10\n",
    "patterns=zpatterns[start:end]+vpatterns[start:end]+npatterns[start:end]\n",
    "patterns_complete=zpatterns+vpatterns+npatterns\n",
    "\n",
    "lenth=end-start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using 3x3 patterns as an example, size can be nxn\n",
    "size=3*3\n",
    "\n",
    "# the lower boundary of target for decision making\n",
    "# arbitrary values are chosen; these values should be consistent with the transfer function of receiver promoter\n",
    "target_L=0.0\n",
    "target_H=1.2\n",
    "patterns=patterns\n",
    "\n",
    "lenth=int(len(patterns)/3)\n",
    "\n",
    "# coding target vectors for \"z\", \"v\" and \"n\" patterns\n",
    "# z patterns correspond to target_0, v patterns for target_1, and n patterns for target_2\n",
    "target_0=np.array([target_H]*lenth+[target_L]*lenth+[target_L]*lenth)\n",
    "target_1=np.array([target_L]*lenth+[target_H]*lenth+[target_L]*lenth)\n",
    "target_2=np.array([target_L]*lenth+[target_L]*lenth+[target_H]*lenth)\n",
    "\n",
    "# choosing target_0 as a demo to recognize \"z\" patterns\n",
    "# target can be set to target_1 when recognizing \"v\" patterns\n",
    "target=target_0\n",
    "#----\n",
    "\n",
    "# parameters are adopted according to experimentally measured Plux transfer functions\n",
    "AHL_unit_level=33# uM \n",
    "\n",
    "# initialze transfer function parameters\n",
    "transf_p=np.zeros(2)\n",
    "transf_n=np.zeros(2)\n",
    "\n",
    "# parameter numbers are approximated from values in Table 1\n",
    "# x=0 represents zero/low AHL input, x=AHL_unit_level for high AHL input\n",
    "transf_p[0]=transf_pos(x=0,K=50,y0=0.1,ym=1.0,n=0.45)\n",
    "transf_p[1]=transf_pos(x=AHL_unit_level,K=50,y0=0.1,ym=1.0,n=0.45)\n",
    "\n",
    "# transf_n paramters are from Table 1\n",
    "transf_n[0]=transf_neg(x=0,K=0.252,y0=0.341,ym=1,n=0.67)\n",
    "transf_n[1]=transf_neg(x=AHL_unit_level,K=0.252,y0=0.341,ym=1,n=0.67)\n",
    "\n",
    "phi_pos=np.array([transf_p]*size)\n",
    "phi_neg=np.array([transf_n]*size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the following functions are used in the training algorithm as in train_step1() or train_step1_dt()\n",
    "def examine_output(w,P,phi_pos,phi_neg):\n",
    "    y_n=np.zeros(len(P))\n",
    "    w_ph_=np.zeros(len(P))\n",
    "\n",
    "    for n in range(0,len(P)):\n",
    "        pttn=np.array(P[n])\n",
    "        \n",
    "        phi_nw=get_phinw(w,pttn,phi_pos,phi_neg)\n",
    "                \n",
    "        w_ph_[n]=np.dot(w,phi_nw)/len(w)\n",
    "        y_n[n]=activate(w_ph_[n])\n",
    "        \n",
    "    return y_n,w_ph_\n",
    "\n",
    "def output_fcn(pttn,fcn):\n",
    "    \n",
    "    CHL_levels=np.zeros(len(pttn))\n",
    "    for i in range(0,len(pttn)):\n",
    "        CHL_levels[i]=fcn[i][pttn[i]]\n",
    "        \n",
    "    return CHL_levels\n",
    "\n",
    "def activate(x):\n",
    "    K,y0,ym_x,n= 1.10292919e+03,1.94584842e-02,2.15950963e+04,2.33038211e+00\n",
    "    result=transf_pos(x.sum(),K=K,y0=y0/1e4,ym=2.0,n=n).sum()\n",
    "    return result\n",
    "\n",
    "# see eq 4 in Supp page 7\n",
    "def get_phinw(w,pttn,phi_pos,phi_neg):\n",
    "    # conitnuous means wether negative weights are allowed to vary\n",
    "    phi_nw=(1.0+w/np.sqrt(w**2))/2*output_fcn(pttn,phi_pos)+\\\n",
    "            (w/np.sqrt(w**2)-1)/2*output_fcn(pttn,phi_neg)\n",
    "\n",
    "    return phi_nw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Algorithm adapted from from Prezioso et al. 2015 memristor paper\n",
    "# Different from the memristor paper in that weights in the memristor NN can take any real number\n",
    "\n",
    "# cont_ sets if negative weights are allowed to vary. By default cont_=False, only one possible negative weight. \n",
    "# Using all initial negative weights actually work better, \n",
    "    # otherwise can lead to spikes in weights and error values\n",
    "# if case cont_=True, initial all positive weights work best\n",
    "\n",
    "def train_step1(target,size,eta,phi_pos,phi_neg,pos=False,cont_=False):\n",
    "    rndstate=RandomState(2)\n",
    "    #eta is learning rate as in eq.8 in Supp page 7, explained on page 8\n",
    "    #phi_pos and phi_neg are positive and negative basis functions, respectively\n",
    "    \n",
    "    # setting initial weights; by default, weights are initialized to negative values\n",
    "    # initial values affect how the algorithm converges.\n",
    "    if cont_==True or pos==True:\n",
    "        h=rndstate.random_sample(size)\n",
    "    else:\n",
    "        h=rndstate.random_sample(size)*(-1)\n",
    "        \n",
    "    print('h: ',h)\n",
    "    r=size\n",
    "\n",
    "    # w_series for weight vector, y_series to store output during iterations, delta_ for errors \n",
    "    w_series=[]\n",
    "    y_series=[]\n",
    "    delta_series=[]\n",
    "\n",
    "    # iterate for 300 times; this is an arbitrary setting. \n",
    "    for it in range(0,300):\n",
    "        y_n=np.zeros(len(patterns))\n",
    "        g_n=np.zeros(len(patterns))\n",
    "        delta_err=np.zeros(size)\n",
    "        #phi_n=[]\n",
    "      \n",
    "        w=h.copy()\n",
    "    \n",
    "        # set the negative to one value -735. This is because only one negative weight circuit has been built\n",
    "        # 735 comes from Table 1, row S_plux_rep, column beta_m\n",
    "        if cont_==False:\n",
    "            w[w<0]=-735\n",
    "        \n",
    "        # if only positive weights are allowed, set the negative values arbitrarily to 0.1\n",
    "        if pos==True:\n",
    "            w[w<0]=0.1\n",
    "            \n",
    "        # for each pattern, calculating errors, eq 7 in Supp on page 7\n",
    "        for n in range(0,len(patterns)):\n",
    "            # consider pttn as indexes in vector x, 0 means x[0], 1 means x[1]\n",
    "            pttn=np.array(patterns[n])\n",
    "            \n",
    "            # eq4 in Supp on page 7\n",
    "            phi_nw=get_phinw(w,pttn,phi_pos,phi_neg)\n",
    "            # h is the hidden variable\n",
    "            g_n[n]=np.dot(w,phi_nw)/r\n",
    "            \n",
    "            # eq 6 in Supp\n",
    "            y_n[n]=activate(g_n[n])            \n",
    "            # right hand side of eq7 inside the summation \n",
    "            tmp=(y_n[n]-target[n])\n",
    "            tmp=min(target_H,tmp)\n",
    "            \n",
    "            delta_err+=tmp*phi_nw\n",
    "\n",
    "        w_series.append(w)\n",
    "        h=h-eta*delta_err \n",
    "        y_series.append(y_n)\n",
    "        delta_series.append(delta_err)\n",
    "        \n",
    "    return w,y_series,w_series,delta_series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# step2\n",
    "# basinhopping method\n",
    "# discussed on page 8 Supp\n",
    "\n",
    "def step2(w0):\n",
    "    y=np.zeros(len(patterns))\n",
    "\n",
    "    for n in range(0,len(patterns)):\n",
    "        pttn=np.array(patterns[n])\n",
    "        phi_nw=get_phinw(w,pttn,phi_pos,phi_neg)\n",
    "        \n",
    "        w0[w0<0]=-735\n",
    "        y[n]=activate(np.dot(w0,phi_nw)/size)\n",
    "                \n",
    "    product=(2*y-target_H)*(2*target-target_H)\n",
    "    \n",
    "    return np.var(product)*10+(target_H**2-np.mean(product))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h:  [-0.44 -0.03 -0.55 -0.44 -0.42 -0.33 -0.2  -0.62 -0.3 ]\n",
      "h:  [-0.44 -0.03 -0.55 -0.44 -0.42 -0.33 -0.2  -0.62 -0.3 ]\n",
      "h:  [-0.44 -0.03 -0.55 -0.44 -0.42 -0.33 -0.2  -0.62 -0.3 ]\n"
     ]
    }
   ],
   "source": [
    "w0,y0_sc,w0_sc,d0_sc=train_step1(target_0,9,eta=10,phi_pos=phi_pos,phi_neg=phi_neg,cont_=False)\n",
    "w1,y1_sc,w1_sc,d1_sc=train_step1(target_1,9,eta=10,phi_pos=phi_pos,phi_neg=phi_neg,cont_=False)\n",
    "w2,y2_sc,w2_sc,d2_sc=train_step1(target_2,9,eta=10,phi_pos=phi_pos,phi_neg=phi_neg,cont_=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "step2 w0:  1813, 1813, -735, -735, 2872, -735, -735, 1813, 1813\n"
     ]
    }
   ],
   "source": [
    "# demo example of step2, w0;\n",
    "# output is the same as in Table S4; \n",
    "\n",
    "w=w0\n",
    "target=target_0\n",
    "minimizer_kwargs = {\"method\": \"Nelder-Mead\"}\n",
    "res0=basinhopping(step2,w,minimizer_kwargs=minimizer_kwargs,niter=20)\n",
    "\n",
    "print(res0.lowest_optimization_result.success)\n",
    "w0_txt=\", \".join(\"%.0f\" % f for f in res0.x)\n",
    "print('step2 w0: ',w0_txt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "step2 w1:  1813, -735, 2872, 1813, -735, 1813, -735, 1813, -735\n"
     ]
    }
   ],
   "source": [
    "# demo example of step2, w1\n",
    "\n",
    "w=w1\n",
    "target=target_1\n",
    "minimizer_kwargs = {\"method\": \"Nelder-Mead\"}\n",
    "res1=basinhopping(step2,w,minimizer_kwargs=minimizer_kwargs,niter=20)\n",
    "\n",
    "print(res1.lowest_optimization_result.success)\n",
    "w1_txt=\", \".join(\"%.0f\" % f for f in res1.x)\n",
    "print('step2 w1: ',w1_txt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "step2 w1:  -735, 1813, -735, 1813, -735, 1813, 2872, -735, 1813\n"
     ]
    }
   ],
   "source": [
    "# demo example of step2, w2\n",
    "\n",
    "w=w2\n",
    "target=target_2\n",
    "minimizer_kwargs = {\"method\": \"Nelder-Mead\"}\n",
    "res2=basinhopping(step2,w,minimizer_kwargs=minimizer_kwargs,niter=20)\n",
    "\n",
    "print(res2.lowest_optimization_result.success)\n",
    "w2_txt=\", \".join(\"%.0f\" % f for f in res2.x)\n",
    "print('step2 w1: ',w2_txt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# all initial states start with negative weights\n",
    "# most part the same as train_step1(), but with input wt_levels for discrete weights\n",
    "# using wt_update() function to update discrete weights\n",
    "\n",
    "def train_step1_dt(target,size,eta,phi_pos,phi_neg,wt_levels):\n",
    "\n",
    "    h=np.ones(size)*wt_levels[0]\n",
    "    w=h.copy()\n",
    "    #print('w: ',w)\n",
    "    r=size\n",
    "\n",
    "    w_series=[]\n",
    "    y_series=[]\n",
    "    delta_series=[]\n",
    "        \n",
    "    for it in range(0,300):\n",
    "        y_n=np.zeros(len(patterns))\n",
    "        g_n=np.zeros(len(patterns))\n",
    "        delta_err=np.zeros(size)\n",
    "        for n in range(0,len(patterns)):\n",
    "            pttn=np.array(patterns[n])       \n",
    "            phi_nw=get_phinw(w,pttn,phi_pos,phi_neg)\n",
    "\n",
    "            g_n[n]=np.dot(w,phi_nw)/r\n",
    "            y_n[n]=activate(g_n[n])            \n",
    "            tmp=(y_n[n]-target[n])\n",
    "            tmp=min(target_H,tmp)            \n",
    "            delta_err+=tmp*phi_nw\n",
    "            \n",
    "        y_series.append(y_n)\n",
    "        w_series.append(w)\n",
    "        delta_series.append(delta_err)\n",
    "        h=h-eta*delta_err\n",
    "        w=wt_update(w,h,-np.sign(delta_err),wt_levels)\n",
    "        \n",
    "    p_=(2*np.array(y_series)-target_H)*(2*target-target_H)\n",
    "    pm_=np.var(p_,axis=1)*10+(target_H**2-np.mean(p_,axis=1))\n",
    "    \n",
    "    w=w_series[np.argmin(pm_)]\n",
    "    y=y_series[np.argmin(pm_)]\n",
    "    \n",
    "    return w,y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# demo of weight update using discrete weights\n",
    "# classification using two states\n",
    "# For Fig S5\n",
    "\n",
    "wt_levels=[-735.0,1906.0]\n",
    "w0,y0=train_step1_dt(target_0,9,eta=20,phi_pos=phi_pos,phi_neg=phi_neg,wt_levels=wt_levels)\n",
    "w1,y1=train_step1_dt(target_1,9,eta=20,phi_pos=phi_pos,phi_neg=phi_neg,wt_levels=wt_levels)\n",
    "w2,y2=train_step1_dt(target_2,9,eta=20,phi_pos=phi_pos,phi_neg=phi_neg,wt_levels=wt_levels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0, 1.2)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 324x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Fig S5 demo\n",
    "fig=plt.figure(figsize=(4.5,4))\n",
    "ax=fig.add_subplot(111)\n",
    "\n",
    "ax.plot(y0,c='royalblue',marker='.',lw=0.5,label='$\\\\vec{w}_0$')\n",
    "ax.plot(y1,c='mediumseagreen',marker='.',lw=0.5,label='$\\\\vec{w}_1$')\n",
    "ax.plot(y2,c='orange',marker='.',lw=0.5,label='$\\\\vec{w}_2$')\n",
    "\n",
    "ax.tick_params(axis='both',direction='in',labelsize=13,size=11)\n",
    "ax.set_yticks([0,0.2,0.5,0.8,1.0])\n",
    "ax.set_xlabel('3x3 patterns',fontsize=14)\n",
    "ax.legend(loc='upper left',ncol=3,fontsize=13)\n",
    "ax.set_xticks([0,9,19,29])\n",
    "\n",
    "plt.ylim([0,1.2])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}