├── Code ├── AdEx.ipynb ├── BinaryNet.ipynb ├── CondBasedSynapses.ipynb ├── ConvolutionExample.ipynb ├── DecodeSpikeCountsWithSingleLayerANN.ipynb ├── DiracDeltaFunctions.ipynb ├── DynamicalMeanField.ipynb ├── EIF.ipynb ├── EIFLIFQIF.ipynb ├── EIFPhaseLine.ipynb ├── EIFfIcurve.ipynb ├── EIFwithPoissonSynapses.ipynb ├── ExponentialDecay.ipynb ├── FeedFwdSpikingNet.ipynb ├── ForwardEuler.ipynb ├── HHspikes.ipynb ├── HodgkinHuxley.ipynb ├── HopfieldNetwork.ipynb ├── LeakyIntegrator.ipynb ├── LinODE.ipynb ├── LinearSystemsOfODEs.ipynb ├── MultiTrialSpikeTrains.ipynb ├── OneRealSpikeTrain.ipynb ├── OrientationTuningCurve.ipynb ├── PhaseLine.ipynb ├── PoissonProcesses.ipynb ├── PopulationCoding.ipynb ├── PythonIntro.ipynb ├── QIFOscPhase.ipynb ├── RNN.ipynb ├── RecurrentSpikingNet.ipynb ├── SingleLayerANN.ipynb ├── SurroundSuppression.ipynb ├── Synapses.ipynb └── SynapticPlasticity.ipynb ├── DataFiles ├── MNISTdata.npz ├── RealMembranePotentialData.npz ├── SpikeCounts112Neuron12Thetas.npz ├── SpikeCounts112Neurons2Thetas.npz ├── SpikeCounts112Neurons2ThetasTest.npz ├── SpikeCounts1Neuron12Thetas.npz ├── SpikeCounts2Neurons2Thetas.npz └── SpikeTimes1Neuron1Theta.npz ├── ImageFiles ├── ANNDiagram.png ├── CoupledPhaseOscDiagram.png ├── Cover.jpg ├── DriftingGrating.png ├── EIFwithPoissonSynapses.png ├── EIPairForPlast.png ├── EIPairForPlast1.png ├── EIPairForPlast2.png ├── EIRecurrentNet.png ├── FeedFwdNet.png ├── OscillatorDiagram.png ├── RNNdiagram.png ├── SurroundSuppDiagram1.png ├── SurroundSuppDiagram2.png └── Synapses.png └── README.md /Code/ConvolutionExample.ipynb: -------------------------------------------------------------------------------- 1 | {"cells":[{"cell_type":"code","execution_count":null,"metadata":{"id":"d8gts4r87Us1","outputId":"23efc6ec-a600-4781-ae17-6b08a0a002ca"},"outputs":[{"data":{"image/png":"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\n","text/plain":["
"]},"metadata":{},"output_type":"display_data"}],"source":["###############################################\n","## Import packages and specify some settings ##\n","###############################################\n","# Import packages\n","import numpy as np\n","import matplotlib.pyplot as plt\n","import seaborn as sns\n","\n","# This makes plots show up and look nice\n","%matplotlib inline\n","sns.set(context='paper',style='white',font_scale=1.5,rc={\"lines.linewidth\":2.5})\n","sns.set_palette('muted')\n","\n","\n","###############################################\n","###############################################\n","\n","\n","# Discretized time\n","T=50\n","dt=.1\n","time=np.arange(0,T,dt)\n","\n","# Define a noisy signal\n","x=np.sin(2*np.pi*time/20)+.25*np.random.randn(len(time))\n","\n","# Define a Gaussian kernel and normalize it to have integral 1\n","sigma=2\n","s=np.arange(-3*sigma,3*sigma,dt)\n","k=np.exp(-(s**2)/sigma**2)\n","k=k/(np.sum(k)*dt)\n","\n","# Perform convolution.\n","y=np.convolve(x,k,'same')*dt\n","\n","# Make plot\n","plt.figure(figsize=(6.5, 3))\n","plt.plot(time,x, label='x(t)')\n","plt.plot(time,y, label='y(t)=(k*x)(t)')\n","plt.plot(s,k, label='k(t)', color=(1,0,0))\n","plt.xlabel('t')\n","plt.legend(loc=(1.04,.25))\n","sns.despine()\n","plt.tight_layout()\n","\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"9yZVaOZg7Us3"},"outputs":[],"source":[]}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.7.4"},"colab":{"provenance":[]}},"nbformat":4,"nbformat_minor":0} -------------------------------------------------------------------------------- /Code/DecodeSpikeCountsWithSingleLayerANN.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": { 7 | "colab": { 8 | "base_uri": "https://localhost:8080/" 9 | }, 10 | "executionInfo": { 11 | "elapsed": 1833, 12 | "status": "ok", 13 | "timestamp": 1701963449928, 14 | "user": { 15 | "displayName": "Robert Rosenbaum", 16 | "userId": "09541400600911705212" 17 | }, 18 | "user_tz": 300 19 | }, 20 | "id": "WWwvfAgA_J1g", 21 | "outputId": "beb106e8-0eb0-4ec5-e2de-435425c1948c" 22 | }, 23 | "outputs": [ 24 | { 25 | "name": "stdout", 26 | "output_type": "stream", 27 | "text": [ 28 | "The orientation for trial 3 was 120 degrees.\n" 29 | ] 30 | } 31 | ], 32 | "source": [ 33 | "###############################################\n", 34 | "## Import packages and specify some settings ##\n", 35 | "###############################################\n", 36 | "# Import packages\n", 37 | "import numpy as np\n", 38 | "import matplotlib.pyplot as plt\n", 39 | "import seaborn as sns\n", 40 | "\n", 41 | "# This makes plots show up and look nice\n", 42 | "%matplotlib inline\n", 43 | "sns.set(context='paper',style='white',font_scale=1.5,rc={\"lines.linewidth\":2.5})\n", 44 | "sns.set_palette('muted')\n", 45 | "\n", 46 | "# Keep this set to false unless you want to save figures and data\n", 47 | "# (in which case you'll need to change some directories below)\n", 48 | "SaveFigures=False\n", 49 | "###############################################\n", 50 | "###############################################\n", 51 | "\n", 52 | "\n", 53 | "# Load the data from a file\n", 54 | "if 'google.colab' in str(get_ipython()):\n", 55 | " url = \"https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/master/DataFiles/SpikeCounts112Neuron12Thetas.npz\"\n", 56 | " file = np.DataSource().open(url)\n", 57 | " data = np.load(file.name, allow_pickle=True)\n", 58 | "else:\n", 59 | " data = np.load('../DataFiles/SpikeCounts112Neuron12Thetas.npz', allow_pickle=True)\n", 60 | "\n", 61 | "\n", 62 | "# Extract the data from the data dictionary to arrays.\n", 63 | "X=data['x']\n", 64 | "Y=data['y']\n", 65 | "XTest=data['xTest']\n", 66 | "YTest=data['yTest']\n", 67 | "AllOrientations=data['AllOrientations']\n", 68 | "T=data['T']\n", 69 | "\n", 70 | "# Get the orientations (in degrees) for each trial\n", 71 | "# from the one-hot encoded labels in y\n", 72 | "Orientations=(AllOrientations[np.argmax(Y,axis=0)]).astype(int)\n", 73 | "\n", 74 | "# Print one orientation\n", 75 | "j=3\n", 76 | "print('The orientation for trial',j,'was',Orientations[j],'degrees.')\n", 77 | "\n", 78 | "\n", 79 | "# Write code for exercise here.\n" 80 | ] 81 | }, 82 | { 83 | "cell_type": "code", 84 | "execution_count": null, 85 | "metadata": { 86 | "id": "avY2KA5K_J1j" 87 | }, 88 | "outputs": [], 89 | "source": [] 90 | } 91 | ], 92 | "metadata": { 93 | "colab": { 94 | "provenance": [] 95 | }, 96 | "kernelspec": { 97 | "display_name": "Python 3 (ipykernel)", 98 | "language": "python", 99 | "name": "python3" 100 | }, 101 | "language_info": { 102 | "codemirror_mode": { 103 | "name": "ipython", 104 | "version": 3 105 | }, 106 | "file_extension": ".py", 107 | "mimetype": "text/x-python", 108 | "name": "python", 109 | "nbconvert_exporter": "python", 110 | "pygments_lexer": "ipython3", 111 | "version": "3.11.8" 112 | } 113 | }, 114 | "nbformat": 4, 115 | "nbformat_minor": 4 116 | } 117 | -------------------------------------------------------------------------------- /Code/EIF.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": { 7 | "colab": { 8 | "base_uri": "https://localhost:8080/", 9 | "height": 243 10 | }, 11 | "executionInfo": { 12 | "elapsed": 3167, 13 | "status": "ok", 14 | "timestamp": 1709914053428, 15 | "user": { 16 | "displayName": "Robert Rosenbaum", 17 | "userId": "09541400600911705212" 18 | }, 19 | "user_tz": 300 20 | }, 21 | "id": "OPaQQmoIy0oo", 22 | "outputId": "01c9dfcb-9b40-42b9-ca6f-8f0acaa6466a" 23 | }, 24 | "outputs": [ 25 | { 26 | "data": { 27 | "image/png": "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\n", 28 | "text/plain": [ 29 | "
" 30 | ] 31 | }, 32 | "metadata": {}, 33 | "output_type": "display_data" 34 | } 35 | ], 36 | "source": [ 37 | "###############################################\n", 38 | "## Import packages and specify some settings ##\n", 39 | "###############################################\n", 40 | "# Import packages\n", 41 | "import numpy as np\n", 42 | "import matplotlib.pyplot as plt\n", 43 | "import seaborn as sns\n", 44 | "\n", 45 | "# This makes plots show up and look nice\n", 46 | "%matplotlib inline\n", 47 | "sns.set(context='paper',style='white',font_scale=1.5,rc={\"lines.linewidth\":2.5})\n", 48 | "sns.set_palette('muted')\n", 49 | "\n", 50 | "###############################################\n", 51 | "###############################################\n", 52 | "\n", 53 | "# Discretized time\n", 54 | "T=1000\n", 55 | "dt=.1\n", 56 | "time=np.arange(0,T,dt)\n", 57 | "\n", 58 | "# Applied current\n", 59 | "Ix=np.zeros_like(time)\n", 60 | "Ix[(time>=200) & (time<=400)]=5\n", 61 | "Ix[(time>=600) & (time<=800)]=18\n", 62 | "\n", 63 | "\n", 64 | "# Neuron parameters\n", 65 | "EL=-72\n", 66 | "taum=15\n", 67 | "Vth=5\n", 68 | "Vre=-75\n", 69 | "VT=-55\n", 70 | "D=2\n", 71 | "\n", 72 | "# Initial condition\n", 73 | "V0=-70\n", 74 | "\n", 75 | "\n", 76 | "# Compute V using the forward Euler method\n", 77 | "V=np.zeros_like(time)\n", 78 | "SpikeTimes=np.array([])\n", 79 | "V[0]=V0\n", 80 | "for i in range(len(time)-1):\n", 81 | "\n", 82 | " # Euler step\n", 83 | " V[i+1]=V[i]+dt*(-(V[i]-EL)+D*np.exp((V[i]-VT)/D)+Ix[i])/taum\n", 84 | "\n", 85 | " # Threshold-reset condition\n", 86 | " if V[i+1]>=Vth:\n", 87 | " V[i+1]=Vre\n", 88 | " V[i]=Vth # This makes plots nicer\n", 89 | " SpikeTimes=np.append(SpikeTimes,time[i+1])\n", 90 | "\n", 91 | "\n", 92 | "\n", 93 | "# Make figure\n", 94 | "plt.subplots(1,2,figsize=(8, 2.5))\n", 95 | "\n", 96 | "plt.subplot(1,2,1)\n", 97 | "plt.plot(time,Ix,color='r')\n", 98 | "plt.xlabel('time (ms)')\n", 99 | "plt.ylabel('I$_x$ (mV)')\n", 100 | "plt.title('A',loc='left')\n", 101 | "sns.despine()\n", 102 | "\n", 103 | "\n", 104 | "plt.subplot(1,2,2)\n", 105 | "plt.plot(time,V,color='gray')\n", 106 | "plt.plot(SpikeTimes,Vth+1+0*SpikeTimes,'ro')\n", 107 | "plt.xlabel('time (ms)')\n", 108 | "plt.ylabel('V (mV)')\n", 109 | "sns.despine()\n", 110 | "plt.title('B',loc='left')\n", 111 | "plt.tight_layout()\n", 112 | "\n", 113 | "\n" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": null, 119 | "metadata": { 120 | "id": "H7lEXa8Yy0oq" 121 | }, 122 | "outputs": [], 123 | "source": [] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": null, 128 | "metadata": { 129 | "id": "AxTAucYKy0oq" 130 | }, 131 | "outputs": [], 132 | "source": [] 133 | } 134 | ], 135 | "metadata": { 136 | "colab": { 137 | "provenance": [] 138 | }, 139 | "kernelspec": { 140 | "display_name": "Python 3 (ipykernel)", 141 | "language": "python", 142 | "name": "python3" 143 | }, 144 | "language_info": { 145 | "codemirror_mode": { 146 | "name": "ipython", 147 | "version": 3 148 | }, 149 | "file_extension": ".py", 150 | "mimetype": "text/x-python", 151 | "name": "python", 152 | "nbconvert_exporter": "python", 153 | "pygments_lexer": "ipython3", 154 | "version": "3.11.8" 155 | } 156 | }, 157 | "nbformat": 4, 158 | "nbformat_minor": 4 159 | } 160 | -------------------------------------------------------------------------------- /Code/EIFPhaseLine.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 2, 6 | "metadata": { 7 | "colab": { 8 | "base_uri": "https://localhost:8080/", 9 | "height": 273 10 | }, 11 | "executionInfo": { 12 | "elapsed": 1019, 13 | "status": "ok", 14 | "timestamp": 1709914815548, 15 | "user": { 16 | "displayName": "Robert Rosenbaum", 17 | "userId": "09541400600911705212" 18 | }, 19 | "user_tz": 300 20 | }, 21 | "id": "bfY3LKC42KB0", 22 | "outputId": "35879b34-044a-41dd-97f5-9d0c82660446" 23 | }, 24 | "outputs": [ 25 | { 26 | "data": { 27 | "image/png": "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\n", 28 | "text/plain": [ 29 | "
" 30 | ] 31 | }, 32 | "metadata": {}, 33 | "output_type": "display_data" 34 | } 35 | ], 36 | "source": [ 37 | "###############################################\n", 38 | "## Import packages and specify some settings ##\n", 39 | "###############################################\n", 40 | "# Import packages\n", 41 | "import numpy as np\n", 42 | "import matplotlib.pyplot as plt\n", 43 | "import seaborn as sns\n", 44 | "\n", 45 | "# This makes plots show up and look nice\n", 46 | "%matplotlib inline\n", 47 | "sns.set(context='paper',style='white',font_scale=1.5,rc={\"lines.linewidth\":2.5})\n", 48 | "sns.set_palette('tab10')\n", 49 | "\n", 50 | "###############################################\n", 51 | "###############################################\n", 52 | "\n", 53 | "\n", 54 | "# Neuron parameters\n", 55 | "EL=-72\n", 56 | "taum=15\n", 57 | "Vth=5\n", 58 | "Vre=-75\n", 59 | "VT=-55\n", 60 | "D=2\n", 61 | "\n", 62 | "\n", 63 | "# RHS of ODE as a function of V and I0\n", 64 | "def f(V,I0):\n", 65 | " return (-(V-EL)+D*np.exp((V-VT)/D)+I0)/taum\n", 66 | "\n", 67 | "\n", 68 | "# Range of V over which to plot f(V)\n", 69 | "Vplot=np.arange(-80,Vth+.1,.1)\n", 70 | "\n", 71 | "\n", 72 | "plt.subplots(1,2,figsize=(9, 2.8))\n", 73 | "\n", 74 | "# Plot the phase line with I0=5\n", 75 | "I0=5\n", 76 | "plt.subplot(1,2,1)\n", 77 | "plt.axhline(y=0,color='black')\n", 78 | "plt.plot(Vplot,f(Vplot,I0))\n", 79 | "plt.plot(EL+I0,0,'.',markersize=15)\n", 80 | "plt.plot(VT,0,'.',markersize=15)\n", 81 | "plt.plot(Vth,0,'.',markersize=15,color='m')\n", 82 | "plt.arrow(-78,0,.2,0,head_width=.2, head_length=3,color='black')\n", 83 | "plt.arrow(-59,0,-.2,0,head_width=.2, head_length=3,color='black')\n", 84 | "plt.arrow(-30,0,.2,0,head_width=.2, head_length=3,color='black')\n", 85 | "plt.ylim(top=1.5,bottom=-.8)\n", 86 | "plt.title('A',loc='left')\n", 87 | "plt.xlabel('V')\n", 88 | "plt.ylabel('f(V)')\n", 89 | "sns.despine()\n", 90 | "\n", 91 | "# Plot the phase line with I0=20\n", 92 | "I0=20\n", 93 | "plt.subplot(1,2,2)\n", 94 | "plt.axhline(y=0,color='black')\n", 95 | "plt.plot(Vplot,f(Vplot,I0), label='f(V)')\n", 96 | "plt.plot(EL+I0,0,'.',markersize=15,label='$E_L+I_0$')\n", 97 | "plt.plot(VT,0,'.',markersize=15,label='$V_T$')\n", 98 | "plt.plot(Vth,0,'.',markersize=15,label='$V_{th}$',color='m')\n", 99 | "plt.arrow(-40,0,.2,0,head_width=.2, head_length=3,color='black')\n", 100 | "plt.legend(loc=(1.04,.25))\n", 101 | "plt.ylim(top=1.5,bottom=-.8)\n", 102 | "plt.title('B',loc='left')\n", 103 | "plt.xlabel('V')\n", 104 | "#plt.ylabel('f(V)')\n", 105 | "sns.despine()\n", 106 | "\n", 107 | "\n", 108 | "plt.tight_layout()\n", 109 | "\n" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": null, 115 | "metadata": { 116 | "id": "VHwkUZg82KB1" 117 | }, 118 | "outputs": [], 119 | "source": [] 120 | } 121 | ], 122 | "metadata": { 123 | "colab": { 124 | "provenance": [] 125 | }, 126 | "kernelspec": { 127 | "display_name": "Python 3 (ipykernel)", 128 | "language": "python", 129 | "name": "python3" 130 | }, 131 | "language_info": { 132 | "codemirror_mode": { 133 | "name": "ipython", 134 | "version": 3 135 | }, 136 | "file_extension": ".py", 137 | "mimetype": "text/x-python", 138 | "name": "python", 139 | "nbconvert_exporter": "python", 140 | "pygments_lexer": "ipython3", 141 | "version": "3.11.8" 142 | } 143 | }, 144 | "nbformat": 4, 145 | "nbformat_minor": 4 146 | } 147 | -------------------------------------------------------------------------------- /Code/ExponentialDecay.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "metadata": { 7 | "id": "P_chqPe6lenc", 8 | "outputId": "04e0d1d1-89cf-4c07-c17f-88a0b923de4b" 9 | }, 10 | "outputs": [ 11 | { 12 | "data": { 13 | "image/png": "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\n", 14 | "text/plain": [ 15 | "
" 16 | ] 17 | }, 18 | "metadata": {}, 19 | "output_type": "display_data" 20 | } 21 | ], 22 | "source": [ 23 | "###############################################\n", 24 | "## Import packages and specify some settings ##\n", 25 | "###############################################\n", 26 | "# Import packages\n", 27 | "import numpy as np\n", 28 | "import matplotlib.pyplot as plt\n", 29 | "import seaborn as sns\n", 30 | "\n", 31 | "# This makes plots show up and look nice\n", 32 | "%matplotlib inline\n", 33 | "sns.set(context='paper',style='white',font_scale=1.5,rc={\"lines.linewidth\":2.5})\n", 34 | "sns.set_palette('muted')\n", 35 | "\n", 36 | "###############################################\n", 37 | "###############################################\n", 38 | "\n", 39 | "# Define parameters\n", 40 | "tau=10\n", 41 | "c=5\n", 42 | "\n", 43 | "# Initial conditions\n", 44 | "x0=10\n", 45 | "y0=10\n", 46 | "\n", 47 | "# Discretized time\n", 48 | "T=70\n", 49 | "dt=.1\n", 50 | "time=np.arange(0,T,dt)\n", 51 | "\n", 52 | "# Define solutions\n", 53 | "x=x0*np.exp(-time/tau)\n", 54 | "y=c+(y0-c)*np.exp(-time/tau)\n", 55 | "\n", 56 | "# Make plot\n", 57 | "plt.figure(figsize=(5, 2.75))\n", 58 | "\n", 59 | "plt.plot(time,x,'b',label='x(t)')\n", 60 | "plt.plot(time,y,'r',label='y(t)')\n", 61 | "plt.plot(time,c+0*time,'k--', label='c')\n", 62 | "plt.xlabel('t')\n", 63 | "plt.legend(loc=(1,0.2))\n", 64 | "sns.despine()\n", 65 | "plt.tight_layout()\n", 66 | "\n", 67 | "\n" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": null, 73 | "metadata": { 74 | "id": "iedjxQvAlend" 75 | }, 76 | "outputs": [], 77 | "source": [] 78 | } 79 | ], 80 | "metadata": { 81 | "colab": { 82 | "provenance": [] 83 | }, 84 | "kernelspec": { 85 | "display_name": "Python 3 (ipykernel)", 86 | "language": "python", 87 | "name": "python3" 88 | }, 89 | "language_info": { 90 | "codemirror_mode": { 91 | "name": "ipython", 92 | "version": 3 93 | }, 94 | "file_extension": ".py", 95 | "mimetype": "text/x-python", 96 | "name": "python", 97 | "nbconvert_exporter": "python", 98 | "pygments_lexer": "ipython3", 99 | "version": "3.11.8" 100 | } 101 | }, 102 | "nbformat": 4, 103 | "nbformat_minor": 4 104 | } 105 | -------------------------------------------------------------------------------- /Code/ForwardEuler.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "metadata": { 7 | "id": "j6yTgvpN_IAz", 8 | "outputId": "512b25ad-964f-4a4c-b6a8-9a9c18e00997" 9 | }, 10 | "outputs": [ 11 | { 12 | "data": { 13 | "image/png": "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\n", 14 | "text/plain": [ 15 | "
" 16 | ] 17 | }, 18 | "metadata": {}, 19 | "output_type": "display_data" 20 | } 21 | ], 22 | "source": [ 23 | "###############################################\n", 24 | "## Import packages and specify some settings ##\n", 25 | "###############################################\n", 26 | "# Import packages\n", 27 | "import numpy as np\n", 28 | "import matplotlib.pyplot as plt\n", 29 | "import seaborn as sns\n", 30 | "\n", 31 | "# This makes plots show up and look nice\n", 32 | "%matplotlib inline\n", 33 | "sns.set(context='paper',style='white',font_scale=1.5,rc={\"lines.linewidth\":2.5})\n", 34 | "sns.set_palette('muted')\n", 35 | "\n", 36 | "###############################################\n", 37 | "###############################################\n", 38 | "\n", 39 | "# Discretized time\n", 40 | "T=50\n", 41 | "dt=.01\n", 42 | "time=np.arange(0,T,dt)\n", 43 | "\n", 44 | "# Initial condition, x(0)\n", 45 | "x0=1\n", 46 | "\n", 47 | "# Function for the RHS of ODE\n", 48 | "def f(x,t):\n", 49 | " return np.sin(x)*np.cos(t)\n", 50 | "\n", 51 | "# Initialize x\n", 52 | "x=np.zeros_like(time)\n", 53 | "\n", 54 | "# set initial condition\n", 55 | "x[0]=x0\n", 56 | "\n", 57 | "# Loop through time and perform Euler steps\n", 58 | "for i in range(len(time)-1):\n", 59 | " x[i+1]=x[i]+f(x[i],time[i])*dt\n", 60 | "\n", 61 | "# Plot solution\n", 62 | "plt.figure(figsize=(5, 2.5))\n", 63 | "plt.plot(time,x)\n", 64 | "plt.ylabel('x')\n", 65 | "plt.xlabel('t')\n", 66 | "sns.despine()\n", 67 | "\n", 68 | "plt.tight_layout()\n" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": null, 74 | "metadata": { 75 | "id": "vwALtEvz_IA2" 76 | }, 77 | "outputs": [], 78 | "source": [] 79 | } 80 | ], 81 | "metadata": { 82 | "colab": { 83 | "provenance": [] 84 | }, 85 | "kernelspec": { 86 | "display_name": "Python 3 (ipykernel)", 87 | "language": "python", 88 | "name": "python3" 89 | }, 90 | "language_info": { 91 | "codemirror_mode": { 92 | "name": "ipython", 93 | "version": 3 94 | }, 95 | "file_extension": ".py", 96 | "mimetype": "text/x-python", 97 | "name": "python", 98 | "nbconvert_exporter": "python", 99 | "pygments_lexer": "ipython3", 100 | "version": "3.11.8" 101 | } 102 | }, 103 | "nbformat": 4, 104 | "nbformat_minor": 4 105 | } 106 | -------------------------------------------------------------------------------- /Code/HHspikes.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": { 7 | "colab": { 8 | "base_uri": "https://localhost:8080/", 9 | "height": 243 10 | }, 11 | "executionInfo": { 12 | "elapsed": 18085, 13 | "status": "ok", 14 | "timestamp": 1709915032372, 15 | "user": { 16 | "displayName": "Robert Rosenbaum", 17 | "userId": "09541400600911705212" 18 | }, 19 | "user_tz": 300 20 | }, 21 | "id": "jdO46IA-CJRU", 22 | "outputId": "d7d6a250-4625-4aff-a03c-b7e6870ce321" 23 | }, 24 | "outputs": [ 25 | { 26 | "data": { 27 | "image/png": "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\n", 28 | "text/plain": [ 29 | "
" 30 | ] 31 | }, 32 | "metadata": {}, 33 | "output_type": "display_data" 34 | } 35 | ], 36 | "source": [ 37 | "\n", 38 | "###############################################\n", 39 | "## Import packages and specify some settings ##\n", 40 | "###############################################\n", 41 | "# Import packages\n", 42 | "import numpy as np\n", 43 | "import matplotlib.pyplot as plt\n", 44 | "import seaborn as sns\n", 45 | "\n", 46 | "# This makes plots show up and look nice\n", 47 | "#matplotlib inline\n", 48 | "sns.set(context='paper',style='white',font_scale=1.5,rc={\"lines.linewidth\":2.5})\n", 49 | "sns.set_palette('muted')\n", 50 | "\n", 51 | "###############################################\n", 52 | "###############################################\n", 53 | "\n", 54 | "\n", 55 | "\n", 56 | "# Discretized time\n", 57 | "T=300\n", 58 | "dt=.001\n", 59 | "time=np.arange(0,T,dt)\n", 60 | "\n", 61 | "# Initialize applied current\n", 62 | "Ix=np.zeros_like(time)\n", 63 | "\n", 64 | "# Add pulsatile inputs\n", 65 | "PulseWidths=1.5 # Width of pulse in ms\n", 66 | "PulseTimes=[25, 50, 75, 100] # Pulse times\n", 67 | "PulseStrengths=[2, 3, 5, 7] # Pulse strengths\n", 68 | "for i in range(len(PulseTimes)):\n", 69 | " Ix+=PulseStrengths[i]*np.exp(-(time-PulseTimes[i])**2/(2*PulseWidths**2))\n", 70 | "\n", 71 | "\n", 72 | "# Add step input\n", 73 | "from scipy.stats import norm\n", 74 | "StepHeight=8\n", 75 | "StepTime=150\n", 76 | "StepWidth=2\n", 77 | "Ix=Ix+StepHeight*norm.cdf(time,StepTime,StepWidth)\n", 78 | "\n", 79 | "\n", 80 | "\n", 81 | "# # Add pulsatile input in the form of a Gaussian\n", 82 | "# PulseWidth=1.5 # Width of pulse in ms\n", 83 | "# PulseTime=10 # Pulse time\n", 84 | "# PulseStrength=10 # Pulse strength\n", 85 | "# Ix=Ix+PulseStrength*np.exp(-(time-PulseTime)**2/(2*PulseWidth**2))\n", 86 | "\n", 87 | "\n", 88 | "\n", 89 | "# Define gating variables as inline functions\n", 90 | "alphan = lambda V: .01*(V+55)/(1-np.exp(-.1*(V+55)))\n", 91 | "betan = lambda V: .125*np.exp(-.0125*(V+65))\n", 92 | "alpham = lambda V: .1*(V+40)/(1-np.exp(-.1*(V+40)))\n", 93 | "betam = lambda V: 4*np.exp(-.0556*(V+65))\n", 94 | "alphah = lambda V: .07*np.exp(-.05*(V+65))\n", 95 | "betah = lambda V: 1/(1+np.exp(-.1*(V+35)))\n", 96 | "\n", 97 | "\n", 98 | "# n variable\n", 99 | "ninfty= lambda V: (alphan(V)/(alphan(V)+betan(V)))\n", 100 | "taun= lambda V: (1/(alphan(V)+betan(V)))\n", 101 | "minfty= lambda V: (alpham(V)/(alpham(V)+betam(V)))\n", 102 | "taum= lambda V: (1/(alpham(V)+betam(V)))\n", 103 | "hinfty= lambda V: (alphah(V)/(alphah(V)+betah(V)))\n", 104 | "tauh= lambda V: (1/(alphah(V)+betah(V)))\n", 105 | "\n", 106 | "# Parameters\n", 107 | "Cm=1\n", 108 | "gL=.3\n", 109 | "EL=-54.387\n", 110 | "gK=36\n", 111 | "EK=-77\n", 112 | "gNa=120\n", 113 | "ENa=50\n", 114 | "\n", 115 | "# Initial conditions near their fixed points when Ix=0\n", 116 | "V0=-65.0\n", 117 | "n0=ninfty(V0)\n", 118 | "m0=minfty(V0)\n", 119 | "h0=hinfty(V0)\n", 120 | "\n", 121 | "\n", 122 | "# Currents\n", 123 | "IL= lambda V: (-gL*(V-EL))\n", 124 | "IK = lambda n,V: (-gK*n **4*(V-EK))\n", 125 | "INa = lambda m,h,V: (-gNa*m **3*h*(V-ENa))\n", 126 | "\n", 127 | "# Toal ion currents\n", 128 | "Iion = lambda n,m,h,V: IL(V)+IK(n,V)+INa(m,h,V)\n", 129 | "\n", 130 | "# Euler solver\n", 131 | "V=np.zeros_like(time)\n", 132 | "n=np.zeros_like(time)\n", 133 | "m=np.zeros_like(time)\n", 134 | "h=np.zeros_like(time)\n", 135 | "V[0]=V0\n", 136 | "n[0]=n0\n", 137 | "m[0]=m0\n", 138 | "h[0]=h0\n", 139 | "for i in range(len(time)-1):\n", 140 | " # Update gating variables\n", 141 | " n[i+1]=n[i]+dt*((1-n[i])*alphan(V[i])-n[i]*betan(V[i]))\n", 142 | " m[i+1]=m[i]+dt*((1-m[i])*alpham(V[i])-m[i]*betam(V[i]))\n", 143 | " h[i+1]=h[i]+dt*((1-h[i])*alphah(V[i])-h[i]*betah(V[i]))\n", 144 | "\n", 145 | " # Update membrane potential\n", 146 | " V[i+1]=V[i]+dt*(Iion(n[i],m[i],h[i],V[i])+Ix[i])/Cm\n", 147 | "\n", 148 | "\n", 149 | "# Make figure\n", 150 | "plt.subplots(1,2,figsize=(11,2.5))\n", 151 | "\n", 152 | "\n", 153 | "\n", 154 | "\n", 155 | "plt.subplot(1,2,1)\n", 156 | "plt.plot(time,Ix,'m')\n", 157 | "plt.ylabel(r'$I_{x}$')\n", 158 | "plt.xlabel('time (ms)')\n", 159 | "plt.title('A',loc='left')\n", 160 | "sns.despine()\n", 161 | "\n", 162 | "\n", 163 | "plt.subplot(1,2,2)\n", 164 | "plt.plot(time,V,color=sns.color_palette()[7])\n", 165 | "plt.ylabel('V (mV)')\n", 166 | "plt.xlabel('time (ms)')\n", 167 | "plt.title('B',loc='left')\n", 168 | "plt.axis([0,T,np.min((-70,np.min(V))),np.max((-57,np.max(V)))])\n", 169 | "sns.despine()\n", 170 | "\n", 171 | "plt.tight_layout()\n", 172 | "\n" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": null, 178 | "metadata": { 179 | "id": "v8CbJPAJCJRW" 180 | }, 181 | "outputs": [], 182 | "source": [] 183 | } 184 | ], 185 | "metadata": { 186 | "colab": { 187 | "provenance": [] 188 | }, 189 | "kernelspec": { 190 | "display_name": "Python 3 (ipykernel)", 191 | "language": "python", 192 | "name": "python3" 193 | }, 194 | "language_info": { 195 | "codemirror_mode": { 196 | "name": "ipython", 197 | "version": 3 198 | }, 199 | "file_extension": ".py", 200 | "mimetype": "text/x-python", 201 | "name": "python", 202 | "nbconvert_exporter": "python", 203 | "pygments_lexer": "ipython3", 204 | "version": "3.11.8" 205 | } 206 | }, 207 | "nbformat": 4, 208 | "nbformat_minor": 4 209 | } 210 | -------------------------------------------------------------------------------- /Code/HopfieldNetwork.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 2, 6 | "metadata": { 7 | "colab": { 8 | "base_uri": "https://localhost:8080/", 9 | "height": 296 10 | }, 11 | "executionInfo": { 12 | "elapsed": 13789, 13 | "status": "ok", 14 | "timestamp": 1709915121970, 15 | "user": { 16 | "displayName": "Robert Rosenbaum", 17 | "userId": "09541400600911705212" 18 | }, 19 | "user_tz": 300 20 | }, 21 | "id": "cSiK-M2T4bkH", 22 | "outputId": "ee938962-0852-4c6d-b791-9d48885afea0", 23 | "tags": [] 24 | }, 25 | "outputs": [ 26 | { 27 | "data": { 28 | "image/png": "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", 29 | "text/plain": [ 30 | "
" 31 | ] 32 | }, 33 | "metadata": {}, 34 | "output_type": "display_data" 35 | } 36 | ], 37 | "source": [ 38 | "###############################################\n", 39 | "## Import packages and specify some settings ##\n", 40 | "###############################################\n", 41 | "# Import packages\n", 42 | "import numpy as np\n", 43 | "import matplotlib.pyplot as plt\n", 44 | "import seaborn as sns\n", 45 | "\n", 46 | "# This makes plots show up and look nice\n", 47 | "#matplotlib inline\n", 48 | "sns.set(context='paper',style='white',font_scale=1.5,rc={\"lines.linewidth\":2.5})\n", 49 | "sns.set_palette('muted')\n", 50 | "\n", 51 | "###############################################\n", 52 | "###############################################\n", 53 | "\n", 54 | "# For computing runtimes\n", 55 | "from time import time as tm\n", 56 | "\n", 57 | "# Seed random number generator so that\n", 58 | "# we get the same results every time\n", 59 | "# we run this code\n", 60 | "np.random.seed(7)\n", 61 | "\n", 62 | "\n", 63 | "# Load the data from a file\n", 64 | "try:\n", 65 | " data = np.load('../DataFiles/MNISTdata.npz', allow_pickle=True)\n", 66 | "except:\n", 67 | " url = \"https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/master/DataFiles/MNISTdata.npz\"\n", 68 | " file = np.DataSource().open(url)\n", 69 | " data = np.load(file.name, allow_pickle=True)\n", 70 | "X=data['X']\n", 71 | "\n", 72 | "# Attractor pattern\n", 73 | "i=7\n", 74 | "S0=np.zeros(28*28)\n", 75 | "S0[X[:,i]>.5]=1\n", 76 | "S0[X[:,i]<=.5]=-1\n", 77 | "\n", 78 | "# Dimension of s\n", 79 | "N=len(S0)\n", 80 | "\n", 81 | "# Define a W that will have S0 as its minimal energy state\n", 82 | "W=(1/N**2)*(np.outer(S0,S0)-np.diag(S0))\n", 83 | "\n", 84 | "\n", 85 | "S=S0.copy()\n", 86 | "NumPixelsToPerturb=80\n", 87 | "Inds=np.random.randint(N,size=NumPixelsToPerturb)\n", 88 | "#Inds0=np.random.randint(5,size=(2,NumPixelsToPerturb))\n", 89 | "#Inds=(Inds0[0]+1)*7+(Inds0[1]+1)\n", 90 | "S[Inds]=-S[Inds]\n", 91 | "Sinit=S.copy()\n", 92 | "\n", 93 | "# Compute Hopfield dynamics\n", 94 | "T=5500\n", 95 | "E=np.zeros(T)\n", 96 | "for n in range(T):\n", 97 | "\n", 98 | " # Compute the energy\n", 99 | " E[n]=-np.sum((S.T)@W@S)\n", 100 | "\n", 101 | " # Compute the input\n", 102 | " I=W@S\n", 103 | "\n", 104 | " # Choose a random neuron\n", 105 | " # and update its state\n", 106 | " j=np.random.randint(N)\n", 107 | " S[j]=np.sign(I[j])\n", 108 | "\n", 109 | "\n", 110 | "# Make figure\n", 111 | "plt.subplots(1,4,figsize=(12, 3))\n", 112 | "\n", 113 | "plt.subplot(1,4,1)\n", 114 | "plt.imshow(Sinit.reshape(28,28))\n", 115 | "plt.axis('off')\n", 116 | "plt.title('A',loc='left')\n", 117 | "plt.title(r'initial $\\mathbf{S}$',loc='center')\n", 118 | "sns.despine()\n", 119 | "\n", 120 | "plt.subplot(1,4,2)\n", 121 | "plt.imshow(S0.reshape(28,28))\n", 122 | "plt.axis('off')\n", 123 | "plt.title('B',loc='left')\n", 124 | "plt.title(r'$\\mathbf{S}^0$',loc='center')\n", 125 | "sns.despine()\n", 126 | "\n", 127 | "\n", 128 | "plt.subplot(1,4,3)\n", 129 | "plt.plot(np.arange(0,T),E,color=[.6,.6,.6])\n", 130 | "#plt.ticklabel_format(axis=\"x\", style=\"sci\",scilimits=(0,0))\n", 131 | "#plt.ticklabel_format(axis=\"y\", style=\"sci\",scilimits=(0,0))\n", 132 | "plt.xlabel('time (n)')\n", 133 | "plt.ylabel('energy (E)')\n", 134 | "plt.title('C',loc='left')\n", 135 | "sns.despine()\n", 136 | "\n", 137 | "\n", 138 | "plt.subplot(1,4,4)\n", 139 | "plt.imshow(S.reshape(28,28))\n", 140 | "plt.axis('off')\n", 141 | "plt.title('D',loc='left')\n", 142 | "plt.title(r'final $\\mathbf{S}$',loc='center')\n", 143 | "sns.despine()\n", 144 | "\n", 145 | "\n", 146 | "\n", 147 | "\n", 148 | "plt.tight_layout()\n" 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": null, 154 | "metadata": { 155 | "id": "sr2FPpTl4bkJ" 156 | }, 157 | "outputs": [], 158 | "source": [] 159 | } 160 | ], 161 | "metadata": { 162 | "colab": { 163 | "provenance": [] 164 | }, 165 | "kernelspec": { 166 | "display_name": "Python 3 (ipykernel)", 167 | "language": "python", 168 | "name": "python3" 169 | }, 170 | "language_info": { 171 | "codemirror_mode": { 172 | "name": "ipython", 173 | "version": 3 174 | }, 175 | "file_extension": ".py", 176 | "mimetype": "text/x-python", 177 | "name": "python", 178 | "nbconvert_exporter": "python", 179 | "pygments_lexer": "ipython3", 180 | "version": "3.11.8" 181 | } 182 | }, 183 | "nbformat": 4, 184 | "nbformat_minor": 4 185 | } 186 | -------------------------------------------------------------------------------- /Code/PythonIntro.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "id": "LYlAYL51_oDo" 7 | }, 8 | "source": [ 9 | "This is a text cell. It does not run Python code. It uses a markdown language to enable all sorts of formatting. Equations can be entered using LaTeX (*e.g.*, $E=mc^2$). You can double-click to edit a text cell and press Shift-Enter to compile it into formatted text.\n", 10 | "\n", 11 | "The cell below is a code cell that prints Hello World. \n", 12 | "To run it, press the play button or Shift-Enter. Shift-Enter moves to the next cell. In some notebook apps, you can press Ctrl-Enter or Cmd-Enter to run a cell without moving to the next cell.\n", 13 | "\n", 14 | "You can also use single quotes instead of double for a string. \n", 15 | "\n", 16 | "***Try changing from double to single, then run the code.***\n", 17 | "\n" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": null, 23 | "metadata": { 24 | "id": "4DkkE4Q1A-cQ" 25 | }, 26 | "outputs": [], 27 | "source": [ 28 | "print(\"Hello World\")" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": { 34 | "id": "IM9Aat0aBc3B" 35 | }, 36 | "source": [ 37 | "# Printing variables\n", 38 | "\n", 39 | "You can also print the value of a numerical variable and you can print more than one thing at a time, as below.\n", 40 | "\n", 41 | "And comments are made using the `#` symbol\n", 42 | "\n", 43 | "***Modify the code to also print xy and x+y.***" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": null, 49 | "metadata": { 50 | "id": "MZ41h7_sBmwA" 51 | }, 52 | "outputs": [], 53 | "source": [ 54 | "x=5 # This is a comment. This line defines x.\n", 55 | "y=2\n", 56 | "print(\"x =\",x,\"y =\",y)" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": { 62 | "id": "QbEWZScjBzXX" 63 | }, 64 | "source": [ 65 | "\n", 66 | "# Data Types\n", 67 | "\n", 68 | "Variables have a type. Three common types are ints, floats, and strings. Each of the variables below are one of those types. Floats can be recognized by the presence of a decimal.\n", 69 | "\n", 70 | "***If you add a float to an int, what is the result? Try adding them and printing the result to find out.***" 71 | ] 72 | }, 73 | { 74 | "cell_type": "code", 75 | "execution_count": null, 76 | "metadata": { 77 | "id": "THXlWwrDBoY8" 78 | }, 79 | "outputs": [], 80 | "source": [ 81 | "xInt=5\n", 82 | "xFloat=5.0\n", 83 | "xString=\"five\"" 84 | ] 85 | }, 86 | { 87 | "cell_type": "markdown", 88 | "metadata": { 89 | "id": "xFO4sQXOC5Z6" 90 | }, 91 | "source": [ 92 | "# Lists\n", 93 | "\n", 94 | "Lists are lists of values, similar to arrays but more versatile. The elements can have the same type or different types. \n", 95 | "\n", 96 | "Elements of a list can be addressed with square brackets like this: `x[2]`. The first element of a list is at index zero, x[0]. This is like C, but unlike Matlab. \n", 97 | "\n", 98 | "The function `len(x)` gives the length of the list, `x`.\n", 99 | "\n", 100 | "***Modify the code below to print the second element of x (which is 5).***\n", 101 | "\n", 102 | "***Print the length of x.***" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": null, 108 | "metadata": { 109 | "id": "j-UbAuTsCQ0n" 110 | }, 111 | "outputs": [], 112 | "source": [ 113 | "x=[1,5,7]\n", 114 | "print(x)\n", 115 | "x[1]=3\n", 116 | "print(x)" 117 | ] 118 | }, 119 | { 120 | "cell_type": "markdown", 121 | "metadata": {}, 122 | "source": [ 123 | "# Immutable lists\n", 124 | "\n", 125 | "Lists can also be created using curved brackets. This creates an \"immutable\" list for which you cannot change the entries. \n", 126 | "\n", 127 | "**In the code below, try to change an element of `x` like we did in the cell above. You should get an error.**" 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": null, 133 | "metadata": {}, 134 | "outputs": [], 135 | "source": [ 136 | "x=(1,5,7)\n", 137 | "print(x)" 138 | ] 139 | }, 140 | { 141 | "cell_type": "markdown", 142 | "metadata": { 143 | "id": "k4oB3r8dJtDE" 144 | }, 145 | "source": [ 146 | "# Passing by reference\n", 147 | "\n", 148 | "If you do `y=x` when `x` is a number, it makes a new copy of `x` to define `y`.\n", 149 | "\n", 150 | "If you do `b=a` when `a` is a list, then it \"passes by reference\" so `a` and `b` refer to the same data. If you change `b`, it will also change `a`.\n", 151 | "\n", 152 | "***Try to guess what the values of `x` and `a` are at the end of the code cell below. Then add a print command to see for yourself.***" 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": null, 158 | "metadata": { 159 | "id": "hwrVjFeiJr5G" 160 | }, 161 | "outputs": [], 162 | "source": [ 163 | "x=5\n", 164 | "y=x\n", 165 | "y=10\n", 166 | "\n", 167 | "a=[1,2,3]\n", 168 | "b=a\n", 169 | "b[0]=100" 170 | ] 171 | }, 172 | { 173 | "cell_type": "markdown", 174 | "metadata": { 175 | "id": "yZvXg5zrEDAt" 176 | }, 177 | "source": [ 178 | "# indexing contiguous elements of a list\n", 179 | "\n", 180 | "You can access multiple elements of a list using `:` .\n", 181 | "\n", 182 | "***Add a line of code that changes the first two elements of `a` to 10 and 20 (using `[10,20]` as the RHS). Then print `a` again.***\n" 183 | ] 184 | }, 185 | { 186 | "cell_type": "code", 187 | "execution_count": null, 188 | "metadata": { 189 | "id": "5FvWnAbJEVBe" 190 | }, 191 | "outputs": [], 192 | "source": [ 193 | "a=[1,2,3,4,5,6,7]\n", 194 | "print(a[1:3])" 195 | ] 196 | }, 197 | { 198 | "cell_type": "markdown", 199 | "metadata": { 200 | "id": "U9CwtLCQFO_s" 201 | }, 202 | "source": [ 203 | "# Indexing tricks\n", 204 | "\n", 205 | "To index from the second element to the last, you can do `a[1:]` \n", 206 | "\n", 207 | "To index from the first to the thrid, you can do `a[:2]`\n", 208 | "\n", 209 | "To take steps of size 2 between indices, you can do `a[1:6:2]`\n", 210 | "\n", 211 | "To index the last element, use `a[-1]`\n", 212 | "\n", 213 | "***Print the first three elements of `a`. Then print all the elements after the second one. Then print every other element starting with the second one.***" 214 | ] 215 | }, 216 | { 217 | "cell_type": "code", 218 | "execution_count": null, 219 | "metadata": { 220 | "id": "wdTZ2JU7Fnz2" 221 | }, 222 | "outputs": [], 223 | "source": [ 224 | "a=[1,2,3,4,5,6,7]\n", 225 | "\n", 226 | "# Put code here" 227 | ] 228 | }, 229 | { 230 | "cell_type": "markdown", 231 | "metadata": { 232 | "id": "iDSkxKrvFsyu" 233 | }, 234 | "source": [ 235 | "# for Loops\n", 236 | "\n", 237 | "for loops can iterate through a list, as below. Note the `:`.\n", 238 | "\n", 239 | "**Important note:** Python uses indentation to denote \"scope\" (e.g., inside versus outside of the for loop). You can use four spaces or tab to indent.\n", 240 | "\n", 241 | "***Modify the code to print a, b, and c (as strings) instead of 1, 2, and 3.***\n", 242 | "\n" 243 | ] 244 | }, 245 | { 246 | "cell_type": "code", 247 | "execution_count": null, 248 | "metadata": { 249 | "id": "iBGwPwoJF2N0" 250 | }, 251 | "outputs": [], 252 | "source": [ 253 | "for i in [1,2,3]:\n", 254 | " print(i)" 255 | ] 256 | }, 257 | { 258 | "cell_type": "markdown", 259 | "metadata": { 260 | "id": "Tu_d1QNwJI-a" 261 | }, 262 | "source": [ 263 | "# range \n", 264 | "\n", 265 | "We often want to iterate through sequential integers. We can use `range` to do that. \n", 266 | "\n", 267 | "`range(3)` goes from 0 to 2.\n", 268 | "\n", 269 | "`range(2,5)` goes from 2 to 4.\n", 270 | "\n", 271 | "`range(2,10,2)` goes from 2 to 9 in steps of 2.\n", 272 | "\n", 273 | "***Print all the even integers from 4 to 20.***" 274 | ] 275 | }, 276 | { 277 | "cell_type": "code", 278 | "execution_count": null, 279 | "metadata": { 280 | "id": "u_vvoRbuF4NT" 281 | }, 282 | "outputs": [], 283 | "source": [ 284 | "for i in range(3):\n", 285 | " print(i)" 286 | ] 287 | }, 288 | { 289 | "cell_type": "markdown", 290 | "metadata": { 291 | "id": "EGMpiFzYLyii" 292 | }, 293 | "source": [ 294 | "# Functions \n", 295 | "\n", 296 | "Functions are defined as below (note the indentation). They can take zero or more arguments and return zero or more arguments.\n", 297 | "\n", 298 | "***Define a function that takes a list as input and returns the first element of the list***" 299 | ] 300 | }, 301 | { 302 | "cell_type": "code", 303 | "execution_count": null, 304 | "metadata": { 305 | "id": "gusRX5cWLfGD" 306 | }, 307 | "outputs": [], 308 | "source": [ 309 | "def myMult(x,y):\n", 310 | " z=x*y\n", 311 | " return z\n", 312 | "\n", 313 | "u=myMult(5,3)\n", 314 | "print(u)\n", 315 | "\n", 316 | "def OneTwoThree():\n", 317 | " return 1,2,3\n", 318 | "\n", 319 | "v,w,x=OneTwoThree()\n", 320 | "print(v,w,x)" 321 | ] 322 | }, 323 | { 324 | "cell_type": "markdown", 325 | "metadata": { 326 | "id": "kGVBTJpRNvly" 327 | }, 328 | "source": [ 329 | "# NumPy\n", 330 | "\n", 331 | "Numpy is a package for doing numerical computations in Python. It is very similar to Matlab. Import it using the import function, as below. After importing it, any numpy function can be accessed using `np.function` where `function` is the name of the function.\n", 332 | "\n", 333 | "If you're used to Matlab, this page that translates between Numpy and Matlab is very handy: https://docs.scipy.org/doc/numpy/user/numpy-for-matlab-users.html\n", 334 | "\n", 335 | "The most common data type is a numpy array. They are similar to a Python list.\n", 336 | "\n", 337 | "***Create and print a numpy array with two elements: 4 and 5.***" 338 | ] 339 | }, 340 | { 341 | "cell_type": "code", 342 | "execution_count": null, 343 | "metadata": { 344 | "id": "u413T7YAMGhM" 345 | }, 346 | "outputs": [], 347 | "source": [ 348 | "import numpy as np\n", 349 | "x=np.array([1,2,3])\n", 350 | "print(x[1])" 351 | ] 352 | }, 353 | { 354 | "cell_type": "markdown", 355 | "metadata": { 356 | "id": "GgrFyKZ9QLjM" 357 | }, 358 | "source": [ 359 | "# Creating NumPy arrays\n", 360 | "\n", 361 | "There are lots of functions for creating numpy arrays. Some examples are below.\n", 362 | "\n", 363 | "***Create a numpy array that goes from 3 to 9 in steps of 2***" 364 | ] 365 | }, 366 | { 367 | "cell_type": "code", 368 | "execution_count": null, 369 | "metadata": { 370 | "id": "17RJRyXNPxs7" 371 | }, 372 | "outputs": [], 373 | "source": [ 374 | "x=np.zeros(5) # An array containing five 0's\n", 375 | "print(x)\n", 376 | "\n", 377 | "y=np.ones(10) # An array containing ten 1's\n", 378 | "print(y)\n", 379 | "\n", 380 | "v=np.arange(2,5) # Just like range(5)\n", 381 | "print(v)\n", 382 | "\n", 383 | "w=np.arange(0,1,.1) # But with arange you can take non-integer steps.\n", 384 | "print(w)\n", 385 | "\n", 386 | "u=np.random.rand(3) # Three random numbers from U[0,1]\n", 387 | "print(u)\n", 388 | "\n", 389 | "z=np.random.randn(5) # Five random numbers from N(0,1)\n", 390 | "print(z) " 391 | ] 392 | }, 393 | { 394 | "cell_type": "markdown", 395 | "metadata": { 396 | "id": "qsOUd_pcivFo" 397 | }, 398 | "source": [ 399 | "# Logical indexing\n", 400 | "\n", 401 | "Logical indexing lets you index elements of an array based on the values inside that or other arrays. See below for examples.\n", 402 | "\n", 403 | "***Create an array of 20 normally distributed numbers then set all of the negative entries to zero.***" 404 | ] 405 | }, 406 | { 407 | "cell_type": "code", 408 | "execution_count": null, 409 | "metadata": { 410 | "id": "vPS_l2FNi7iP" 411 | }, 412 | "outputs": [], 413 | "source": [ 414 | "a=np.array([10,20,30,40])\n", 415 | "b=np.array([5,5,5,5])\n", 416 | "b[a<=20]=1 # Find where a is <=20 and set the corresponding values of b to 1\n", 417 | "print(b)\n", 418 | "\n" 419 | ] 420 | }, 421 | { 422 | "cell_type": "markdown", 423 | "metadata": { 424 | "id": "jH29-ZsgRnew" 425 | }, 426 | "source": [ 427 | "# Matrices\n", 428 | "\n", 429 | "Matrices are just arrays of arrays (2D arrays). They can be created as below.\n", 430 | "\n", 431 | "The size of any array can be accessed using `shape`\n", 432 | "\n", 433 | "To address a matrix, just use two indices separated by a comma.\n", 434 | "\n", 435 | "***Print the first row of x.***" 436 | ] 437 | }, 438 | { 439 | "cell_type": "code", 440 | "execution_count": null, 441 | "metadata": { 442 | "id": "c3ms9taZRvql" 443 | }, 444 | "outputs": [], 445 | "source": [ 446 | "x=np.array([[1,2,3],[4,5,6]]) # Create a matrix by hand\n", 447 | "print(x)\n", 448 | "\n", 449 | "# For ones and zeros, you pass the size as a list.\n", 450 | "x=np.ones((3,3)) \n", 451 | "print(x)\n", 452 | "\n", 453 | "# For rand and randn, you just pass multiple arguments\n", 454 | "x=np.random.rand(3,3)\n", 455 | "print(x)\n", 456 | "\n", 457 | "# Print the size of x using two different syntaxes\n", 458 | "print(np.shape(x))\n", 459 | "print(x.shape)\n", 460 | "\n", 461 | "# To access elements, use two indices\n", 462 | "print(x[0,2])\n", 463 | "\n", 464 | "# You can also access multiple elements\n", 465 | "print(x[0:2,0])" 466 | ] 467 | }, 468 | { 469 | "cell_type": "markdown", 470 | "metadata": { 471 | "id": "DaQ4DBSiUJYr" 472 | }, 473 | "source": [ 474 | "# Basic Linear Algebra in Numpy\n", 475 | "\n", 476 | "In NumPy, 1D arrays are treated as vectors \n", 477 | "\n", 478 | "and 2D arrays as matrices. There are built-in functions for just about any linear algebra operation you would want. You can use Google to find them.\n", 479 | "\n", 480 | "***Define the matrix $C=BA^T$ where $A^T$ is the transpose of $A$ then print $C$***" 481 | ] 482 | }, 483 | { 484 | "cell_type": "code", 485 | "execution_count": null, 486 | "metadata": { 487 | "id": "5VEYU76VR2g0" 488 | }, 489 | "outputs": [], 490 | "source": [ 491 | "A=np.array([[1,2,3],[4,5,6],[5,5,5]])\n", 492 | "B=np.ones((3,3))\n", 493 | "x=np.array([7,8,9])\n", 494 | "y=np.ones(3)\n", 495 | "\n", 496 | "# Add two vectors or matrices (must have the same size)\n", 497 | "print(x+y)\n", 498 | "print(A+B)\n", 499 | "\n", 500 | "# Element-wise multiplication\n", 501 | "print(x*y)\n", 502 | "print(A*B)\n", 503 | "\n", 504 | "# Matrix-vector and matrix-matrix multiplication. Inner dimensions must agree\n", 505 | "# unless applied to two vectors of the same size, in which case the \n", 506 | "# dot product is computed.\n", 507 | "print(A@x)\n", 508 | "print(A@B)\n", 509 | "print(x@y) # dot product\n", 510 | "\n" 511 | ] 512 | }, 513 | { 514 | "cell_type": "markdown", 515 | "metadata": { 516 | "id": "hCbBq4H0XJ0E" 517 | }, 518 | "source": [ 519 | "\n", 520 | "\n", 521 | "# Exercise: Create a dot product function\n", 522 | "\n", 523 | "Write a function, MyDotProduct, that takes two 1D numpy arrays as inputs and uses a for-loop to compute the dot product between them. To test your function, compare its output to the output from using `@` when applied to two random vectors.\n" 524 | ] 525 | }, 526 | { 527 | "cell_type": "code", 528 | "execution_count": null, 529 | "metadata": { 530 | "id": "YyvttWj29ZEK" 531 | }, 532 | "outputs": [], 533 | "source": [ 534 | "# put code here\n" 535 | ] 536 | }, 537 | { 538 | "cell_type": "markdown", 539 | "metadata": { 540 | "id": "-IRbBDWJT_BE" 541 | }, 542 | "source": [ 543 | "# Vectorization \n", 544 | "\n", 545 | "The code below computes the product between two random matrices using nested for-loops that directly implement the equation:\n", 546 | "$$\n", 547 | " C(j,k)=\\sum_i A(j,i)B(i,k)\n", 548 | "$$\n", 549 | "It uses the `time` library to calculate how long it takes to perform the multplication. Read through the code to understand what it's doing. \n", 550 | "\n", 551 | "Vectorization is the act of using built-in functions in place of loops. The built-in functions are pre-compiled in C, so they run faster. To vectorize the loops below, you would just use the numpy matrix multiplication `@` in place of loops. \n", 552 | "\n", 553 | "**Add code at the end of this cell that performs the same matrix multiplication using the vectorized `@` operator. Compare the runtimes.**" 554 | ] 555 | }, 556 | { 557 | "cell_type": "code", 558 | "execution_count": null, 559 | "metadata": { 560 | "id": "2JIu2fF2T_J3" 561 | }, 562 | "outputs": [], 563 | "source": [ 564 | "\n", 565 | "# import the timing function\n", 566 | "from time import time as tm \n", 567 | "\n", 568 | "# Define the number of dimensions\n", 569 | "n=200\n", 570 | "\n", 571 | "# Generate random matrices A and B\n", 572 | "A=np.random.randn(n,n)\n", 573 | "B=np.random.randn(n,n)\n", 574 | "\n", 575 | "### First Do matrix multiplication with nested loops\n", 576 | "t1=tm()\n", 577 | "\n", 578 | "C=np.zeros((n,n))\n", 579 | "\n", 580 | "for j in range(n):\n", 581 | " for k in range(n):\n", 582 | " for i in range(n):\n", 583 | " C[j,k]=C[j,k]+A[j,i]*B[i,k]\n", 584 | "\n", 585 | "t2=tm()\n", 586 | "print(\"Time to compute product =\",t2-t1,\"seconds\")\n", 587 | "\n", 588 | "### Now do \"vectorized matrix multplication using @ and time it\n", 589 | "\n", 590 | "\n", 591 | "\n", 592 | "\n" 593 | ] 594 | }, 595 | { 596 | "cell_type": "markdown", 597 | "metadata": { 598 | "id": "XwSirKf2ntbA" 599 | }, 600 | "source": [ 601 | "# matplotlib\n", 602 | "\n", 603 | "`matplotlib` is a package for creating plots and other graphics. \n", 604 | "\n", 605 | "Its plotting functions take NumPy arrays as inputs. \n", 606 | "\n", 607 | "To create a new figure, use `plt.figure()`\n", 608 | "\n", 609 | "To make a standard line plot, use `plt.plot(x,y)`\n", 610 | "\n", 611 | "Some notebook apps require you to enter `plt.show()` to show the plot as output from the notebook.\n", 612 | "\n", 613 | "To make a plot in red, use `plt.plot(x,y,'r')` and there are many other options for styling your plots.\n" 614 | ] 615 | }, 616 | { 617 | "cell_type": "code", 618 | "execution_count": null, 619 | "metadata": { 620 | "id": "03OfYvvTnxpK" 621 | }, 622 | "outputs": [], 623 | "source": [ 624 | "# Import matplotlib functions for plotting\n", 625 | "import matplotlib.pyplot as plt\n", 626 | "\n", 627 | "# Build vectors to plot\n", 628 | "x=np.arange(-3,3,.1)\n", 629 | "y=x**2\n", 630 | "\n", 631 | "# Plot two curves on the same axis\n", 632 | "plt.figure()\n", 633 | "plt.plot(x,y,label='y')\n", 634 | "plt.plot(x,x**3,label='x^3')\n", 635 | "plt.legend()\n", 636 | "plt.xlabel('x')\n", 637 | "plt.ylabel('y')\n", 638 | "\n", 639 | "# Now make another figure\n", 640 | "plt.figure(figsize=(5,3))\n", 641 | "plt.plot(x,y,'g--')\n", 642 | "plt.plot(x,x**3,color=[.8,.1,.8],linewidth=2)\n", 643 | "plt.title('same plot with different style')\n", 644 | "\n", 645 | "\n", 646 | "plt.show()" 647 | ] 648 | }, 649 | { 650 | "cell_type": "markdown", 651 | "metadata": { 652 | "id": "OlGgl5hepk3z" 653 | }, 654 | "source": [ 655 | "# seaborn\n", 656 | "\n", 657 | "seaborn is a package that helps make more aesthetically pleasing matplotlib plots and also provides many utilities for plotting data sets and their statistics. We will ony use it for aesthetic purposes.\n", 658 | "\n", 659 | "To make a $m\\times n$ grid of plots, use `subplot(m,n,j)` where `j` tells which gridspace to plot on.\n", 660 | "\n" 661 | ] 662 | }, 663 | { 664 | "cell_type": "code", 665 | "execution_count": null, 666 | "metadata": {}, 667 | "outputs": [], 668 | "source": [ 669 | "import seaborn as sns\n", 670 | "\n", 671 | "# Change some seaborn settings to make plots look nicer\n", 672 | "sns.set(context='paper',style='white',font_scale=1.5,rc={\"lines.linewidth\":2.5})\n", 673 | "sns.set_palette('muted')\n", 674 | "\n", 675 | "# Build vectors to plot\n", 676 | "x=np.arange(-3,3,.1)\n", 677 | "y=x**2\n", 678 | "\n", 679 | "# Make new figure with subplots\n", 680 | "plt.subplots(1,2,figsize=(11,4))\n", 681 | "\n", 682 | "# Build each subplot\n", 683 | "plt.subplot(1,2,1)\n", 684 | "plt.plot(x,y,label='y')\n", 685 | "plt.plot(x,x**3,label='x^3')\n", 686 | "plt.legend()\n", 687 | "plt.xlabel('x')\n", 688 | "plt.ylabel('y')\n", 689 | "plt.title('A',loc='left')\n", 690 | "\n", 691 | "\n", 692 | "plt.subplot(1,2,2)\n", 693 | "plt.plot(x,y,'g--')\n", 694 | "plt.plot(x,x**3,color=[.8,.1,.8],linewidth=2)\n", 695 | "plt.xlabel('x')\n", 696 | "plt.ylabel('y')\n", 697 | "plt.title('B',loc='left')\n", 698 | "\n", 699 | "# This keeps the subplots closer together\n", 700 | "plt.tight_layout()\n", 701 | "\n", 702 | "# This removes the top and right axes from plots\n", 703 | "sns.despine()" 704 | ] 705 | }, 706 | { 707 | "cell_type": "code", 708 | "execution_count": null, 709 | "metadata": {}, 710 | "outputs": [], 711 | "source": [] 712 | } 713 | ], 714 | "metadata": { 715 | "colab": { 716 | "collapsed_sections": [], 717 | "name": "Code0-PythonIntro.ipynb", 718 | "provenance": [] 719 | }, 720 | "kernelspec": { 721 | "display_name": "Python 3 (ipykernel)", 722 | "language": "python", 723 | "name": "python3" 724 | }, 725 | "language_info": { 726 | "codemirror_mode": { 727 | "name": "ipython", 728 | "version": 3 729 | }, 730 | "file_extension": ".py", 731 | "mimetype": "text/x-python", 732 | "name": "python", 733 | "nbconvert_exporter": "python", 734 | "pygments_lexer": "ipython3", 735 | "version": "3.11.8" 736 | } 737 | }, 738 | "nbformat": 4, 739 | "nbformat_minor": 4 740 | } 741 | -------------------------------------------------------------------------------- /DataFiles/MNISTdata.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/DataFiles/MNISTdata.npz -------------------------------------------------------------------------------- /DataFiles/RealMembranePotentialData.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/DataFiles/RealMembranePotentialData.npz -------------------------------------------------------------------------------- /DataFiles/SpikeCounts112Neuron12Thetas.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/DataFiles/SpikeCounts112Neuron12Thetas.npz -------------------------------------------------------------------------------- /DataFiles/SpikeCounts112Neurons2Thetas.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/DataFiles/SpikeCounts112Neurons2Thetas.npz -------------------------------------------------------------------------------- /DataFiles/SpikeCounts112Neurons2ThetasTest.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/DataFiles/SpikeCounts112Neurons2ThetasTest.npz -------------------------------------------------------------------------------- /DataFiles/SpikeCounts1Neuron12Thetas.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/DataFiles/SpikeCounts1Neuron12Thetas.npz -------------------------------------------------------------------------------- /DataFiles/SpikeCounts2Neurons2Thetas.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/DataFiles/SpikeCounts2Neurons2Thetas.npz -------------------------------------------------------------------------------- /DataFiles/SpikeTimes1Neuron1Theta.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/DataFiles/SpikeTimes1Neuron1Theta.npz -------------------------------------------------------------------------------- /ImageFiles/ANNDiagram.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/ImageFiles/ANNDiagram.png -------------------------------------------------------------------------------- /ImageFiles/CoupledPhaseOscDiagram.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/ImageFiles/CoupledPhaseOscDiagram.png -------------------------------------------------------------------------------- /ImageFiles/Cover.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/ImageFiles/Cover.jpg -------------------------------------------------------------------------------- /ImageFiles/DriftingGrating.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/ImageFiles/DriftingGrating.png -------------------------------------------------------------------------------- /ImageFiles/EIFwithPoissonSynapses.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/ImageFiles/EIFwithPoissonSynapses.png -------------------------------------------------------------------------------- /ImageFiles/EIPairForPlast.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/ImageFiles/EIPairForPlast.png -------------------------------------------------------------------------------- /ImageFiles/EIPairForPlast1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/ImageFiles/EIPairForPlast1.png -------------------------------------------------------------------------------- /ImageFiles/EIPairForPlast2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/ImageFiles/EIPairForPlast2.png -------------------------------------------------------------------------------- /ImageFiles/EIRecurrentNet.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/ImageFiles/EIRecurrentNet.png -------------------------------------------------------------------------------- /ImageFiles/FeedFwdNet.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/ImageFiles/FeedFwdNet.png -------------------------------------------------------------------------------- /ImageFiles/OscillatorDiagram.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/ImageFiles/OscillatorDiagram.png -------------------------------------------------------------------------------- /ImageFiles/RNNdiagram.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/ImageFiles/RNNdiagram.png -------------------------------------------------------------------------------- /ImageFiles/SurroundSuppDiagram1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/ImageFiles/SurroundSuppDiagram1.png -------------------------------------------------------------------------------- /ImageFiles/SurroundSuppDiagram2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/ImageFiles/SurroundSuppDiagram2.png -------------------------------------------------------------------------------- /ImageFiles/Synapses.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/2a2a4c558a1a3671553cde4973612953176e3714/ImageFiles/Synapses.png -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Modeling Neural Circuits Made Simple 2 | 3 | Python notebooks for the textbook "Modeling Neural Circuits Made Simple with Python" by Robert Rosenbaum. 4 | 5 | The notebooks generate figures from the textbook. The book contains references to each notebook. 6 | 7 | The notebooks can also be found in the following Drive folder where they can be run in Google Colab: 8 | https://drive.google.com/drive/folders/1UFS60MnpSUHIGsnGyIbsmtJliZLd3b2c?usp=sharing 9 | 10 | The book can be found on the publisher's website where an open access is available by clicking on "Open access" and then "Other open access edition": 11 | https://mitpress.mit.edu/9780262548083/modeling-neural-circuits-made-simple-with-python/ 12 | 13 | and it can be purchased on Amazon: 14 | https://www.amazon.com/dp/0262548089/ 15 | 16 | Please email any corrections or suggestions to Robert.Rosenbaum@nd.edu and include the term MNCBOOK in the subject line. 17 | 18 | To cite the book, please use the following: 19 | 20 | Rosenbaum, Robert. Modeling Neural Circuits Made Simple with Python. MIT Press, 2024. 21 | 22 | or in bibtex: 23 | 24 | @book{rosenbaum2024modeling, 25 | title={Modeling Neural Circuits Made Simple with Python}, 26 | author={Rosenbaum, Robert}, 27 | year={2024}, 28 | publisher={MIT Press}, 29 | address={Cambridge, MA} 30 | } 31 | 32 | ![Cover](https://raw.githubusercontent.com/RobertRosenbaum/ModelingNeuralCircuits/main/ImageFiles/Cover.jpg) 33 | --------------------------------------------------------------------------------