branch: models_igr: graph display + record selection

neuronpp/utils/network_status_graph.py

@@ -26,6 +26,7 @@ def __init__(self, cells, weight_name='w', plot_fixed_weight_edges=True):
 
         self.correct_position = (0.1, 0.1)
 
+        self.population_sizes = dict()
         self.population_names = self._get_population_names()
         self.edges = self._get_edges(weight_name)
 
@@ -69,6 +70,10 @@ def update_spikes(self, sim_time):
 
     def _get_edges(self, weight_name):
         result = []
+        # compute the number of cells in each layer
+        for c in self.cells:
+            pop_name = c.name.split('[')[0]
+            self.population_sizes[pop_name] = self.population_sizes.get(pop_name, 0) + 1
         for c in self.cells:
             soma = c.filter_secs('soma')
             if c._spike_detector is None:
@@ -81,11 +86,13 @@ def _get_edges(self, weight_name):
             except ValueError:
                 x_pos = self.population_names.index(pop_name)
 
-            y_pos = int(split_name[-1][:-1])
+            # shift down the layer by half its size to vertically center graph
+            y_pos = int(split_name[-1][:-1]) - self.population_sizes[pop_name] // 2
 
             if 'inh' in c.name:
                 self.colors.append('red')
-                y_pos -= 5
+                # todo center vertically by half width of the hid layer
+                y_pos -= 6
             elif 'hid' in c.name:
                 self.colors.append('blue')
             else:
@@ -110,7 +117,8 @@ def _find_target(self, c, x_pos, y_pos, weight_name):
                 except ValueError:
                     x_trg = self.population_names.index(pop_name)
 
-                y_trg = int(split_target[-1][:-1])
+                # center veritically
+                y_trg = int(split_target[-1][:-1]) - self.population_sizes[pop_name] // 2
 
                 weight = None
                 if self.plot_constant_connections and hasattr(nc.target.hoc, weight_name):
@@ -125,7 +133,8 @@ def _find_weights(c, weight_name):
         for nc in c.ncs:
             if "SpikeDetector" in nc.name:
                 continue
-            elif isinstance(nc.source, Seg) and isinstance(nc.target, PointProcess) and hasattr(nc.target.hoc, weight_name):
+            elif isinstance(nc.source, Seg) and isinstance(nc.target, PointProcess) and hasattr(nc.target.hoc,
+                                                                                                weight_name):
                 weight = getattr(nc.target.hoc, weight_name)
                 targets.append(weight)
         return targets

neuronpp/utils/record.py

@@ -1,11 +1,9 @@
-from nrn import Segment, Section
 from collections import defaultdict
 
+import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 from neuron import h
-import matplotlib.pyplot as plt
-
 from neuronpp.core.hocwrappers.seg import Seg
 
 
@@ -39,7 +37,8 @@ def __init__(self, elements, variables='v'):
                 try:
                     s = getattr(elem.hoc, "_ref_%s" % var)
                 except AttributeError:
-                    raise AttributeError("there is no attribute of %s. Maybe you forgot to append loc param for sections?" % var)
+                    raise AttributeError(
+                        "there is no attribute of %s. Maybe you forgot to append loc param for sections?" % var)
 
                 rec = h.Vector().record(s)
                 self.recs[var].append((name, rec))
@@ -84,16 +83,19 @@ def _plot_static(self, position=None):
             for i, (name, rec) in enumerate(section_recs):
                 rec_np = rec.as_numpy()
                 if np.max(np.isnan(rec_np)):
-                    raise ValueError("Vector recorded for variable: '%s' and segment: '%s' contains nan values." % (var_name, name))
+                    raise ValueError(
+                        "Vector recorded for variable: '%s' and segment: '%s' contains nan values." % (var_name, name))
 
                 if position is not "merge":
-                    ax = self._get_subplot(fig=fig, var_name=var_name, position=position, row_len=len(section_recs), index=i + 1)
+                    ax = self._get_subplot(fig=fig, var_name=var_name, position=position, row_len=len(section_recs),
+                                           index=i + 1)
                 ax.set_title("Variable: %s" % var_name)
                 ax.plot(self.t, rec, label=name)
                 ax.set(xlabel='t (ms)', ylabel=var_name)
                 ax.legend()
 
-    def _plot_animate(self, steps=10000, y_lim=None, position=None):
+    def _plot_animate(self, steps=10000, y_lim=None, position=None, true_class=None, pred_class=None, stepsize=None,
+                      dt=None, show_true_predicted=True, true_labels=None):
         """
         Call each time you want to redraw plot.
 
@@ -106,6 +108,12 @@ def _plot_animate(self, steps=10000, y_lim=None, position=None):
             * position=(3,3) -> if you have 9 neurons and want to display 'v' on 3x3 matrix
             * position='merge' -> it will display all figures on the same graph.
             * position=None -> Default, each neuron has separated  axis (row) on the figure.
+        :param true_class: list of true class labels in this window
+        :param pred_class: list of predicted class labels in window
+        :param stepsize: agent readout time step
+        :param dt: agent integration time step
+        :param show_true_predicted: whther to print true/predicted class' marks on the plot
+        :param true_labels: list of true labels for the consecutive plots
         :return:
         """
         create_fig = False
@@ -116,7 +124,7 @@ def _plot_animate(self, steps=10000, y_lim=None, position=None):
             fig = self.figs[var_name]
             if fig is None:
                 create_fig = True
-                fig = plt.figure()
+                fig = plt.figure(figsize=(16.5, 5.5))
                 fig.canvas.draw()
                 self.figs[var_name] = fig
 
@@ -125,15 +133,15 @@ def _plot_animate(self, steps=10000, y_lim=None, position=None):
                     if position == 'merge':
                         ax = fig.add_subplot(1, 1, 1)
                     else:
-                        ax = self._get_subplot(fig=fig, var_name=var_name, position=position, row_len=len(section_recs), index=i + 1)
+                        ax = self._get_subplot(fig=fig, var_name=var_name, position=position, row_len=len(section_recs),
+                                               index=i + 1)
 
                     if y_lim:
                         ax.set_ylim(y_lim[0], y_lim[1])
                     line, = ax.plot([], lw=1)
-                    ax.set_title("Variable: %s" % var_name)
-                    ax.set_ylabel(var_name)
+                    # ax.set_title("Variable: %s" % var_name)
+                    ax.set_ylabel("{}_{}".format(var_name, i))
                     ax.set_xlabel("t (ms)")
-                    ax.legend()
 
                     self.axs[var_name].append((ax, line))
 
@@ -143,17 +151,66 @@ def _plot_animate(self, steps=10000, y_lim=None, position=None):
 
                 ax.set_xlim(t.min(), t.max())
                 if y_lim is None:
-                    ax.set_ylim(r.min()-(np.abs(r.min()*0.05)), r.max()+(np.abs(r.max()*0.05)))
+                    y_limits = (r.min() - (np.abs(r.min() * 0.05)), r.max() + (np.abs(r.max() * 0.05)))
+                    ax.set_ylim(y_limits)
 
                 # update data
                 line.set_data(t, r)
-
+                if show_true_predicted:
+                    # info draw triangles for true and predicted classes
+                    if true_labels is not None:
+                        true_x, pred_x = self._true_predicted_class_marks(label=true_labels[i], true_class=true_class,
+                                                                          pred_class=pred_class, t=t, r=r,
+                                                                          stepsize=stepsize, dt=dt)
+                    else:
+                        raise ValueError("True_labels parameter need to be given if show_true_prediction is True")
+                    if y_lim is None:
+                        true_y = [y_limits[0] + np.abs(y_limits[0]) * 0.09] * len(true_x)
+                        pred_y = [y_limits[1] - np.abs(y_limits[1] * 0.11)] * len(pred_x)
+                    else:
+                        true_y = [y_lim[0]] * len(true_x)
+                        pred_y = [y_lim[1]] * len(pred_x)
+                    ax.scatter(true_x, true_y, c="orange", marker="^", alpha=0.95, label="true")
+                    ax.scatter(pred_x, pred_y, c="magenta", marker="v", alpha=0.95, label="predicted")
+                    if create_fig and i == 0:
+                        # draw legend only the first time and only on the uppermost graph
+                        ax.legend()
+
+            # info join plots by removing labels and ticks from subplots that are not on the edge
+            if create_fig:
+                for key in self.axs:
+                    for ax in self.axs[key]:
+                        ax[0].label_outer()
+                fig.subplots_adjust(left=0.09, bottom=0.075, right=0.99, top=0.98, wspace=None, hspace=0.00)
             fig.canvas.draw()
             fig.canvas.flush_events()
 
         if create_fig:
             plt.show(block=False)
 
+    def _true_predicted_class_marks(self, label, true_class, pred_class, t, stepsize, dt):
+        """
+        find and return lists of time steps for true and predicted labels
+        :param label: the label id (an int)
+        :param true_class: list of true classes for the whole time region
+        :param pred_class: list of predicted labels (class ids) for the whole time region
+        :param t: the region time steps
+        :param stepsize: original agent stepsize; class selections are 2 * stepsize / dt
+        :param dt: integration step
+        :return: lists of marks for true_x: true classes, pred_x: predicted classes
+        """
+        n = len(true_class)
+        x = t[::int(2 * stepsize / dt)][-n:]
+        true_x = []
+        pred_x = []
+        for k in range(n):
+            # get the true classes for the current label
+            if true_class[k] == label:
+                true_x.append(x[k])
+            if pred_class[k] == label:
+                pred_x.append(x[k])
+        return true_x, pred_x
+
     def to_csv(self, filename):
         cols = ['time']
         data = [self.t.as_numpy().tolist()]