model.py

   1 from os import mkdir
   2 import matplotlib.pyplot as plt
   3 import matplotlib.ticker as mtick
   4 import nengo
   5 import numpy as np
   6
   7 exec(open("conf.py").read())
   8
   9 def wm_recurrent_function(x):
  10         return x
  11
  12
  13 def inputs_function(x):
  14         return x * tau_wm
  15
  16
  17 def noise_decision_function(t):
  18         return np.random.normal(0.0, noise_decision)
  19
  20
  21 def noise_bias_function(t):
  22         return np.random.normal(0.0, noise_wm)
  23
  24
  25 def time_function(t):
  26     return time_scale if t > t_cue else 0
  27
  28
  29 def decision_function(x):
  30     return 1.0 if x[0] + x[1] > 0.0 else -1.0
  31
  32
  33 class Alpha(object):
  34     """
  35     Base class for alpha receptors. Not to be used directly.
  36     """
  37
  38     def __init__(self):
  39         self.x = np.logspace(0, 3, steps)
  40         self.y = 1 / (1 + (999 * np.exp(-0.1233 * (self.x / self.offset))))
  41
  42         self.gain = []
  43         self.bias = []
  44
  45         for i in range(steps):
  46             y = self.y[i]
  47             self.gain.append(1 + self.gaind * y)
  48             self.bias.append(1 + self.biasd * y)
  49
  50     def plot(self):
  51         try:
  52             mkdir("./out")
  53         except FileExistsError:
  54             pass
  55
  56         out = f"./out/{self.__class__.__name__}"
  57         plt.plot(self.x, self.y)
  58
  59         plt.xlabel("Norepinephrine concentration (nM)")
  60         plt.ylabel("Activity (%)")
  61         plt.title("Norepinepherine Concentration vs Neuron Activity in " +
  62                   self.pretty)
  63
  64         plt.vlines(self.ki, 0, 1, linestyles="dashed")
  65         plt.text(1.1 * self.ki, 0.1, "Affinity")
  66
  67         plt.hlines(0.5, 0, 1000, linestyles="dashed")
  68         plt.text(1, 0.51, "50%")
  69
  70         plt.xscale("log")
  71         plt.gca().yaxis.set_major_formatter(mtick.PercentFormatter())
  72
  73         plt.draw()
  74         plt.savefig(f"{out}-norep-activity.png", dpi=1000)
  75
  76         #######################################################################
  77
  78         plt.plot(self.x, self.gain)
  79
  80         plt.xlabel("Norepinephrine concentration (nM)")
  81         plt.ylabel("Gain")
  82         plt.title(f"Concentration vs Gain in {self.pretty}")
  83
  84         plt.draw()
  85         plt.savefig(f"{out}-concentration-gain.png", dpi=1000)
  86
  87         #######################################################################
  88
  89         plt.plot(self.x, self.bias)
  90
  91         plt.xlabel("Norepinephrine concentration (nM)")
  92         plt.ylabel("Bias")
  93         plt.title("Concentration vs Bias in " + self.pretty)
  94
  95         plt.draw()
  96         plt.savefig(f"{out}-concentration-bias.png", dpi=1000)
  97
  98     def simulate(self):
  99             with nengo.Network() as net:
 100                 # Nodes
 101                 time_node = nengo.Node(output=time_function)
 102                 noise_wm_node = nengo.Node(output=noise_bias_function)
 103                 noise_decision_node = nengo.Node(
 104                     output=noise_decision_function)
 105
 106                 # Ensembles
 107                 wm = nengo.Ensemble(neurons_wm, 2)
 108                 decision = nengo.Ensemble(neurons_decide, 2)
 109                 inputs = nengo.Ensemble(neurons_inputs, 2)
 110                 output = nengo.Ensemble(neurons_decide, 1)
 111
 112                 # Connections
 113                 nengo.Connection(time_node, inputs[1], synapse=None)
 114                 nengo.Connection(inputs, wm, synapse=tau_wm,
 115                                  function=inputs_function)
 116                 wm_recurrent = nengo.Connection(wm, wm, synapse=tau_wm,
 117                                                 function=wm_recurrent_function)
 118                 nengo.Connection(noise_wm_node, wm.neurons, synapse=tau_wm,
 119                                  transform=np.ones((neurons_wm, 1)) * tau_wm)
 120                 wm_to_decision = nengo.Connection(
 121                     wm[0], decision[0], synapse=tau)
 122                 nengo.Connection(noise_decision_node,
 123                                  decision[1], synapse=None)
 124                 nengo.Connection(decision, output, function=decision_function)
 125
 126                 # Probes
 127                 #probes_wm = nengo.Probe(
 128                 #    wm[0], synapse=0.01, sample_every=dt_sample)
 129                 #probes_spikes = nengo.Probe(wm.neurons, 'spikes',
 130                 #                            sample_every=dt_sample)
 131                 #probe_output = nengo.Probe(output, synapse=None,
 132                 #                           same_every=dt_sample)
 133
 134                 # Run simulation
 135                 with nengo.Simulator(net, dt=dt) as sim:
 136                     sim.run(t_cue + t_delay)
 137
 138
 139 class Alpha1(Alpha):
 140     """
 141     Subclass of Alpha representing an alpha1 receptor.
 142     """
 143
 144     def __init__(self):
 145         self.ki = 330
 146         self.offset = 5.895
 147         self.pretty = "α1 Receptor"
 148         self.gaind = 0.1
 149         self.biasd = 0.1
 150         super().__init__()
 151
 152
 153 class Alpha2(Alpha):
 154     """
 155     Subclass of Alpha representing an alpha2 receptor.
 156     """
 157
 158     def __init__(self):
 159         self.ki = 56
 160         self.offset = 1
 161         self.pretty = "α2 Receptor"
 162         self.gaind = -0.04
 163         self.biasd = -0.02
 164         super().__init__()
 165
 166
 167 def main():
 168     plt.style.use("ggplot")  # Nice looking and familiar style
 169
 170     a1 = Alpha1()
 171     # a1.plot()
 172     a1.simulate()
 173
 174     #a2 = Alpha2()
 175     # a2.plot()
 176
 177
 178 if __name__ == "__main__":
 179     main()