Log things

diff --git a/conf.py b/conf.py
index 0c71dfa46faff3c0b775b8f55e3fbe47e966be55..02c981c9e2ba9f967d5c63319917601232adec08 100644 (file)
--- a/conf.py
+++ b/conf.py
@@ -1,4 +1,4 @@
-dt = 0.001             # Time step
+dt = 0.01              # Time step
 t_cue = 1.0            # Duration of cue presentation
 cue_scale = 1.0        # How strong the cuelus is from the visual system
 perceived = 0          # ???
@@ -11,5 +11,4 @@ neurons_inputs = 100   # Number of neurons for inputs ensemble
 neurons_wm = 100       # Number of neurons for working memory ensemble
 tau_wm = 0.1           # Synapse on recurrent connection in wm
 tau = 0.01             # Synaptic time constant between ensembles
-dt_sample = 0.01       # Timestep for data recording through probes
 t_delay = 8.0          # Duration of delay period between cue and decision

diff --git a/model.py b/model.py
index f3079e211decc92113a2d04546e4f0c5df178a34..cd6002207c20f0c1f5b6246163964ce490c9e937 100644 (file)
--- a/model.py
+++ b/model.py
@@ -1,4 +1,7 @@
+from datetime import datetime
 from os import mkdir
+import logging
+
 import matplotlib.pyplot as plt
 import matplotlib.ticker as mtick
 import nengo
@@ -6,16 +9,13 @@ import numpy as np
 
 exec(open("conf.py").read())
 
-def fmt_num(num):
+
+def fmt_num(num, width=18):
     """
     Format number to string.
     """
 
-    return str(num)[:18].zfill(18)
-
-
-def wm_recurrent_function(x):
-    return x
+    return str(num)[:width].ljust(width)
 
 
 def inputs_function(x):
@@ -47,28 +47,25 @@ class Alpha(object):
         self.x = np.logspace(0, 3, steps)
         self.y = 1 / (1 + (999 * np.exp(-0.1233 * (self.x / self.offset))))
 
-        self.gain = []
-        self.bias = []
+        self.gains = []
+        self.biass = []
 
         for i in range(steps):
             y = self.y[i]
-            self.gain.append(1 + self.gaind * y)
-            self.bias.append(1 + self.biasd * y)
+            self.gains.append(1 + self.gaind * y)
+            self.biass.append(1 + self.biasd * y)
 
     def plot(self):
-        try:
-            mkdir("./out")
-        except FileExistsError:
-            pass
-
         out = f"./out/{self.__class__.__name__}"
+
+        title = "Norepinepherine Concentration vs Neuron Activity in " + self.pretty
+        logging.info("Plotting " + title)
         plt.figure()
         plt.plot(self.x, self.y)
 
         plt.xlabel("Norepinephrine concentration (nM)")
         plt.ylabel("Activity (%)")
-        plt.title("Norepinepherine Concentration vs Neuron Activity in " +
-                  self.pretty)
+        plt.title(title)
 
         plt.vlines(self.ki, 0, 1, linestyles="dashed")
         plt.text(1.1 * self.ki, 0.1, "Affinity")
@@ -80,73 +77,39 @@ class Alpha(object):
         plt.gca().yaxis.set_major_formatter(mtick.PercentFormatter())
 
         plt.draw()
-        plt.savefig(f"{out}-norep-activity.png", dpi=1000)
+        plt.savefig(f"{out}-norep-activity.png")
 
         #######################################################################
 
+        title = "Concentration vs Gain Scalar in" + self.pretty
+        logging.info("Plotting " + title)
         plt.figure()
-        plt.plot(self.x, self.gain)
+        plt.plot(self.x, self.gains)
 
         plt.xlabel("Norepinephrine concentration (nM)")
         plt.ylabel("Gain")
-        plt.title(f"Concentration vs Gain in {self.pretty}")
+        plt.title(title)
+
+        plt.xscale("log")
 
         plt.draw()
-        plt.savefig(f"{out}-concentration-gain.png", dpi=1000)
+        plt.savefig(f"{out}-concentration-gain.png")
 
         #######################################################################
 
+        title = "Concentration vs Bias scalar in " + self.pretty
+        logging.info("Plotting " + title)
         plt.figure()
-        plt.plot(self.x, self.bias)
+        plt.plot(self.x, self.biass)
+
+        plt.xscale("log")
 
         plt.xlabel("Norepinephrine concentration (nM)")
         plt.ylabel("Bias")
-        plt.title("Concentration vs Bias in " + self.pretty)
+        plt.title(title)
 
         plt.draw()
-        plt.savefig(f"{out}-concentration-bias.png", dpi=1000)
-
-    def simulate(self):
-        for i in range(steps):
-            print(f"{self.__class__.__name__}, gain: {fmt_num(self.gain[i])}, bias: {fmt_num(self.bias[i])}")
-            with nengo.Network() as net:
-                # Nodes
-                time_node = nengo.Node(output=time_function)
-                noise_wm_node = nengo.Node(output=noise_bias_function)
-                noise_decision_node = nengo.Node(
-                    output=noise_decision_function)
-
-                # Ensembles
-                wm = nengo.Ensemble(neurons_wm, 2)
-                wm.gain = np.full(wm.n_neurons, self.gain[i])
-                wm.bias = np.full(wm.n_neurons, self.bias[i])
-                decision = nengo.Ensemble(neurons_decide, 2)
-                inputs = nengo.Ensemble(neurons_inputs, 2)
-                output = nengo.Ensemble(neurons_decide, 1)
-
-                # Connections
-                nengo.Connection(time_node, inputs[1], synapse=None)
-                nengo.Connection(inputs, wm, synapse=tau_wm,
-                                 function=inputs_function)
-                wm_recurrent = nengo.Connection(wm, wm, synapse=tau_wm,
-                                                function=wm_recurrent_function)
-                nengo.Connection(noise_wm_node, wm.neurons, synapse=tau_wm,
-                                 transform=np.ones((neurons_wm, 1)) * tau_wm)
-                wm_to_decision = nengo.Connection(
-                    wm[0], decision[0], synapse=tau)
-                nengo.Connection(noise_decision_node,
-                                 decision[1], synapse=None)
-                nengo.Connection(decision, output, function=decision_function)
-
-                # Probes
-                # probes_wm = nengo.Probe(wm[0], synapse=0.01, sample_every=dt_sample)
-                # probes_spikes = nengo.Probe(wm.neurons, 'spikes',
-                #                           sample_every=dt_sample)
-                # probe_output = nengo.Probe(output, synapse=None, same_every=dt_sample)
-
-                # Run simulation
-            with nengo.Simulator(net, dt=dt, progress_bar=False) as sim:
-                sim.run(t_cue + t_delay)
+        plt.savefig(f"{out}-concentration-bias.png")
 
 
 class Alpha1(Alpha):
@@ -158,8 +121,8 @@ class Alpha1(Alpha):
         self.ki = 330
         self.offset = 5.895
         self.pretty = "α1 Receptor"
-        self.gaind = -0.04
-        self.biasd = -0.02
+        self.gaind = -0.02
+        self.biasd = 0.04
         super().__init__()
 
 
@@ -172,21 +135,76 @@ class Alpha2(Alpha):
         self.ki = 56
         self.offset = 1
         self.pretty = "α2 Receptor"
-        self.gaind = -0.1
-        self.biasd = 0.1
+        self.gaind = 0.1
+        self.biasd = -0.1
         super().__init__()
 
 
+def simulate(a1, a2):
+    for i in range(steps):
+        gain = a1.gains[i] + a2.gains[i] - 1
+        bias = a1.biass[i] + a2.biass[i] - 1
+        logging.info(f"gain: {fmt_num(gain)}, bias: {fmt_num(bias)}")
+        with nengo.Network() as net:
+            # Nodes
+            time_node = nengo.Node(output=time_function)
+            noise_wm_node = nengo.Node(output=noise_bias_function)
+            noise_decision_node = nengo.Node(
+                output=noise_decision_function)
+
+            # Ensembles
+            wm = nengo.Ensemble(neurons_wm, 2)
+            wm.gain = np.full(wm.n_neurons, gain)
+            wm.bias = np.full(wm.n_neurons, bias)
+            decision = nengo.Ensemble(neurons_decide, 2)
+            inputs = nengo.Ensemble(neurons_inputs, 2)
+            output = nengo.Ensemble(neurons_decide, 1)
+
+            # Connections
+            nengo.Connection(time_node, inputs[1], synapse=None)
+            nengo.Connection(inputs, wm, synapse=tau_wm,
+                             function=inputs_function)
+            wm_recurrent = nengo.Connection(wm, wm, synapse=tau_wm)
+            nengo.Connection(noise_wm_node, wm.neurons, synapse=tau_wm,
+                             transform=np.ones((neurons_wm, 1)) * tau_wm)
+            wm_to_decision = nengo.Connection(
+                wm[0], decision[0], synapse=tau)
+            nengo.Connection(noise_decision_node,
+                             decision[1], synapse=None)
+            nengo.Connection(decision, output, function=decision_function)
+
+            # Probes
+            probes_wm = nengo.Probe(wm[0], synapse=0.01)
+            probe_output = nengo.Probe(output, synapse=None)
+
+        # Run simulation
+        with nengo.Simulator(net, dt=dt, progress_bar=False) as sim:
+            sim.run(t_cue + t_delay)
+
+
 def main():
+    logging.info("Initializing simulation")
     plt.style.use("ggplot")  # Nice looking and familiar style
+
     a1 = Alpha1()
-    # a1.plot()
-    a1.simulate()
+    a1.plot()
 
     a2 = Alpha2()
-    # a2.plot()
-    a2.simulate()
+    a2.plot()
+
+    simulate(a1, a2)
 
 
 if __name__ == "__main__":
+    try:
+        mkdir("./out")
+    except FileExistsError:
+        pass
+
+    logging.basicConfig(filename=f"out/{datetime.now().isoformat()}.log",
+                        level=logging.DEBUG)
+    console = logging.StreamHandler()
+    console.setLevel(logging.INFO)
+    logging.getLogger("").addHandler(console)
+
     main()