From c53222a96ab03d683ccd6deac67d4e4121a22f4c Mon Sep 17 00:00:00 2001 From: ackurth-nc Date: Thu, 22 Sep 2022 05:43:32 -0700 Subject: [PATCH] Address remarks from review --- tutorials/end_to_end/convert_params.py | 342 +++++++++++------- ...rial02_excitatory_inhibitory_network.ipynb | 277 +++++++------- 2 files changed, 351 insertions(+), 268 deletions(-) diff --git a/tutorials/end_to_end/convert_params.py b/tutorials/end_to_end/convert_params.py index 7bad45312..50f8b793e 100644 --- a/tutorials/end_to_end/convert_params.py +++ b/tutorials/end_to_end/convert_params.py @@ -8,10 +8,183 @@ from scipy.special import erf +# Define auxiliary functions for weight conversion. +def _mean_input(num_neurons_exc, gamma, g_factor, weight, rate, bias): + ''' + Calculate mean input to single neuron given mean excitatory weight. + + Parameters + ---------- + num_neurons_exc : int + Number of excitatory neurons + gamma : float + Ratio of inhibitory and excitatory neurons + g_factor : float + Factor controlling inhibition-excitation balance + weight : float + Mean excitatory weight + rate : float + Mean rate of neurons in network + bias : float + Bias provided to neurons + + Returns + ------- + mean_inp : float + Mean input received by each neuron + ''' + mean_inp = num_neurons_exc * (1 - gamma * g_factor) * weight * rate + bias + + return mean_inp + +def _std_input(num_neurons_exc, gamma, g_factor, weight, rate): + ''' + Calculate mean input to single neuron given mean excitatory weight. + + Parameters + ---------- + num_neurons_exc : int + Number of excitatory neurons + gamma : float + Ratio of inhibitory and excitatory neurons + g_factor : float + Factor controlling inhibition-excitation balance + weight : float + Mean excitatory weight + rate : float + Mean rate of neurons in network + + Returns + ------- + mean_inp : float + Mean input received by each neuron + ''' + return num_neurons_exc * (1 + gamma * g_factor**2) * weight ** 2 * rate + +def _y_th(vth, mean, std, dv_exc, du_exc): + ''' + Effective threshold, see Grytskyy et al. 2013. + + Parameters + ---------- + vth : float + Threshold of LIF neuron + mean : float + Mean input of neuron + std : float + Standard deviation of input + dv_exc : float + Integration constant of voltage variable + du_exc : float + Integration constant of current variable + + Returns + ------- + yth : float + Effective threshold of neuron in network + ''' + y_th = (vth - mean) / std + y_th += np.sqrt(2) * np.abs(zetac(0.5)) * np.sqrt(dv_exc / du_exc) / 2 + + return y_th + +def _y_r(mean, std, dv_exc, du_exc): + ''' + Effective reset, see Grytskyy et al. 2013. + + Parameters + ---------- + vth : float + Threshold of LIF neuron + mean : float + Mean input of neuron + std : float + Standard deviation of input + dv_exc : float + Integration constant of voltage variable + du_exc : float + Integration constant of current variable + + Returns + ------- + yr : float + Effective reset of neuron in network + ''' + y_r = (- 1 * mean) / std + y_r += np.sqrt(2) * np.abs(zetac(0.5)) * np.sqrt(dv_exc / du_exc) / 2 + + return y_r + +def f(y): + ''' + Derivative of transfer function of LIF neuron at given argument. + ''' + return np.exp(y ** 2) * (1 + erf(y)) + +def _alpha(vth, mean, std, dv_exc, du_exc): + ''' + Auxiliary variable describing contribution of weights for weight + mapping given network state, see Grytskyy et al. 2013. + + Parameters + ---------- + vth : float + Threshold of LIF neuron + mean : float + Mean input of neuron + std : float + Standard deviation of input + dv_exc : float + Integration constant of voltage variable + du_exc : float + Integration constant of current variable + + Returns + ------- + val : float + Contribution of weight + ''' + val = np.sqrt(np.pi) * (mean * dv_exc * 0.01) ** 2 + val *= 1 / std + val *= (f(_y_th(vth, mean, std, dv_exc, du_exc)) + - f(_y_r(mean, std, dv_exc, du_exc))) + + return val + +def _beta(vth, mean, std, dv_exc, du_exc): + ''' + Auxiliary variable describing contribution of square of weights for + weight mapping given network state, see Grytskyy et al. 2013. + + Parameters + ---------- + vth : float + Threshold of LIF neuron + mean : float + Mean input of neuron + std : float + Standard deviation of input + dv_exc : float + Integration constant of voltage variable + du_exc : float + Integration constant of current variable + + Returns + ------- + val : float + Contribution of square of weights + ''' + val = np.sqrt(np.pi) * (mean * dv_exc * 0.01) ** 2 + val *= 1/(2 * std ** 2) + val *= (f(_y_th(vth, mean, std, dv_exc, du_exc)) * (vth - mean) / std + - f(_y_r(mean, std, dv_exc, du_exc)) * (-1 * mean) / std) + + return val + def convert_rate_to_lif_params(**kwargs): '''Convert rate parameters to LIF parameters. The mapping is based on A unified view on weakly correlated recurrent - network, Grytskyy et al. 2013 + network, Grytskyy et al. 2013. Parameters ---------- @@ -23,7 +196,7 @@ def convert_rate_to_lif_params(**kwargs): lif_network_dict : dict Parameter dictionary for LIF network ''' - # Fetch rate parameters + # Fetch rate parameters. shape_exc = kwargs['shape_exc'] dr_exc = kwargs['dr_exc'] bias_exc = kwargs['bias_exc'] @@ -40,25 +213,25 @@ def convert_rate_to_lif_params(**kwargs): num_neurons_exc = shape_exc num_neurons_inh = shape_inh - # ratio of excitatory to inhibitory neurons + # Ratio of excitatory to inhibitory neurons. gamma = float(num_neurons_exc) / float(num_neurons_inh) - # assert that network is balanced + # Assert that network is balanced. assert gamma * g_factor > 1, "Network not balanced, increase g_factor" - # Set timescales of neurons - dv_exc = 1 * dr_exc # dynamics of membrane potential as fast as rate - du_exc = 7 * dr_exc # dynamics of current 7 times as fast as rate + # Set timescales of neurons. + dv_exc = 1 * dr_exc # Dynamics of membrane potential as fast as rate. + du_exc = 7 * dr_exc # Dynamics of current 7 times as fast as rate. - dv_inh = 1 * dr_inh # dynamics of membrane potential as fast as rate - du_inh = 7 * dr_inh # dynamics of current 7 times as fast as rate + dv_inh = 1 * dr_inh # Dynamics of membrane potential as fast as rate. + du_inh = 7 * dr_inh # Dynamics of current 7 times as fast as rate. - # set threshold to default value + # Set threshold to default value. vth_exc = 1 vth_inh = 1 - # Set biases - # First calculate relative biases for rate model + # Set biases. + # First calculate relative biases for rate model. if bias_exc >= bias_inh: rel_exc_inh_bias = bias_exc / bias_inh rel_inh_exc_bias = 1 @@ -68,152 +241,41 @@ def convert_rate_to_lif_params(**kwargs): # We then determine the the bias for the LIF network. # We have to be careful not the reduce the bias since a too small bias - # results in inactivity + # results in inactivity. bias_exc = 5 * vth_exc * dv_exc * rel_exc_inh_bias bias_inh = 5 * vth_inh * dv_inh * rel_inh_exc_bias - # Get the mean excitatory weight + # Get the mean excitatory weight. exc_weights = weights[:, :num_neurons_exc] mean_exc_weight = np.mean(exc_weights) - # Perform weight conversion + # Perform weight conversion. # First determine approximately stationary firing rate in inhibition # dominated regime. # See Dynamic of Sparsely Connected Networks of Excitatory and # Inhibitory Spiking Neurons, Brunel, 2000. - # We simplify the calculation by working with average acitivites + # We simplify the calculation by working with average acitivites. bias = (bias_exc / dv_exc + bias_inh / dv_inh) / 2 rate = (bias - vth_exc) / (gamma * g_factor - 1) - # Define auxiliary functions for weight conversion - def _mean_input(weight): - ''' - Calculate mean input to single neuron given mean excitatory weight - ''' - return num_neurons_exc * (1 - gamma * g_factor) * weight * rate + bias - - def _std_input(weight): - ''' - Calculate mean input to single neuron given mean excitatory weight - ''' - return num_neurons_exc * (1 + gamma * g_factor**2) * weight ** 2 * rate - - def _y_th(vth, mean, std): - ''' - Effective threshold, see Grytskyy et al. - - Parameters - ---------- - vth : float - Threshold of LIF neuron - mean : float - Mean input of neuron - std : float - Standard deviation of input - - Returns - ------- - yth : float - Effective threshold of neuron in network - ''' - y_th = (vth - mean) / std - y_th += np.sqrt(2) * np.abs(zetac(0.5)) * np.sqrt(dv_exc / du_exc) / 2 - - return y_th - - def _y_r(mean, std): - ''' - Effective reset, Grytskyy et al. - - Parameters - ---------- - vth : float - Threshold of LIF neuron - mean : float - Mean input of neuron - std : float - Standard deviation of input - - Returns - ------- - yr : float - Effective reset of neuron in network - ''' - y_r = (- 1 * mean) / std - y_r += np.sqrt(2) * np.abs(zetac(0.5)) * np.sqrt(dv_exc / du_exc) / 2 - - return y_r - - # Derivative of transfer function of LIF neuron - f = lambda y: np.exp(y**2) * (1 + erf(y)) - - def _alpha(vth, mean, std): - ''' - Auxiliary variable describing contribution of weights for weight - mapping given network state. - See Grytskyy et al. - - Parameters - ---------- - vth : float - Threshold of LIF neuron - mean : float - Mean input of neuron - std : float - Standard deviation of input - - Returns - ------- - val : float - Contribution of weight - ''' - val = np.sqrt(np.pi) * (mean * dv_exc * 0.01) ** 2 - val *= 1 / std - val *= f(_y_th(vth, mean, std)) - f(_y_r(mean, std)) - - return val - - def _beta(vth, mean, std): - ''' - Auxiliary variable describing contribution of square of weights for - weight mapping given network state. - See Grytskyy et al. - - Parameters - ---------- - vth : float - Threshold of LIF neuron - mean : float - Mean input of neuron - std : float - Standard deviation of input - - Returns - ------- - val : float - Contribution of square of weights - ''' - val = np.sqrt(np.pi) * (mean * dv_exc * 0.01) ** 2 - val *= 1/(2 * std ** 2) - val *= (f(_y_th(vth, mean, std)) * (vth - mean) / std - - f(_y_r(mean, std)) * (-1 * mean) / std) - - return val - # Function describing mapping of rate to LIF weights problem about - # finding a zero + # finding a zero. def func(weight): ''' Adapted from Grytskyy et al.. ''' - alpha = _alpha(vth_exc, _mean_input(weight), _std_input(weight)) - beta = _beta(vth_exc, _mean_input(weight), _std_input(weight)) + mean_inp = _mean_input(num_neurons_exc, gamma, + g_factor, weight, rate, bias) + std_inp = _std_input(num_neurons_exc, gamma, + g_factor, weight, rate) + alpha = _alpha(vth_exc, mean_inp, std_inp, dv_exc, du_inh) + beta = _beta(vth_exc, mean_inp, std_inp, dv_exc, du_inh) return mean_exc_weight - alpha * weight - beta * weight**2 # Solve for weights of LIF network retaining correlation structure of - # rate network + # rate network. with warnings.catch_warnings(): warnings.filterwarnings('ignore', '', RuntimeWarning) try: @@ -225,18 +287,18 @@ def func(weight): # induced by strong weights. Choose 1 as scaling factor. weight_scale = 1 - # Scale weights + # Scale weights. if weight_scale > 0: weights *= weight_scale else: print('Weigh scaling factor not positive: No weight scaling possible') - # Scale weights with integration time step + # Scale weights with integration time step. weights[:, :num_neurons_exc] *= du_exc weights[:, num_neurons_exc:] *= du_inh - # Single neuron paramters - # Bias_mant is set to make the neuron spike + # Single neuron paramters. + # Bias_mant is set to make the neuron spike. lif_params_exc = { "shape_exc": num_neurons_exc, "vth_exc": vth_exc, @@ -251,7 +313,7 @@ def func(weight): "dv_inh": dv_inh, "bias_mant_inh": bias_inh} - # Parameters Paramters for E/I network + # Parameters Paramters for E/I network/ network_params_lif = {} network_params_lif.update(lif_params_exc) diff --git a/tutorials/end_to_end/tutorial02_excitatory_inhibitory_network.ipynb b/tutorials/end_to_end/tutorial02_excitatory_inhibitory_network.ipynb index 1d7c8320c..301dc0fe7 100644 --- a/tutorials/end_to_end/tutorial02_excitatory_inhibitory_network.ipynb +++ b/tutorials/end_to_end/tutorial02_excitatory_inhibitory_network.ipynb @@ -20,10 +20,7 @@ "metadata": {}, "source": [ "**Motivation**: In this tutorial, we will build a Lava Process for a neural networks of excitatory and inhibitory neurons (E/I network).
\n", - "E/I networks are a fundamental example of neural networks mimicking the structure of the brain and exhibiting rich dynamical behavior.
\n", - "**The first aim** of this tutorial is to investigate some of their dynamical properties for different single neuron dynamics as well as dynamical states. Especially the transition to a critical state which can be harnessed in reservoir computing will be of interest as well as self-balancing and the role of the recurrently generated activations in this.
\n", - "**Secondly**, since the description above is agnostic towards the single neuron model used for implementing the network, we will see how to use multiple ProcessModels for the E/I network Process implementing similar, but different dynamical behaviors.
\n", - "**Finally** we will see how to convert the parameters of the LIF E/I Network from a floating-point to a fixed-point representation given certain precision constraints and run a bit-accurate ProcessModels E/I network with the respective ProcessModels provided by Lava." + "E/I networks are a fundamental example of neural networks mimicking the structure of the brain and exhibiting rich dynamical behavior.
" ] }, { @@ -35,16 +32,16 @@ "- have the [Lava framework installed](../in_depth/tutorial01_installing_lava.ipynb \"Tutorial on Installing Lava\")\n", "- are familiar with the [Process concept in Lava](../in_depth/tutorial02_processes.ipynb \"Tutorial on Processes\")\n", "\n", - "#### This tutorial gives a bird's-eye view of\n", + "#### This tutorial gives a high level view of\n", "- how to implement simple E/I Network Lava Process\n", "- hot to define and select multiple ProcessModels for the E/I Network, based on Rate and [Leaky Integrate-and-Fire (LIF)](https://github.com/lava-nc/lava/tree/main/src/lava/proc/lif \"Lava's LIF neuron\") neurons\n", "- how to use tags to chose between different ProcessModels when running the Process\n", "- the principle adjustments needed to run bit-accurate ProcessModels\n", "\n", "#### E/I Network\n", - "From bird's-eye view, an E/I network is a recurrently coupled network of neurons consisting of two populations of neurons.
\n", + "From bird's-eye view, an E/I network is a recurrently coupled network of neurons.
\n", "Since positive couplings (excitatory synapses) alone lead to a positive feedback loop ultimately causing a divergence in the activity of the network, appropriate negative couplings (inhibitory synapses) need to be introduced to counterbalance this effect.
\n", - "Additionally, we here require a separation of the neurons into two classes (the populations): Neurons can either be inhibitory or excitatory.
\n", + "We here require a separation of the neurons into two populations: Neurons can either be inhibitory or excitatory.
\n", "Such networks exhibit different dynamical states. By introducing a control parameter, we can switch between these states and simultaneously alter the response properties of the network.
\n", "In the notebook below, we introduce two incarnations of E/I networks with different single neuron models: Rate and LIF neurons.
\n", "By providing a utility function that maps the weights from rate to LIF networks, we can retain hallmark properties of the dynamic in both networks.\n", @@ -129,37 +126,7 @@ "\n", " # Ports for receiving input or sending output.\n", " self.inport = InPort(shape=(full_shape,))\n", - " self.outport = OutPort(shape=(full_shape,))\n", - " \n", - " @staticmethod \n", - " def generate_gaussian_weights(q_factor, g_factor, shape_exc, full_shape):\n", - " '''Generate connectivity drawn from a Gaussian distribution with mean 0\n", - " and std of q_factor ** 2 * sqrt(full_shape).\n", - " W[i, j] is connection weight from pre-synaptic neuron j to post-synaptic neuron i.\n", - " '''\n", - " # Set scaled standard deviation of recurrent weights.\n", - " J = q_factor**2 * 6 / full_shape\n", - " weights = np.random.normal(0, J,\n", - " (full_shape, full_shape))\n", - " \n", - " # Impose constraint that neurons can **either** be excitatory (positive weight)\n", - " # **or** inhibitory (negative weight),\n", - " exc_conns = np.full(weights.shape, True)\n", - " exc_conns[:, shape_exc:] = False # Set entries for inhibitory neurons to False.\n", - " inh_conns = np.invert(exc_conns)\n", - " \n", - " mask_pos_weights = (weights > 0)\n", - " mask_neg_weights = (weights < 0)\n", - "\n", - " # Set negative weights of exciatory neurons to zero and similarly for inhibitory neurons.\n", - " # This induce sparsity in the connectivity.\n", - " weights[mask_neg_weights * exc_conns] = 0\n", - " weights[mask_pos_weights * inh_conns] = 0\n", - "\n", - " # We finally need to increase the inhibitory weights by a factor to control balance.\n", - " weights[inh_conns] *= g_factor\n", - " \n", - " return weights" + " self.outport = OutPort(shape=(full_shape,))" ] }, { @@ -313,19 +280,17 @@ "source": [ "#### Defining the parameters for the network\n", "Next, we need to constrain the network with the needed parameters.
\n", - "First, we define the dimensionality of the network. Since - given a suitable parameter regime - the neurons in an E/I network tend decouple, we identify the dimensionality with the total number of neurons in the network.
\n", - "Moreover, we need to set the parameters for the excitatory and inhibitory neurons\n", - "For the recurrent connectivity we employ the generation method defined in the class.
\n", - "The weights must *balance* the network, i.e. the average recurrent input to a neuron must be less or equal than $0$. Otherwise, the network activity is caught up in a positive feedback loop and diverges.
\n", + "First, we define the dimensionality of the network which we identify with the total number of neurons as well as the single neuron parameters.
\n", "We here follow the common choice that the ratio between the number of excitatory and inhibitory neurons equals $4$ and that the connection probability between two arbitrary neurons is identical.
\n", - "Since the connection probability between two arbitrary neurons is equal, we therefore need to increase the strength of the inhibitory weights, the `g_factor`, to at least $4$. We choose $4.5$ to unambiguously place the network in the inhibition dominated regime.
\n", + "The recurrent weights must *balance* the network, i.e. the average recurrent input to a neuron must be less or equal than $0$.
\n", + "This implies that we need to increase the strength of the inhibitory weights, the `g_factor`, to at least $4$. We choose $4.5$ to unambiguously place the network in the inhibition dominated regime.
\n", "Finally, we set a parameter that controls the response properties of the network by scaling up the recurrent weights, the `q_factor`." ] }, { "cell_type": "code", "execution_count": 6, - "id": "7cadbf55", + "id": "474077c3", "metadata": {}, "outputs": [], "source": [ @@ -363,8 +328,72 @@ "network_params_balanced.update(params_exc)\n", "network_params_balanced.update(params_inh)\n", "network_params_balanced['g_factor'] = g_factor\n", - "network_params_balanced['q_factor'] = q_factor\n", - "network_params_balanced['weights'] = EINetwork.generate_gaussian_weights(q_factor, g_factor, num_neurons_exc, dim)" + "network_params_balanced['q_factor'] = q_factor" + ] + }, + { + "cell_type": "markdown", + "id": "05712d4e", + "metadata": {}, + "source": [ + "Finally, we have to set the weights given the above constraints. To this end, we sample the weights randomly from a Gaussian distribution with zero-mean and a standard deviation that scales with the ```q_factor```." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7cadbf55", + "metadata": {}, + "outputs": [], + "source": [ + "def generate_gaussian_weights(dim, num_neurons_exc, q_factor, g_factor):\n", + " '''Generate connectivity drawn from a Gaussian distribution with mean 0\n", + " and std of (2 * q_factor) ** 2 / dim.\n", + " If a excitatory neuron has a negative weight, we set it to 0 and similarly adapt\n", + " positive weights for inhibitory neurons.\n", + " W[i, j] is connection weight from pre-synaptic neuron j to post-synaptic neuron i.\n", + " \n", + " Paramerters\n", + " -----------\n", + " dim : int\n", + " Dimensionality of network\n", + " num_neurons_exc : int\n", + " Number of excitatory neurons\n", + " q_factor : float\n", + " Factor determining response properties of network\n", + " g_factor : float\n", + " Factor determining inhibition-excitation balance\n", + " '''\n", + " # Set scaled standard deviation of recurrent weights.\n", + " #J = q_factor**2 * 6 / full_shape\n", + " J = (2 * q_factor)**2 / dim\n", + " weights = np.random.normal(0, J,\n", + " (dim, dim))\n", + " \n", + " # Impose constraint that neurons can **either** be excitatory (positive weight)\n", + " # **or** inhibitory (negative weight).\n", + " exc_conns = np.full(weights.shape, True)\n", + " exc_conns[:, num_neurons_exc:] = False # Set entries for inhibitory neurons to False.\n", + " inh_conns = np.invert(exc_conns)\n", + " \n", + " mask_pos_weights = (weights > 0)\n", + " mask_neg_weights = (weights < 0)\n", + "\n", + " # Set negative weights of exciatory neurons to zero and similarly for inhibitory neurons.\n", + " # This induce sparsity in the connectivity.\n", + " weights[mask_neg_weights * exc_conns] = 0\n", + " weights[mask_pos_weights * inh_conns] = 0\n", + "\n", + " # We finally need to increase the inhibitory weights by a factor to control balance.\n", + " weights[inh_conns] *= g_factor\n", + " \n", + " return weights\n", + "\n", + "# Generate weights\n", + "network_params_balanced['weights'] = generate_gaussian_weights(dim,\n", + " num_neurons_exc,\n", + " network_params_balanced['q_factor'],\n", + " network_params_balanced['g_factor'])" ] }, { @@ -377,7 +406,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "e609ac8c", "metadata": {}, "outputs": [], @@ -411,18 +440,18 @@ "metadata": {}, "source": [ "#### Visualizing the activity\n", - "We first have a look at the trajectories of the neurons in the network." + "We first have a look at the activity of the network by plotting the numerical value of the state of the first $50$ neurons." ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "f4cdddfe", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -437,7 +466,7 @@ "plt.figure(figsize=(7,5))\n", "plt.xlabel('Time Step')\n", "plt.ylabel('State value')\n", - "plt.plot(states_balanced)\n", + "plt.plot(states_balanced[:, :50])\n", "plt.show()" ] }, @@ -446,9 +475,10 @@ "id": "70982ef0", "metadata": {}, "source": [ - "We observe that after an initial period the network settles in a fixed point. As it turns out, this fixed point is stable: After a small perturbation, the network returns to this state.
\n", + "We observe that after an initial period the network settles in a fixed point.
\n", + "As it turns out, this is a global stable fixed point of the network dynamics: If we applied a small perturbation, the network would return to the stable state.
\n", "Such a network is unfit for performing meaningful computations, the dynamics is low-dimensional and rather poor.
\n", - "To better understand this, we have to apply an additional analysis." + "To better understand this, we apply an additional analysis." ] }, { @@ -457,8 +487,8 @@ "metadata": {}, "source": [ "#### Further analysis\n", - "A characteristic quantity of the network activity is the *auto-correlation function* $c(\\tau)$.
\n", - "With this function, one can assess the *memory* of the network.
\n", + "We introduce the *auto-correlation function* $c(\\tau)$.
\n", + "With this function, one can assess the *memory* of the network as well as the richness of the dynamics.
\n", "Denoting the (temporally averaged) network activity by $a$, the *auto-covariance function* is the variance (here denoted $\\mathrm{Cov}(\\cdot, \\cdot)$) of $a$ with a time shifted version of itself:\n", "\\begin{equation}\n", " c(\\tau) = \\mathrm{Cov}(a(t), a(t+\\tau))\n", @@ -466,12 +496,12 @@ "This means for positive $\\tau$ the value of the auto-covariance function gives a measure for the similarity of the network state $a(t)$ and $a(t+\\tau)$.
\n", "By comparing $c(\\tau)$ with $c(0)$, we may assess the *memory* a network has of its previous states after $\\tau$ time steps.
\n", "Note that the auto-covariance function is not normalised!
\n", - "Due to this, we may derive further information about the network state: If $c(0)$ is small (in our case $<< 1$), the network acitivty does not exhibit a huge temporal variety across neurons and thus the networks dynamics are unable to perform meaningful computations." + "Due to this, we may derive further information about the network state: If $c(0)$ is small (in our case $<< 1$), the network activity is not rich and does not exhibit a large temporal variety across neurons. Thus the networks is unable to perform meaningful computations." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "67d93c4f", "metadata": {}, "outputs": [], @@ -514,13 +544,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "830d4529", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbAAAAFICAYAAAAxj6teAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAA3kUlEQVR4nO3dd3gVZd7G8e8vjUDoEGrovbeANHWtgAXEiqtiQbHX1VXXdS3ruu666toVFRV1wYprV5CiYoGEXkNChwChBgjpz/tHDvtGpATIZE65P9d1LsKcnMzteOBm5jzzPOacQ0REJNRE+R1ARETkaKjAREQkJKnAREQkJKnAREQkJKnAREQkJKnAREQkJAVdgZnZWDPbbGYLy+nnFZnZ3MDjk/L4mSIi4j8LtvvAzOwEYDcwzjnXuRx+3m7nXNVjTyYiIsEk6M7AnHPfAdtKbzOzVmb2lZmlmtn3Ztbep3giIhIkgq7ADmIMcLNzrhdwJ/DCEbw23sxSzOxnMzvHk3QiIlLhYvwOcDhmVhXoD7xvZvs2Vwo8dy7w8AFett45NyjwdTPn3HozawlMMbMFzrkMr3OLiIi3gr7AKDlL3OGc677/E865j4CPDvVi59z6wK8rzGwa0ANQgYmIhLigv4TonMsGVprZBQBWoltZXmtmtcxs39laXWAAsNizsCIiUmGCrsDMbDzwE9DOzNaZ2SjgEmCUmc0DFgHDyvjjOgApgddNBR5zzqnARETCQNANoxcRESmLoDsDExERKQsVmIiIhKSgGoVYt25d17x5c79jiIhIkEhNTd3inEs80HNBVWDNmzcnJSXF7xgiIhIkzGz1wZ7TJUQREQlJKjAREQlJKjAREQlJKjAREQlJKjAREQlJKjAREQlJKjAREQlJKjAREQlJKjAREQlJKjCRIDN/3Q7W79jrdwyRoKcCEwkiO3MKGDHmZ24dP8fvKCJBTwUmEkTe/mU1OflFpKzeTurqbX7HEQlqKjCRIJFbUMTrM1bRt2VtalaJ5eXpK/yOJBLUVGAiQWLinPVs2Z3HLae0YWTfZkxasomMrN1+xxIJWiowkSBQVOx45bsVdGlcg34t6zCyf3PioqN49XudhYkcjApMJAhMWryJFVv2cO2JLTEz6latxPm9kvgwdT2bd+X6HU8kKKnARHzmnOPl7zJoUrsygzs1+N/2q49vSUFxMW/+uMq/cCJBTAUm4rOU1duZs2YH1xzfkpjo//8j2aJuAoM7NeCtn1azO6/Qx4QiwUkFJuKzl6evoFaVWC7o1eQ3z40+oSXZuYW8O2utD8lEgpsKTMRH6Zt3MXnJJkb2a07luOjfPN+jaS36tKjNa9+voKCo2IeEIsFLBSbiozHfrSA+NoqR/Zod9HuuO7ElG3bm8tn8DRWYTCT4qcBEfLIpO5eP52zggl5NqFO10kG/73dt69GmXlVenr4C51wFJhQJbiowEZ+8PmMVhcXFXH18i0N+X1SUMfqElizduIvvlm+poHQiwc+zAjOzdmY2t9Qj28xu82p/IqFkV24B7/yymiGdG9KsTsJhv39Y98bUr16JMd9lVEA6kdDgWYE555Y557o757oDvYAcYKJX+xMJJRNmrmVXbiGjT2hZpu+Pi4niqgEtmJG+lQXrdnqcTiQ0VNQlxFOADOfc6gran0jQyi8s5rUfVtK3ZW26NalZ5tddfFxTqlaK4SWdhYkAFVdgI4DxFbQvkaA2cc46Nmbnct2JrY7oddXjY7m0bzO+WJDJCk3yK+J9gZlZHDAUeP8gz482sxQzS8nKyvI6joivCouKeXFaBl0a1+DEtolH/PpRA1sQFx3FS9N1FiZSEWdgQ4DZzrlNB3rSOTfGOZfsnEtOTDzyP9AioeSLhRtZtTWHG09qhZkd8esTq1ViRO8mfDR7Pet37PUgoUjoqIgCuxhdPhShuNjxwtR0WteryukdGxz+BQcxOnDp8ZXvtNSKRDZPC8zMEoDTgI+83I9IKJiydDNLN+7iht+1IirqyM++9mlcszLDezRm/Mw1bNmdV44JRUKLpwXmnNvjnKvjnNO4X4lozjmem5pOUq3KnN2t0TH/vOt+14r8opLRjCKRSjNxiFSAnzK2MnftDq47sRWx0cf+x65VYlXO6NKQt35azc69BeWQUCT0qMBEKsBzU9OpV61kleXycsPvWrE7r5BxWvBSIpQKTMRjs9ds58eMrVxzfEviY3+7ZMrR6tSoBie3r8fYGSvJydeClxJ5VGAiHnthagY1q8Ty++OalvvPvvGkVmzPKWD8TC14KZFHBSbioaUbs5m8ZBNX9m9BQqWYcv/5vZrVpm/L2oz5LoO8wqJy//kiwUwFJuKhF6ZmkBAXzeX9D75g5bG68aTWbMrO46PZ6z3bh0gwUoGJeGTVlj18Nn8Dl/ZrRs0qcZ7tZ2DrunRLqsGL0zIoLCr2bD8iwUYFJuKRl6ZnEBMdxaiBh16w8liZGTec1Jo123L4fEGmp/sSCSYqMBEPbNixlw9nr+Oi5CbUqxbv+f5O61CftvWr8tyUdIqLnef7EwkGKjARD7wwLR0omTGjIkRFGTed3Iblm3fz5cKNFbJPEb+pwETK2YYde3l31louSG5C45qVK2y/Z3ZpSKvEBJ7+Nk1nYRIRVGAi5ezFaSVrdd1QQWdf+0RHGbec0oa0Tbv5apHOwiT8qcBEylHmzpKzr/N7NSGpVpUK3/9ZXRuVnIVNXq6zMAl7KjCRcvTitAyKnePGkyr27GuffWdhyzbt4mudhUmYU4GJlJPMnXuZMHMtFyQn+XL2tc9ZXRvRMjGBp7/VWZiENxWYSDl5KXD2dcPvWvuaIzrKuOXkNizduItvFussTMKXCkykHGzcmcv4WWs5v1cSTWr7d/a1z9ndGtGybgJPf6v7wiR8qcBEysFL0zMoLnbceJK/Z1/7REcZN5/SmiWZ2XyzeJPfcUQ8oQITOUabsnP5z8w1nNczOM6+9jm7ayNa1E3gmW+X45zOwiT8qMBEjtGL04Lr7GufmOgobj65NYt1FiZhSgUmcgw2Z+cyfuYazu3ZmKZ1gufsa5+h3RrRvE4Vnp6sszAJPyowkWPw4vQMCosdN53Uxu8oB1RyFtaGxZnZTNJZmIQZFZjIUdqcnct/flnDuT2C8+xrn2HdA2dh+ixMwowKTOQoPTc1naJix00nB9dnX/vbdxa2aEM2X2mmegkjKjCRo7B2Ww7jZ67hwt5NaFYnwe84h3VOj8a0SkzgiUlpFOm+MAkTnhaYmdU0sw/MbKmZLTGzfl7uT6SiPDtlOWbGzUF+9rVPdJRxx2ntSN+8m0/mrfc7jki58PoM7GngK+dce6AbsMTj/Yl4bkXWbj6cvZ5Lj2tGwxoVt97XsRrSuQEdG1bnqUnLKSgq9juOyDHzrMDMrAZwAvAagHMu3zm3w6v9iVSUpyYvp1JMFDf4NOP80YqKMu4c1JY123J4P2Wd33FEjpmXZ2AtgCzgdTObY2avmlnwf1ggcghLMrP5dN4GrhzQnLpVK/kd54id1K4ePZvW5Nkpy8ktKPI7jsgx8bLAYoCewIvOuR7AHuCe/b/JzEabWYqZpWRlZXkYR+TYPfFNGtXiYxh9fGidfe1jZtw5qB2ZO3N555c1fscROSZeFtg6YJ1z7pfA7z+gpNB+xTk3xjmX7JxLTkxM9DCOyLGZs2Y7k5ds4toTWlKjSqzfcY5a/1Z1GdC6Di9MTWdPXqHfcUSOmmcF5pzbCKw1s3aBTacAi73an4jXnpyURu2EOK4c0MLvKMfsD6e3Y+uefN74cZXfUUSOmtejEG8G3jGz+UB34FGP9yfiiZ9XbOX75Vu44XetSKgU43ecY9azaS1OaV+Pl6dnsHNvgd9xRI6KpwXmnJsbuDzY1Tl3jnNuu5f7E/GCc45/fb2M+tUrcWnfZn7HKTd3nN6W7NxCXv1+hd9RRI6KZuIQOYxpaVmkrN7OzSe3IT422u845aZToxqc2bUhY39YydbdeX7HETliKjCRQ3DO8cQ3y2hSuzIXJjfxO065u/3UtuwtKOLFaRl+RxE5YiowkUP4cuFGFq7P5rZT2hIXE35/XFrXq8q5PZMY9/NqNuzY63cckSMSfn8iRcpJQVExj3+9jLb1q3JOj8Z+x/HMbae2AQf/npzmdxSRI6ICEzmId2etZeWWPdw9uD3RUeZ3HM8k1arCyH7N+CB1HWmbdvkdR6TMVGAiB7Anr5B/T15On+a1Obl9Pb/jeO7Gk1qTUCmGf361zO8oImWmAhM5gNd+WMmW3Xncc0Z7zML37GufWglxXP+7VkxesolZq7b5HUekTFRgIvvZujuPl6dnMLhTA3o2reV3nApzZf8W1K9eib9/sQTntOilBD8VmMh+np2STm5hMXcNbnf4bw4jleOiuf3Utsxes4NvFm/yO47IYanAREpZszWHd35ZzYXJTWiVWNXvOBXu/F5JtEpM4J9fLaVQi15KkFOBiZTyr2+WERMVxe2ntvE7ii9ioqO4e3B7MrL28H6qFr2U4KYCEwlYuH4nn8zbwKiBLahXPd7vOL45rWN9ejWrxVOT0tibr0UvJXipwEQC/vHVUmpViWX0iS39juIrM+PeIe3ZvCuPsTNW+h1H5KBUYCLA98uz+H75Fm4+uQ3V40N3scrykty8Nqd1rM9L0zLYtiff7zgiB6QCk4hXXOx47MulJNWqzCV9m/odJ2j8cVA79uQX8vzUdL+jiByQCkwi3qfzN7BoQzZ3nt6OSjHhs1zKsWpTvxoX9GrCWz+tZu22HL/jiPyGCkwiWm5BEf/4cimdG1dnaLdGfscJOref1pboKOOxr5b6HUXkN1RgEtFe+2ElG3bm8uczOxIVxhP2Hq0GNeK59sSWfD4/k9TVmmJKgosKTCLW5l25vDA1nUGd6tO3ZR2/4wSt0Se0pH71Sjz82RKKizXFlAQPFZhErKcmpZFfVMw9Qzr4HSWoVYmL4a5B7Zm3dgefzt/gdxyR/1GBSURakpnNu7PWMrJfc1rUTfA7TtA7t0djOjeuzj+/WkZugW5uluCgApOI45zjb58voXrlWG45OTKnjDpSUVHGfWd0ZP2Ovbz2g25uluCgApOIM21ZFj+kb+HWU9pQo4puWi6rfq3qcHrH+rwwNZ2sXXl+xxFRgUlkKSgq5pHPF9OybgKX9m3md5yQc+8ZHcgrLObJSVq5WfynApOIMn7mGjKy9nDvGR2Ijdbb/0i1qJvAyH7NeXfWWpZkZvsdRyKcp3+CzWyVmS0ws7lmluLlvkQOZ+feAp6alEa/lnU4tUM9v+OErFtOaU21+Fj+9rlWbhZ/VcQ/QU9yznV3ziVXwL5EDur5qens2FvAfWd2wEw3LR+tmlXiuPWUNvyQvoVpy7L8jiMRTNdQJCKs3rqHN2as4vyeSXRuXMPvOCHv0r7NaFE3gUc+X0yBVm4Wn3hdYA74xsxSzWy0x/sSOahHv1hCdJRx56B2fkcJC3ExUdw7pGTl5rd/Xu13HIlQXhfYQOdcT2AIcKOZnbD/N5jZaDNLMbOUrCxdjpDy9/3yLL5etImbTm5N/Qheabm8ndaxPse3qctTk9LYulvD6qXieVpgzrn1gV83AxOBPgf4njHOuWTnXHJiYqKXcSQCFRQV89Cni2lWpwqjBrbwO05YMTMeOLsjOflF/OubNL/jSATyrMDMLMHMqu37GjgdWOjV/kQOZNxPq0nfvJv7z+xIfKzW+ipvretV4/L+zZkwaw0L1+/0O45EGC/PwOoDP5jZPGAm8Llz7isP9yfyK1t25/HvSWmc2DaRUzRs3jO3ntqGOglxPPDJIg2rlwrlWYE551Y457oFHp2cc3/zal8iB/L4V8vYW1DEX87uqGHzHqoeH8sfB7UndfV2/jtXs9VLxdEweglL89bu4L3UtVw1sAWtEqv6HSfsnd8ria5JNXj0iyXsziv0O45ECBWYhJ3iYseDny6iTkIlbj65td9xIkJUlPHg0E5s3pXH81PT/Y4jEUIFJmFn4pz1zFmzg3uGtKdavGabryg9m9bivJ5JvPb9SlZu2eN3HIkAKjAJK7tyC3jsq6X0aFqTc3s09jtOxLl7SDviYqJ45LPFfkeRCKACk7Dy3JR0tuzO48GzOxEVpYEbFa1etXhuPaUN3y7dzNSlm/2OI2FOBSZhIyNrN2NnrOTCXk3o1qSm33Ei1uX9m9MyMYGHP1tMfqHmSRTvqMAkLDjnePCTRcTHRHPXYM136Ke4mCgeOLsTK7fs4dUfVvgdR8KYCkzCwhcLNvL98i384fS21K1aye84Ee/EtokM6lSfZ75dzrrtOX7HkTBV5gIzs4FmdmXg60Qz08RyEhR25xXy8GeL6NSoOpf1a+53HAl44OxORJnx0Kca0CHeKFOBmdkDwN3AvYFNscDbXoUSORL/npTG5l15PHJOZ6I1cCNoNKpZmVtPacOkxZuYvHiT33EkDJX1DGw4MBTYA+Cc2wBU8yqUSFktyczm9R9XcXGfpvRoWsvvOLKfqwa2oG39qjz46SL25hf5HUfCTFkLLN+VzNLp4H+zy4v4qrjY8eePF1Kzcix3D2rvdxw5gNjoKB45pwvrtu/luanL/Y4jYaasBfaemb0M1DSza4DJwCvexRI5vA9S15G6ejv3ntGBGlU040aw6tOiNuf1TGLMdytI37zb7zgSRspUYM65fwEfAB8C7YC/OOee9TKYyKFs35PP379cQp/mtTmvp2bcCHb3ntGeKnEx3P/xQi25IuWmrIM4WgDfO+fucs7dSck6X809TSZyCP/4aim7cgv56zmdtVRKCKhbtRJ/HNyOn1Zs5ZN5WnJFykdZLyG+D5S+pb4osE2kwqWu3s6EWWsZNbAF7RpoLFGoGNG7Kd2a1OSvny0hO7fA7zgSBspaYDHOufx9vwl8HedNJJGDKywq5s8fL6RhjXhuOaWN33HkCERHGY8M68y2PXk8+U2a33EkDJS1wLLMbOi+35jZMGCLN5FEDu7Nn1azJDObB87uSEKlGL/jyBHqklSDy/o2Y9xPq1iwbqffcSTElbXArgP+ZGZrzGwtJTc1X+tdLJHfWr9jL098s4yT2iUyqFMDv+PIUfrDoHbUqVqJeyfOp7BIk/3K0SvrKMQM51xfoCPQwTnX3zmnZVelwjjnuP/jhQAauBHiqsfH8tDQTixcn83rM1b5HUdCWJmuwZhZJeA8oDkQs+8vD+fcw54lEynls/mZTFm6mfvP6khSrSp+x5FjNKRzA07tUJ8nJ6UxuHMDmtTW/1M5cmW9hPhfYBhQSMl0UvseIp7bkZPPQ58uomtSDa7o39zvOFIOzIy/ntOJKIM/TVyge8PkqJT1U/Ak59xgT5OIHMSjXyxhe04B4646TpP1hpGGNSrzx8HteeCTRXw8dz3DeyT5HUlCTFnPwH40sy6eJhE5gB8ztvBeyjquOb4lHRtV9zuOlLNL+zajR9OSe8O27ck//AtESilrgQ0EUs1smZnNN7MFZjbfy2AiuQVF/OmjBTSrU4XbTtU9X+EoOsp47Nyu7Mot4JHPtW6YHJmyXkIccrQ7MLNoIAVY75w762h/jkSeZ6csZ9XWHN65+jjiY6P9jiMeadegGted2Ipnp6QzvEdjjm+T6HckCRFlHUa/2jm3GthLyZIq/1tapQxuBZYcXTyJVEsys3l5+grO75XEgNZ1/Y4jHrvxpNa0rJvAfRMXat0wKbOyTuY71MyWAyuB6cAq4MsyvC4JOBN49RgySoQpKnbc89ECalSO5b4zOvgdRypAfGw0j57bhTXbcvj3ZE0zJWVT1s/A/gr0BdKccy2AU4Cfy/C6fwN/5NcTAf+KmY02sxQzS8nKyipjHAln435axby1O/jL2R2plaApNyNF35Z1GNG7Ca/+sJKF6zXNlBxeWQuswDm3FYgysyjn3FQg+VAvMLOzgM3OudRDfZ9zboxzLtk5l5yYqGvfkW7tthwe/3oZJ7ZNZGi3Rn7HkQp275AO1E6I448fzKdA00zJYZS1wHaYWVXgO+AdM3uaw9/IPAAYamargAnAyWb29lEnlbBXXOz44wfziTLj7+d20XRREahGlVgeOaczizOzeXFaht9xJMiVtcCGUTKA43bgKyADOPtQL3DO3eucS3LONQdGAFOcc5ceQ1YJc/+ZuYafVmzlvjM70KhmZb/jiE8GdWrA0G6NeHbKcpZkZvsdR4JYWUch7nHOFTnnCp1zbzrnnglcUhQpF+u25/D3L5YwsHVdRvRu4ncc8dmDQztRo3Isd30wT5cS5aAOWWBm9kPg111mll3qscvMyvxPI+fcNN0DJgfjnOOeDxcA8Nh5unQoUDshjr8O68zC9dmM+W6F33EkSB2ywJxzAwO/VnPOVS/1qOac07w+Ui4mzFrLD+lbuPeMDpppXv5nSJeGnNm1IU9PXk7apl1+x5EgdNhLiGYWbWZLKyKMRJ71O/byt8+X0L9VHX7fp6nfcSTIPDy0E1XjY7jr/Xla/FJ+47AF5pwrApaZmf52kXLlnOPejxZQ7Bz/OK8rUZppXvZTp2olHh7WiXnrdvLK9yv9jiNBpqxzIdYCFpnZTEoNn3fODfUklUSE91PW8V1aFg8P66QFDeWgzuzSkM87Z/LUpDRO61iP1vWq+R1JgkRZC+x+T1NIxMncuZe/fr6Y41rU5tLjmvkdR4KYmfHwsM78vGI6d74/nw+v76914QQo+zD66Qd6eB1OwpNzjj99tICComL+eb4uHcrhJVarxINDOzF37Q5e/V6jEqVEWSfz7Wtms8xst5nlm1nRkQyjFyltwqy1TF2Wxd2D29OsToLfcSREDO3WiEGd6vPEN2ks26hRiVL2mTieAy4GlgOVgauB570KJeFr9dY9/PWzxQxoXYfL+zX3O46EEDPj0eFdqF45htvenUt+oUYlRrqyFhjOuXQgOjAjx+vAYO9iSTgqKnb84b15REcZj5/fTZcO5YjVqVqJv5/blSWZ2Tz9rZZdiXRlLbAcM4sD5prZP83s9iN4rQgAY75bQcrq7Tw8rJPmOpSjdlrH+lyYnMSL0zJIXb3N7zjio7KW0GWB772JkmH0TYDzvAol4WdJZjZPTlrGkM4NOKd7Y7/jSIi7/6yONKpZmTvem8eevEK/44hPylpgvQDnnMt2zj3knLsjcElR5LDyCou4/d251Kgcx9+Ga65DOXbV4mN54oJurNmWw6NfLPE7jvikrAV2NpBmZm+Z2VlmVtb7x0R4clIaSzfu4p/nd6G2VliWcnJcyzpcc3xL3vllDVOXbfY7jvigrPeBXQm0Bt6nZDRihpm96mUwCQ+zVm1jzHcruLhPE05uX9/vOBJm7jitLe3qV+PuD+azfU++33Gkgh3JKMQC4EtKVldOBc7xKJOEid15hdzx3lya1KrCn8/s6HccCUPxsdE8eVE3tufk8+f/LsQ553ckqUBlvZF5iJm9Qcl9YOcBrwINPMwlYeCRzxazbvtenriwGwmVdNVZvNGpUQ1uO7Utn8/P5JN5G/yOIxWorGdgI4GPgXbOuSucc1845zT0Rw7qq4UbmTBrLdee0IrezWv7HUfC3LUntKRXs1r8+eOFrN2W43ccqSBl/QzsYuAn4LTAII563saSUJa5cy/3fDSfLo1rcMdpbf2OIxEgJjqKf1/UHefg9nfnau2wCFHWS4gXADOBC4ALgV/M7Hwvg0loKip23PHuPPILi3l6RHfiYnS/u1SMJrWr8LfhnUlZvZ3npuoun0hQ1g8m/gz0ds5tBjCzRGAy8IFXwSQ0vfxdBj+t2Mo/z+9Ky8SqfseRCDOse2OmL8vimW+XM7B1XZJ1+TqslfWfx1H7yitg6xG8ViLE3LU7ePKbNM7s2pALeiX5HUci1EPDOpFUqwq3TpjLzr0FfscRD5W1hL4ys6/N7AozuwL4HPjCu1gSanbnFXLrhDnUrx7Po+dotg3xT7X4WJ4e0Z2N2bncN3GBhtaHsUMWmJm1NrMBzrm7gJeBroHHT8CYCsgnIeKB/y5i7bYcnrqoOzWqxPodRyJcj6a1uOO0tnw2P5MPZ6/3O4545HBnYP8GsgGccx8F5kC8A5gYeE6E/85dz4ez13HTyW3o00KfOUhwuO7EVhzXojZ/+e9CVm3Z43cc8cDhCqy+c27B/hsD25p7kkhCytptOfx54kJ6Nq3JLSe39juOyP9ERxlPXdSd2OgobpkwRwtghqHDFVjNQzx3yAWdzCzezGaa2TwzW2RmDx1xOglqhUXF3PbuXACeHtGDmGiN65Hg0qhmZR47twvz1+3kiUnL/I4j5exwf+OkmNk1+280s6spmQ/xUPKAk51z3YDuwGAz63tUKSUoPTEpjdTV23lkeGea1K7idxyRAxrSpSEX92nCy9NXME2z1oeVw90Hdhsw0cwu4f8LKxmIA4Yf6oWuZOjP7sBvYwMPDQcKE9OWbebFaRmM6N2EYVqgUoLcX87qxOzVO7jjvXl8ccvxNKgR73ckKQeHPANzzm1yzvUHHgJWBR4POef6Oec2Hu6Hm1m0mc0FNgOTnHO/HOB7RptZipmlZGVlHcV/glS0zJ17ueO9ebRvUI0Hh3byO47IYVWOi+b5S3qSW1DELePnaKqpMFHWuRCnOueeDTymlPWHO+eKnHPdgSSgj5l1PsD3jHHOJTvnkhMTE8scXPxRWFTMLePnkFtQxHO/70l8bLTfkUTKpHW9qvxteGdmrtrGU5PT/I4j5aBCPnV3zu0ApgKDK2J/4p2nJqcxa9V2Hh3ehdb1NFWUhJbhPZK4KLkJL0zLYHqarviEOs8KzMwSzaxm4OvKwGnAUq/2J96bnpbF81MzuCi5Cef00OdeEpoeHNqJtvWqcfu7c9m4M9fvOHIMvDwDawhMNbP5wCxKPgP7zMP9iYc27szl9nfn0q6+PveS0FbyeVgP9uYXccsEfR4WyjwrMOfcfOdcD+dcV+dcZ+fcw17tS7xVWFTMLRNKPvd6/pKeVI7T514S2lrXq8Yj53Rm5sptPP3tcr/jyFHSnadyWP+evJyZK7fxt+Gd9bmXhI3zeiVxYXISz01N5zt9HhaSVGBySFOXbeb5aelcmJzE8B5aIkXCy0NDO9OmXlVuf3cumTv3+h1HjpAKTA5q7bYcbptQ8rnXQ0N/cweESMirHBfNC5f0IregiOvfnk1eYZHfkeQIqMDkgHILirju7VSKnePly3rpcy8JW63rVeXxC7oxd+0OHvlsid9x5AiowOQ3nHP8+eOFLNqQzb8v6k6zOgl+RxLx1BldGjL6hJa89fNqPkxd53ccKSMVmPzG+Jlr+SB1Hbec3JpTOtT3O45IhfjjoHb0bVmbP01cwOIN2X7HkTJQgcmvzFu7gwc/WcQJbRO59dS2fscRqTAx0VE8e3FPalaJ5bq3U9mZU+B3JDkMFZj8z7Y9+Vz/diqJ1Srx9EXdiY4yvyOJVKjEapV44ZJegQmr51JcrAU0gpkKTAAoKnbcMn4OW/bk89KlvaiVEOd3JBFf9GpWi/vP6si3Szfz/NR0v+PIIajABIAnJy3jh/QtPDKsM12SavgdR8RXl/VtxvAejXlycpom/Q1iKjDhq4UbeX5qyeKUF/Zu4nccEd+ZGY8O70K7+tW4dcIc1mzN8TuSHIAKLMIt3ZjNHe/NpVuTmpqkV6SUynHRvHxZL5yDa8alsCev0O9Ish8VWATbviefa8alULVSDGMu66XFKUX206xOAs/9vgfLN+/SoI4gpAKLUIVFxdw0fjabdubx0mW9qF893u9IIkHp+DaJ/OmMDny9aBPPTtGgjmAS43cA8cejXyxlRvpW/nl+V3o2reV3HJGgNmpgCxZnZvPU5DTaN6zGoE4N/I4k6AwsIr2fspaxM1Zy5YDmXJisQRsih7NvUEe3pBrc8e5clm3c5XckQQUWcWav2c59ExcyoHUd7jujg99xREJGfGw0L1+WTEKlGK4eN4vte/L9jhTxVGARZFN2Lte9lUqDGvE8d3FPYqL1v1/kSDSoEc9Ll/Vi0848bho/m8KiYr8jRTT9DRYhcguKGP1WKrvzCnllZLJm2hA5Sj2b1uKR4Z2Zkb6VR79Y6neciKZBHBHAOcfdH85n3todvHRpL9o1qOZ3JJGQdmFyE5ZkZjN2xkra1K/KxX2a+h0pIukMLAI88206/527gTtPb8vgzho9JVIe7jujAye0TeT+jxcyI32L33EikgoszH0ybwNPTU7j3J6NufGk1n7HEQkbMdFRPPf7HrSom8D1b6eSvnm335EijgosjKWu3s6d78+jT/Pa/P3cLphpeRSR8lQ9PpaxV/QmLiaKUW/OYptGJlYoFViYWrsth9HjUmgYGDVVKUbTRIl4oUntKrx8WTKZO0tG+eYVFvkdKWJ4VmBm1sTMpprZYjNbZGa3erUv+bXs3AJGvTmLgqJixl7Rm9oacSjiqV7NavGvC7oxc9U27v1oAc5pzsSK4OUoxELgD8652WZWDUg1s0nOucUe7jPiFRYVc9N/5rAiaw/jrupDq8SqfkcSiQhDuzViZdYenpqcRqvEqvrMuQJ4VmDOuUwgM/D1LjNbAjQGVGAeevizxXyXlsVj53ahf+u6fscRiSi3nNKalVt28/jXy2heJ4Ezuzb0O1JYq5DPwMysOdAD+KUi9hepxv6wknE/rWb0CS0ZoftSRCqcmfHYeV3p1awWd7w3l9lrtvsdKax5XmBmVhX4ELjNOZd9gOdHm1mKmaVkZWnp7qP15YJM/vr5YgZ1qs/dg9v7HUckYsXHRjPmsl40qBHP1W+msHLLHr8jhS1PC8zMYikpr3eccx8d6Hucc2Occ8nOueTExEQv44StlFXbuPXdufRoUpOnR/QgOkrD5UX8VKdqJd68sg8AV7w+ky2783xOFJ68HIVowGvAEufck17tJ9Klb97NqDdTSKpZmVcv761VlUWCRPO6Cbx2eTKbsnMZ9cYscvIL/Y4Udrw8AxsAXAacbGZzA48zPNxfxNm8K5fLx84kNtp448o+Gi4vEmR6NK3Fsxf3ZMH6ndz8nzmavb6ceVZgzrkfnHPmnOvqnOseeHzh1f4ize68Qq56Yxbbc/IZe0Vvmtap4nckETmA0zrW56Fhnfl26Wbu/+8i3SNWjjQbfQgqKCrmxndmsyRzF6+OTKZrUk2/I4nIIVzWtxmZO/bywrQMkmpV1j1i5UQFFmKcc/zpowVMD9zrdVL7en5HEpEyuGtQOzJ35vL418toUD2e83ol+R0p5KnAQsxTk9J4P3Udt5zSRvd6iYQQM+Mf53Vl865c7v5wPnWrVeLEthp5fSw0mW8IeWPGSp6Zks6FyUncfmobv+OIyBGKi4nixUt70aZ+Na57K1U3Oh8jFViI+HjOeh78dDGnd6zPo8O1NIpIqKoeH8ubV/WmXvVKXPXGLNI27fI7UshSgYWAqcs2c+f78+jbsjbPXNyDmGj9bxMJZfWqxfP2qOOIi45i5GszWbc9x+9IIUl/Ewa51NXbuP7tVNo3rMYrI5N1o7JImGhSuwrjRvUhJ7+Qka9pto6joQILYks3ZnPl67NoWKMyb1zZh2rxsX5HEpFy1L5BdcZe0ZsNO/dyxesz2ZVb4HekkKICC1Jrt+Uw8rWZVI6L5q1RfahbtZLfkUTEA8nNa/PiJb1YmrmL0eNSyS3Qis5lpQILQlm78rj0tV/IKyzmrVHHkVRLs2yIhLOT2tfjXxd046cVW7llvKacKisVWJDZkZPPyLEz2Zydx+tX9qZt/Wp+RxKRCnBOj8Y8cHZHvlm8ibs/XEBxsaacOhzdyBxEduUWcPnYmWRs3s1rVyTTs2ktvyOJSAW6ckALsvcW8tTkNCrHRfHXYZ11y8whqMCCRE5+yeS8izZk89KlvTi+je7QF4lEt5zSmr0FRbw0PYP4mGjuO7ODSuwgVGBBILegiGvGpZC6ejvPXtyTUzvW9zuSiPjEzLh7cDtyC4p49YeVVImL5o7T2/kdKyipwHyWX1jMDe/MZkb6Vp64oBtndm3odyQR8ZmZ8ZezOrI3v4hnpqRTKTZaM9gfgArMR4VFxdw6YQ5Tlm7mb8M7a3ZqEfmfqCjj0XO7kFtYxONfL6NybDRXDWzhd6ygogLzSXGx464P5vPlwo3cf1ZHLjmumd+RRCTIREcZT1zQjbyCYh7+bDHxsdH8/jitQrGPhtH7oLjY8aeJC5g4Zz13DWrHKP2rSkQOIiY6imcu7sFJ7RK57+MFfJi6zu9IQUMFVsGKix33fbyACbPWctNJrXVdW0QOa98yLP1b1eHOD+bx0WyVGKjAKtS+8ho/s6S8/nB6W78jiUiIiI+N5tWRvenfqg5/eF8lBiqwCnOg8tK9HSJyJCrHqcRKU4FVgH2feam8RORY7V9ikfyZmArMY/vKa99nXiovETlWpUvszg8it8RUYB5SeYmIV1RiKjDPFBU77v1I5SUi3tm/xN5PWet3pArlWYGZ2Vgz22xmC73aR7AqLCrmD+/N5d0UlZeIeGtfiQ1oVZe7PpjP2z+v9jtShfHyDOwNYLCHPz8o5RcWc9N/5vDx3A3cNagddw5qp/ISEU9Vjovm1cuTObl9Pf788UJe/X6F35EqhGcF5pz7Dtjm1c8PRrkFRYx+K4WvFpVMD6WblEWkosTHRvPSpb04s0tDHvl8Cc98uxznwntRTM2FWE725BVy9Zsp/LxyK48O76L5ykSkwsXFRPH0iO5UioniyUlp5OQXcffg8L0K5HuBmdloYDRA06ah+Zd+dm4BV74+izlrtvPkhd0Y3kOzyouIP2Kio/jXBd2oHBfNS9MzyC0o4i9ndSQqKvxKzPcCc86NAcYAJCcnh9z57vY9+YwcO5OlG7N5/vc9GdJF63mJiL+iooxHzulM5dhoXv1hJXvzi3j03C5Eh1mJ+V5goWxTdi4jX5vJyq17GHNZMie1r+d3JBERoGRRzPvO7ECVuGiemZJOTkERT1zQjbiY8Ll7yrMCM7PxwO+Auma2DnjAOfeaV/uraKu27OHS135h+5583riiN/1b1/U7kojIr5gZd5zejiqVYnjsy6Vk7y3gxUt7UiUuPM5dPPuvcM5d7NXP9tvC9Tu54vWZFDsYP7ovXZNq+h1JROSgrjuxFTUrx/KniQu49NVfGHtFb2pWifM71jELn3PJCvLziq1cPOZn4qKjeO/afiovEQkJI/o05YVLerJwfTYXvvwTG3fm+h3pmKnAjsA3izYycuxM6teI54Pr+9O6XlW/I4mIlNngzg1548rerN++l/Ne/JEVWbv9jnRMVGBl9F7KWq57O5UODavz/rX9aFSzst+RRESOWP/WdZkwuh97C4q44KWfWLh+p9+RjpoKrAzGfJfBHz+Yz4DWdfnP1cdRKyH0rx2LSOTqklSDD67rR3xsNCPG/MyPGVv8jnRUVGCHUFzsePjTxTz6xVLO7NqQVy9PJqFSeIzeEZHI1jKxKh9c34+GNeK5YuwsPpm3we9IR0wFdhC5BUXc+J/ZjJ2xkisHNOeZET2oFBPtdywRkXLTsEZl3r+uH92b1OSW8XN4eXpGSM2fqAI7gO178rn01V/4cuFG/nxmBx44u1PY3cEuIgJQs0oc40b14cyuDfn7l0t58JNFFBWHRonpeth+1m7L4fLXZ7Ju+16e/31PzuyqqaFEJLzFx0bz7IgeNKoRzyvfryRzZy5Pj+hB5bjgvuqkM7BS5q/bwfAXZrB1dz5vjzpO5SUiESMqyrjvzI48cHZHJi3ZxO9f/Zlte/L9jnVIKrCAqUs3c9HLP1MpJpoPr+9Hnxa1/Y4kIlLhrhzQghcv6cniDdmc9+KPrN66x+9IB6UCA976eTVXj0uhVb0EJt7Yn9b1qvkdSUTEN4M7N+Q/1xzH9px8hr/wIymrgnNt4ogusMKiYh78ZBH3f7yQE9smMmF0P+pVi/c7loiI73o1q81H1/enenwMv3/lFz6es97vSL8RsQW2K7eAq8el8MaPqxg1sAWvjEymqu7xEhH5n5aJVZl4wwB6NK3Jbe/O5clvllEcRCMUI7LA1m7L4bwXf+T75Vv42/DO3H9WRw2TFxE5gFoJcbw16jguTE7imSnp3DxhDrkFRX7HAiJwGH3q6u2MHpdCflExb17Zh4FttI6XiMihxMVE8Y/zutIqsSqPfbWUddv38srIXr5/5BJRZ2D/nbuei1/5marxMUy8YYDKS0SkjMyMa09sxUuX9iJt4y7OeW4Gizdk+5opIgqsuNjxr6+XceuEuXRPqsnEGwZoKRQRkaMwqFMD3r+uH0XOcf5LP/LVwo2+ZQn7AsvOLeCacSk8NzWdi5Kb8NbVfait2eRFRI5a58Y1+OSmgbSpX43r3k7lyUlpvgzuCOsCy8jazTnPz2B6WhZ/HdaJx87rogl5RUTKQf3q8bw7ui/n90rimW+Xc+3bqezOK6zQDGFbYFOXbuac52awI6eAt68+jsv6NcdMIw1FRMpLfGw0j5/flQfO7siUpZsZ/vwMVm2puJk7wq7AnHM8PzWdq96cRZPaVfjkpgH0bVnH71giImHJzLhyQAveuqoPWbvzGPrcD0xPy6qQfYdVgeXkF3Lz+Dk8/vUyzuraiA+v709SrSp+xxIRCXv9W9fl05sG0qhmZa58fWaFrC0WVgU29oeVfL4gk3uGtOeZEd2DfikAEZFw0qR2FT66oT9DOpesLZa6erun+7NgWn0zOTnZpaSkHPXr8wuLmbduB72bayZ5ERG/OOf4acVW+rc69nttzSzVOZd8oOfC6gwsLiZK5SUi4jMzK5fyOhxPC8zMBpvZMjNLN7N7vNyXiIhEFs8KzMyigeeBIUBH4GIz6+jV/kREJLJ4eQbWB0h3zq1wzuUDE4BhHu5PREQiiJcF1hhYW+r36wLbREREjpnvgzjMbLSZpZhZSlZWxdz8JiIioc/LAlsPNCn1+6TAtl9xzo1xziU755ITExM9jCMiIuHEywKbBbQxsxZmFgeMAD7xcH8iIhJBPFuR2TlXaGY3AV8D0cBY59wir/YnIiKRxbMCA3DOfQF84eU+REQkMvk+iENERORoBNVciGaWBaw+xh9TF9hSDnEqUqhlVl7vhVrmUMsLoZc5UvM2c84dcIRfUBVYeTCzlINN/BisQi2z8nov1DKHWl4IvczK+1u6hCgiIiFJBSYiIiEpHAtsjN8BjkKoZVZe74Va5lDLC6GXWXn3E3afgYmISGQIxzMwERGJACFdYGZ2gZktMrNiM0ve77l7AwtpLjOzQaW2B8Uim2b2rpnNDTxWmdncwPbmZra31HMv+ZVxf2b2oJmtL5XtjFLPHfB4+8nMHjezpWY238wmmlnNwPZgPsZB8f48FDNrYmZTzWxx4M/frYHtB31/+C3wZ2xBIFdKYFttM5tkZssDv9byOyeAmbUrdQznmlm2md0WbMfXzMaa2WYzW1hq2wGPqZV4JvC+nm9mPcslhHMuZB9AB6AdMA1ILrW9IzAPqAS0ADIomc4qOvB1SyAu8D0dg+C/4wngL4GvmwML/c50kJwPAnceYPsBj3cQ5D0diAl8/Q/gH8F8jIP1/XmAnA2BnoGvqwFpgffAAd8fwfAAVgF199v2T+CewNf37Ht/BNMj8J7YCDQLtuMLnAD0LP1n6WDHFDgD+BIwoC/wS3lkCOkzMOfcEufcsgM8NQyY4JzLc86tBNIpWWAz6BbZNDMDLgTG+5njGB3sePvKOfeNc64w8NufKVkRIZgF3fvzQJxzmc652YGvdwFLCM21/oYBbwa+fhM4x78oB3UKkOGcO9YJHsqdc+47YNt+mw92TIcB41yJn4GaZtbwWDOEdIEdwsEW0wzGRTaPBzY555aX2tbCzOaY2XQzO96vYAdxU+ASwNhSl1yC8bju7ypK/gW4TzAe41A4jr9iZs2BHsAvgU0Hen8EAwd8Y2apZjY6sK2+cy4z8PVGoL4/0Q5pBL/+x22wHt99DnZMPXlvB32BmdlkM1t4gEfQ/ct0f2XMfjG/foNmAk2dcz2AO4D/mFn1IMn8ItAK6B7I+URF5TqYshxjM7sPKATeCWzy9RiHCzOrCnwI3OacyyYI3x+lDHTO9QSGADea2Qmln3Ql17mCaki2lSxDNRR4P7ApmI/vb1TEMfV0Nvry4Jw79ShedqjFNA+7yGZ5OVx2M4sBzgV6lXpNHpAX+DrVzDKAtkCKVzlLK+vxNrNXgM8Cvy3T4qVeKMMxvgI4Czgl8AfK92N8CL4dxyNlZrGUlNc7zrmPAJxzm0o9X/r94Tvn3PrAr5vNbCIll2s3mVlD51xm4HLWZl9D/tYQYPa+4xrMx7eUgx1TT97bQX8GdpQ+AUaYWSUzawG0AWYSfItsngosdc6t27fBzBLNLDrwdUtKsq/wKd+v7HfNejiwb/TRwY63r8xsMPBHYKhzLqfU9mA9xsH2/jygwOe2rwFLnHNPltp+sPeHr8wswcyq7fuaksE9Cyk5tpcHvu1y4L/+JDyoX12dCdbju5+DHdNPgJGB0Yh9gZ2lLjUePb9HshzjKJjhlFxLzQM2AV+Xeu4+SkZ0LQOGlNp+BiWjpjKA+3zO/wZw3X7bzgMWAXOB2cDZfh/nUtneAhYA8wNvyIaHO94+502n5Lr73MDjpRA4xkHz/jxExoGUXBqaX+rYnnGo94fPeVtSMqJzXuD/+32B7XWAb4HlwGSgtt9ZS2VOALYCNUptC6rjS0m5ZgIFgb+HRx3smFIy+vD5wPt6AaVGjR/LQzNxiIhISArXS4giIhLmVGAiIhKSVGAiIhKSVGAiIhKSVGAiIhKSVGAiPjCz3X5nEAl1KjAREQlJKjCRIGFmZ5vZL4FJhiebWf3A9sTA2kqLzOxVM1ttZnX9ziviNxWYSPD4AejrSiYZnkDJNFgADwBTnHOdgA+Apj7lEwkqQT+Zr0gESQLeDcx5FwesDGwfSMm0aTjnvjKz7T7lEwkqOgMTCR7PAs8557oA1wLxPucRCWoqMJHgUYP/X2Li8lLbZ1CyajdmdjoQjAsZilQ4TeYr4gMzKwY2lNr0JCUzdT8FbAemAL2dc78zs3qUzPxdH/iJkvXNmruSdc1EIpYKTCTImVkloMg5V2hm/YAXnXPdfY4l4jsN4hAJfk2B98wsCsgHrvE5j0hQ0BmYiIiEJA3iEBGRkKQCExGRkKQCExGRkKQCExGRkKQCExGRkKQCExGRkPR/e8TacXGKATYAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -549,8 +579,7 @@ "source": [ "As expected, there is covariance has its maximum at a time lag of $0$.
\n", "Examining the covariance function, we first note its values are small ($<<1$) implying low dimensional dynamics of the network.
\n", - "This fits our observation made above on the grounds of the display of the time-resolved activity.
\n", - "Moreover, we see a quick decay of the covariance with time steps implying a short memory of the network." + "This fits our observation made above on the grounds of the display of the time-resolved activity.
" ] }, { @@ -559,26 +588,28 @@ "metadata": {}, "source": [ "#### Controlling the network\n", - "We see that the states of the neurons quickly converge to a fixed point: the network does not exhibit any non-trivial behavior.
\n", - "The situation is even worse: One can show that this fixed point is the only fixed point of the system. This means, that after a perturbation of the network, the activity quickly relapses to the stable state. Hence, the network is incapable of performing any meaningful computation.
\n", + "We saw that the states of the neurons quickly converged to a globally stable fixed point.
\n", "The reason for this fixed point is, that the dampening part dominates the dynamical behavior - we need to increase the weights!
\n", "This we can achieve by increasing the `q_factor`." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "d12da1b0", "metadata": {}, "outputs": [], "source": [ "# Defining new, larger q_factor.\n", - "q_factor = np.sqrt(dim) / 3\n", + "q_factor = np.sqrt(dim / 6)\n", "\n", "# Changing the strenghts of the recurrent connections.\n", "network_params_critical = network_params_balanced.copy()\n", "network_params_critical['q_factor'] = q_factor\n", - "network_params_critical['weights'] = EINetwork.generate_gaussian_weights(q_factor, g_factor, num_neurons_exc, dim)\n", + "network_params_critical['weights'] = generate_gaussian_weights(dim,\n", + " num_neurons_exc,\n", + " network_params_critical['q_factor'],\n", + " network_params_critical['g_factor'])\n", "\n", "\n", "# Configurations for execution.\n", @@ -600,13 +631,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "a708a851", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -621,7 +652,7 @@ "plt.figure(figsize=(7,5))\n", "plt.xlabel('Time Step')\n", "plt.ylabel('State value')\n", - "plt.plot(states_critical)\n", + "plt.plot(states_critical[:, :50])\n", "plt.show()" ] }, @@ -630,13 +661,13 @@ "id": "57019969", "metadata": {}, "source": [ - "We find that after increasing the `q_factor`, the network shows a very different behavior. The stable fixed point is gone, instead we observe chaotical network dynamics:
\n", + "We find that after increasing the `q_factor`, the network shows a very different behavior. The stable fixed point is gone, instead we observe chaotic network dynamics:
\n", "The single neuron trajectories behave unpredictably and fluctuate widely, a small perturbation would lead to completely different state." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "36411f14", "metadata": {}, "outputs": [ @@ -689,7 +720,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "id": "6dc54408", "metadata": {}, "outputs": [], @@ -799,12 +830,13 @@ "id": "bd11399c", "metadata": {}, "source": [ - "#### Execution and Results" + "#### Execution and Results\n", + "In order to execute the LIF E/I network and the infrastructure to monitor the activity, we introduce a ```CustomRunConfig``` where we specify which ProcessModel we select for execution." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "37865890", "metadata": {}, "outputs": [], @@ -870,7 +902,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "abac04ec", "metadata": {}, "outputs": [], @@ -915,7 +947,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "id": "80307fe2", "metadata": {}, "outputs": [ @@ -951,7 +983,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "id": "45cd2071", "metadata": {}, "outputs": [], @@ -962,17 +994,17 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "id": "9036e802", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 19, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, @@ -1021,7 +1053,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "id": "78d091ea", "metadata": {}, "outputs": [], @@ -1054,7 +1086,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "id": "bd6aba46", "metadata": {}, "outputs": [ @@ -1081,13 +1113,13 @@ "metadata": {}, "source": [ "Here we see a qualitatively different network activity where the recurrent connections play a more dominant role:
\n", - "At seemingly random times, single neurons enter into active states of variable length.
\n", + "At seemingly random times, single neurons enter an active states of variable length.
\n", "Next, we have a look at the auto-covariance function of the network, especially in direct comparison with the respective function of the rate network." ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "id": "25e27549", "metadata": {}, "outputs": [], @@ -1099,7 +1131,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "id": "2c79c458", "metadata": {}, "outputs": [ @@ -1135,7 +1167,7 @@ "metadata": {}, "source": [ "We observe in the auto-covariance function of the LIF network a slowly decay, akin to the rate network.
\n", - "Even though both auto-covariance functions are not identical, they qualitatively match in that both network exhibit long-lasting temporal correlations and an activity at the edge of chaos.
\n", + "Even though both auto-covariance functions are not identical, they qualitatively match in that both networks exhibit long-lasting temporal correlations and an activity at the edge of chaos.
\n", "This implies that both network are in a suitable regime for computation, e.g. in the context of reservoir computing." ] }, @@ -1144,15 +1176,15 @@ "id": "c4278dc3", "metadata": {}, "source": [ - "#### Self balancing of the network\n", - "After having observed these two radically different dynamical states in the LIF network, we next turn to the question how they come about.
\n", - "Besides the external currents driving the neurons above threshold and causing the neurons to spike, the recurrently provided activations to the neuron determine the dynamics.
\n", - "We now examine these activations. Since we know the spike times of the individual neurons as well as the recurrent weights, we may calculate the excitatory, inhibitory as well as total activiation provided to each neuron in both networks." + "#### DIfferent recurrent activation regimes\n", + "After having observed these two radically different dynamical states also in the LIF network, we next turn to the question how they come about.
\n", + "The difference between both version of LIF E/I networks is in the recurrently provided activations.
\n", + "We now examine these activations by having look at the excitatory, inhibitory as well as total activation provided to each neuron in both networks." ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "id": "a9f2f809", "metadata": {}, "outputs": [], @@ -1205,7 +1237,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "id": "f199fbe1", "metadata": {}, "outputs": [], @@ -1233,13 +1265,13 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "id": "fb934b23-0bdd-41fe-a798-493e0fd75024", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAFgCAYAAACmDI9oAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAs3UlEQVR4nO3de7hdZXnv/e/PAEYBlUNEIGBSS7B4KOAS3RtboIhG2xp9axXqASptqqC2qLui9sVUa8FDBd0aLZ5AayV4LHXjIfJGqLuiRIzhJBgBSxAhBBSsggTv9485FgziOiVZ87DW/H6ua15rjjGeOeb9rMOdO898xjNSVUiSJEnqeFC/A5AkSZIGiQWyJEmS1GKBLEmSJLVYIEuSJEktFsiSJElSiwWyJEmS1GKBLG2hJL+X5Ooptj08yfpuxyRJvZTkiiSHT7Ht9Ume3t2IHvB++yb5eZI5U2i7IEkl2a4XsWnmsEBW3/U6eW6rqvqPqtp/Os6V5Kwk/zAd55Kk6TBWTk5yXJJvjG5X1eOq6us9D24Kquq/qmqnqrp3W8+VZFmSf5mOuDSzWCBLkiRJLRbIGlhJHpzkjCQ/bh5nJHlwc+zCJH/SPD+0+YjsD5vtI5OsGeN8c5P8MsnuzfabkmxK8rBm+61Jzmi997uS/FeSm5N8MMlDmmMPmDaR5OAk301yZ5JPJ1mx+ahwktcmuSXJTUn+vNm3FHgR8LfNx4H/3ux/fZIbm/NdneTI6f3OStK2aY8yJ3lIkrOT3J7kqiR/O8bUsgOTrE3ysyZHzh3nvD9K8qTm+Yua3P64Zvv4JF9onj8oyclJfphkY5Jzk+zaHHvAtIkkC5Nc1OTUryV5/xijwi9q8v2tSd7UvG4x8EbghU2O/l6z/7gk1zbnuy7Ji6bhW6oBY4GsQfYm4KnAgcDvAocAf9ccuxA4vHl+GHAt8Put7Qs3P1lV3QVc0hwfbfcj4NAxXncasKh5798G9gZO2fycSXYAPg+cBewKfAp43mbNHgU8vDnH8cD7k+xSVWcCnwTe0Xwc+MdJ9gdeCTy5qnYGnglcP9Y3R5IGxJuBBcBvAUcBLx6jzQuAxcBC4InAceOca6q5/VXAc5t9ewG3A+8f55z/Cnwb2A1YBrxkjDZPA/YHjgROSfI7VfVl4B+BFU2O/t0kOwLvBZ7V5Oj/CawZ5301g1kga5C9CHhLVd1SVRuAv+f+xHYh9xe6vw+cygML398okNuva0YWnkgn0R3WjGY8GbgoSYClwElVdVtV3UknSR49xvmeCmwHvLeq7qmqz9FJxG33NP24p6rOB35OJxGP5V7gwcABSbavquur6ofjtJWkbvlCkp+OPoDlE7R9AfCPVXV7Va2nk1c3996q+nFV3Qb8O53Bh7G0c/vvMX5ufznwpqpaX1V30yl8n7/5xXZJ9qWT20+pql9V1TeA88Z437+vql9W1feA79EZlBnPr4HHJ3lIVd1UVVdM0FYzlAWyBtledEZ4R/2o2QfwTWBRkj3oJNqPA/s00ycOAS4a55yjoxMHA5cBK+kk3acC66pqIzAPeCjwndY/Dl9u9o8V441VVa19N2zWZmNVbWpt/wLYaazgqmod8Dd0kv0tSc5JstdYbSWpi55bVY8YfQAnTNB2Lx6Y9zbPgQA/aT0fNwfSydG/l2RPYA5wLnBokgV0Polb07R7NPD5Vo6+is4Awx5jxHZbVf1iOuKrqv8GXkinQL8pyf9J8thx+qIZzAJZg+zHdJLgqH2bfTTJ7jvAXwOXV9WvgP8EXgP8sKpuHeec/0ln9PZ5wIVVdWVz3mdz/8jErcAvgce1/oF4eFWNlTBvAvZuRp1H7bMFfazf2FH1r1X1NDp9L+DtW3A+Seq1m4D5re0tyYEP0AwS/ILOFIqLquoOOsXrUuAbVfXrpukNdKY5PKL1mFtVN44R265JHrqV8Y2Vo79SVUcBewLfBz60BefTDGGBrEGxfXMR3ehjOzrzef8uybxmZPgUoH1hxYV05uuOFrZf32z7N7QK6xNb7f6TzmjAhU2bX9NJeKcneSRAkr2TPHOMU36TzqjFK5Nsl2QJnRHsqbqZzrw9mvfZP8kfpHMx4l10CvVfj/diSRoA5wJvSLJLkr3p5OFtMZXc/kHgbUkeDdD8O7Fk8xNV1Y+A1cCyJDsk+R/AH29BLDcDC5I8qHmfPZIsaeYi301nypw5ehayQNagOJ9OMTj6WAb8A53EtpbOdIhLm32jLgR25v7pFJtvj+dCYHvunys81uteD6wDLk5yB/A1xpg33Ixc/z90Lr77KZ2LU75IJ3FOxUfozDf+aXN19oPpXCB4K51Rk0cCb5jiuSSpH94CrAeuo5MrP8PUc+BYppLb30NnLvFXk9wJXAw8ZZzzvQj4H8BGOv+GrNiC+D7dfN2Y5FI6ddNr6HyaeRudKXqvmOK5NIPkgVMnJW2rJN8CPlhVH+t3LJLUa0leARxdVYdN2rgPkqwAvl9Vb+53LBpcjiBL2yjJYUke1UyxOJbO6hhf7ndcktQLSfZMZz36BzVLVb6WzvKXAyHJk5M8polvMbAE+EKfw9KA897j0rbbn84cvB3prNn5/Kq6qb8hSVLP7AD8M501jn8KnMPEy8L12qOAz9FZB3k98Iqq+m5/Q9Kgc4qFJEmS1OIUC0mSJKllRk+x2H333WvBggX9DkOSJvWd73zn1qoa62Yzs465WdJMMV5untEF8oIFC1i9enW/w5CkSSX50eStZgdzs6SZYrzc7BQLSZIkqcUCWZIkSWqxQJYkSZJaZvQcZEkzxz333MP69eu56667+h1KV82dO5f58+ez/fbb9zsUSZrQsORl2PLcbIEsqSfWr1/PzjvvzIIFC0jS73C6oqrYuHEj69evZ+HChf0OR5ImNAx5GbYuNzvFQlJP3HXXXey2226zOgknYbfddhuK0RhJM98w5GXYutxsgSypZ2Z7Eobh6KOk2WNYctaW9tMCWZIkSWpxDrKkvjh95TXTer6Tjlo0aZs5c+bwhCc84b7to48+mpNPPnla45Ckmcq8fD8LZElD4yEPeQhr1qzpdxiSpMag5mWnWEiSJEktFsiShsYvf/lLDjzwwPseK1as6HdIkjTUBjUvO8VC6pdVp07PeY54w/ScZwgM6kd5krQ1JpszPJU5wP02qHnZEWRJkiSpxQJZkiRJanGKhaS+6MdHf6Nz3UYtXryY0047redxSNIgMi/fzwJZ0tC49957+x2CJKllUPOyUywkSZKkFgtkSZIkqcUCWZIkSWqxQJYkSZJaLJAlSZKkFgtkSZIkqcVl3iT1x3TdanvUFG65vdNOO/Hzn/98et93BkvyUeCPgFuq6vHjtDkcOAPYHri1qg7rVXySesy8fB9HkCVpeJ0FLB7vYJJHAMuB51TV44A/7U1YktRfFsiSNKSq6iLgtgma/Bnwuar6r6b9LT0JTJL6zAJZkjSeRcAuSb6e5DtJXjpewyRLk6xOsnrDhg09DFGSpp8FsiRpPNsBTwL+EHgm8P8mWTRWw6o6s6pGqmpk3rx5vYxRkqadF+lJksazHthYVf8N/HeSi4DfBa7pb1iS1F2OIEuSxvNvwNOSbJfkocBTgKv6HJMkdV3XRpCT7AN8HNgDKODMqnpPkmXAXwKjk9TeWFXnN695A3A8cC/w6qr6Srfik9RnU1j+R92V5FPA4cDuSdYDb6aznBtV9cGquirJl4G1wK+BD1fV5f2KV1KXmZfv080pFpuA11bVpUl2Br6TZGVz7PSqele7cZIDgKOBxwF7AV9Lsqiq7u1ijJKGyCCutdlPVXXMFNq8E3hnD8KRNIQGNS93bYpFVd1UVZc2z++k87Hc3hO8ZAlwTlXdXVXXAeuAQ7oVnyRJkjSWnsxBTrIAOAj4VrPrlUnWJvlokl2afXsDN7Retp4xCmqXEpIkSVI3db1ATrIT8Fngb6rqDuADwGOAA4GbgH/akvO5lJAkSZK6qasFcpLt6RTHn6yqzwFU1c1VdW9V/Rr4EPdPo7gR2Kf18vnNPkmSJKlnulYgJwnwEeCqqnp3a/+erWbPA0aviD4PODrJg5MsBPYDvt2t+CRJkqSxdHMVi0OBlwCXJVnT7HsjcEySA+ks/XY98FcAVXVFknOBK+msgHGiK1hIkiSp17pWIFfVN4CMcej8CV7zNuBt3YpJ0uBYvmb5tJ7vhANPmPD4xo0bOfLIIwH4yU9+wpw5cxi9juHb3/42O+yww31tzzjjDJYuXcpDH/rQCc95+OGH8653vYuRkZFtjF6aPab6tz3Z36x6z7x8P281LWko7LbbbqxZswaAZcuWsdNOO/G6171uzLZnnHEGL37xiydNxJKkrTfIedlbTUsaWhdccAEHHXQQT3jCE3jZy17G3XffzXvf+15+/OMfc8QRR3DEEUcA8IpXvIKRkREe97jH8eY3v7nPUUvS7DUoedkCWdJQuuuuuzjuuONYsWIFl112GZs2beIDH/gAr371q9lrr71YtWoVq1atAuBtb3sbq1evZu3atVx44YWsXbu2z9FL0uwzSHnZAlnSULr33ntZuHAhixYtAuDYY4/loosuGrPtueeey8EHH8xBBx3EFVdcwZVXXtnLUCVpKAxSXnYOsqQtcvrKayZtc9JRi3oQSW9cd911vOtd7+KSSy5hl1124bjjjuOuu+7qd1iSNLR6kZcdQZY0lObMmcP111/PunXrAPjEJz7BYYcdBsDOO+/MnXfeCcAdd9zBjjvuyMMf/nBuvvlmvvSlL/UtZkmazQYpLzuCLKkv+r3E09y5c/nYxz7Gn/7pn7Jp0yae/OQn8/KXvxyApUuXsnjx4vvmvB100EE89rGPZZ999uHQQw/ta9yS1C3m5ftZIEsaOsuWLbvv+Xe/+93fOP6qV72KV73qVfdtn3XWWWOe5+tf//o0RyZJw2nQ8rJTLCRJkqQWC2RJkiSpxQJZUs9UVb9D6Lph6KOk2WNYctaW9tMCWVJPzJ07l40bN87qZFxVbNy4kblz5/Y7FEma1DDkZdi63OxFepJ6Yv78+axfv54NGzb0O5Sumjt3LvPnz+93GJI0qWHJy7DludkCWVJPbL/99ixcuLDfYUiSGubl8TnFQpIkSWqxQJYkSZJaLJAlSZKkFgtkSRpSST6a5JYkl0/S7slJNiV5fq9ik6R+skCWpOF1FrB4ogZJ5gBvB77ai4AkaRBYIEvSkKqqi4DbJmn2KuCzwC3dj0iSBoMFsiRpTEn2Bp4HfGAKbZcmWZ1k9TCsqSppdrNAliSN5wzg9VX168kaVtWZVTVSVSPz5s3rfmSS1EXeKESSNJ4R4JwkALsDz06yqaq+0NeoJKnLLJAlSWOqqvtusZXkLOCLFseShoEFsiQNqSSfAg4Hdk+yHngzsD1AVX2wj6FJUl9ZIEvSkKqqY7ag7XFdDEWSBooX6UmSJEktFsiSJElSi1MsJN3n9JXX9DsESZL6zhFkSZIkqcUCWZIkSWqxQJYkSZJaLJAlSZKkFi/SkyRJmoUmu/D6pKMW9SiSmccRZEmSJKnFAlmSJElqsUCWJEmSWiyQJUmSpBYLZEmSJKnFAlmSJElqcZk3SZKmy6pTp9buiDd0Nw5J28QRZEmSJKmlawVykn2SrEpyZZIrkvx1s3/XJCuT/KD5ukuzP0nem2RdkrVJDu5WbJIkSdJ4ujmCvAl4bVUdADwVODHJAcDJwAVVtR9wQbMN8Cxgv+axFPhAF2OTJEmSxtS1ArmqbqqqS5vndwJXAXsDS4Czm2ZnA89tni8BPl4dFwOPSLJnt+KTJEmSxtKTOchJFgAHAd8C9qiqm5pDPwH2aJ7vDdzQetn6Zp8kSZLUM10vkJPsBHwW+JuquqN9rKoKqC0839Ikq5Os3rBhwzRGKkmSJHW5QE6yPZ3i+JNV9blm982jUyear7c0+28E9mm9fH6z7wGq6syqGqmqkXnz5nUveEmSJA2lbq5iEeAjwFVV9e7WofOAY5vnxwL/1tr/0mY1i6cCP2tNxZAkSZJ6ops3CjkUeAlwWZI1zb43AqcB5yY5HvgR8ILm2PnAs4F1wC+AP+9ibJIkSdKYulYgV9U3gIxz+Mgx2hdwYrfikSQ9UJKPAn8E3FJVjx/j+IuA19PJ5XcCr6iq7/U2SknqPW81LWnanb7ymknbnHTUoh5EokmcBbwP+Pg4x68DDquq25M8CzgTeEqPYpOkvrFAlqQhVVUXNctwjnf8P1ubF9O5eFqSZr2erIMsSZrxjge+NN5Bl+CUNJtYIEuSJpTkCDoF8uvHa+MSnJJmE6dYSJLGleSJwIeBZ1XVxn7HI0m94AiyJGlMSfYFPge8pKomv/JSkmYJR5AlaUgl+RRwOLB7kvXAm4HtAarqg8ApwG7A8s69n9hUVSP9iVaSescCWZKGVFUdM8nxvwD+okfhSNLAcIqFJEmS1GKBLEmSJLVYIEuSJEktFsiSJElSiwWyJEmS1GKBLEmSJLVYIEuSJEktFsiSJElSiwWyJEmS1GKBLEmSJLVYIEuSJEktFsiSJElSiwWyJEmS1GKBLEmSJLVYIEuSJEktFsiSJElSiwWyJEmS1GKBLEmSJLVYIEuSJEkt2/U7AEndd/rKa/odgiRJM4YjyJIkSVKLBbIkSZLUYoEsSZIktVggS5IkSS0WyJI0pJJ8NMktSS4f53iSvDfJuiRrkxzc6xglqR8skCVpeJ0FLJ7g+LOA/ZrHUuADPYhJkvrOAlmShlRVXQTcNkGTJcDHq+Ni4BFJ9uxNdJLUPxbIkqTx7A3c0Npe3+z7DUmWJlmdZPWGDRt6EpwkdYsFsiRpm1XVmVU1UlUj8+bN63c4krRNLJAlSeO5EdintT2/2SdJs9qUCuQkn0vyh0ksqCVpAHUpT58HvLRZzeKpwM+q6qZpPL8kDaSpJtLlwJ8BP0hyWpL9uxiTJGnLbXGeTvIp4JvA/knWJzk+ycuTvLxpcj5wLbAO+BBwQpdil6SBst1UGlXV14CvJXk4cEzz/AY6CfNfquqeLsYoSZrE1uTpqjpmknMWcGI34pWkQTblj+KS7AYcB/wF8F3gPcDBwMquRCZJ2iLmaUmaHlMaQU7yeWB/4BPAH7fmoK1IsrpbwUmSpsY8LUnTZ6ojyB+qqgOq6tTRpJvkwQBVNTLWC8a6hWmSZUluTLKmeTy7dewNze1Mr07yzG3okyQNoy3O05KksU1pBBn4BzoXa7R9k85Hd+M5C3gf8PHN9p9eVe9q70hyAHA08DhgLzpz5xZV1b1TjE+Sht3W5GlpoC1fs3xK7U440OtHNb0mLJCTPIrOXZMekuQgIM2hhwEPnei1VXVRkgVTjGMJcE5V3Q1cl2QdcAid5C5JGse25GlJ0tgmG0F+Jp0LPuYD727tvxN441a+5yuTvBRYDby2qm6nk9wvbrWZ8HamwFKAfffddytDkKRZoxt5Wt226tTJ2xzxhu7HIWlMExbIVXU2cHaSP6mqz07D+30AeCtQzdd/Al62JSeoqjOBMwFGRkZqGmKSpBmrC3lakobeZFMsXlxV/wIsSPKazY9X1bvHeNm4qurm1rk/BHyx2fR2ppK0FaY7T0saHqevvGbSNicdtagHkQyeyaZY7Nh83Wk63izJnq2lh54HjK5wcR7wr0neTecivf2Ab0/He0rSLDeteXroTGWqAzjdQRoyk02x+Ofm699v6YmbW5geDuyeZD3wZuDwJAfSmWJxPfBXzfmvSHIucCWwCTjRFSwkaXLbkqclSWOb0jrISd6R5GFJtk9yQZINSV480Wuq6piq2rOqtq+q+VX1kap6SVU9oaqeWFXPaY0mU1Vvq6rHVNX+VfWlbe2YJA2TrcnTkqSxTfVGIc+oqjuAP6Iz8vvbwP/qVlCSpC1mnpakaTLVAnl0KsYfAp+uqp91KR5J0tYxT0vSNJnqnfS+mOT7wC+BVySZB9zVvbAkSVvIPC1J02RKI8hVdTLwP4GRqroH+G86d7+TJA0A87QkTZ+pjiADPJbOOpvt13x8muORJG0987QkTYMpFchJPgE8BlgDjC6/Vph4JWkgmKclafpMdQR5BDigqry1syQNJvO0JE2TqRbIlwOPAm6arKEkqS/M07PNLL/L3/I1y/sdgjSuqRbIuwNXJvk2cPfozqp6TleikiRtKfO0JE2TqRbIy7oZhCRpmy3rdwCSNFtMqUCuqguTPBrYr6q+luShwJzuhiZJmirztCRNnymtg5zkL4HPAP/c7Nob+EKXYpIkbSHztCRNn6lOsTgROAT4FkBV/SDJI7sWlaRJLf/p2s6TKVzocukdG7fo3Ac/7IVbE5L6yzwtSdNkSiPIwN1V9avRjWYRepcSkqTBsVV5OsniJFcnWZfk5DGO75tkVZLvJlmb5NnTHLckDZypFsgXJnkj8JAkRwGfBv69e2FJkrbQFufpJHOA9wPPAg4AjklywGbN/g44t6oOAo4GXJtL0qw31QL5ZGADcBnwV8D5dJKmJGkwbE2ePgRYV1XXNqPP5wBLNmtTwMOa5w8HfjxtEUvSgJrqKha/TvIF4AtVtaG7IUmSttRW5um9gRta2+uBp2zWZhnw1SSvAnYEnj7WiZIsBZYC7LvvvlMPvFumepMNSRrDhCPI6ViW5FbgauDqJBuSnNKb8CRJE+lBnj4GOKuq5gPPBj6R5Df+7aiqM6tqpKpG5s2bN01vLUn9MdkUi5OAQ4EnV9WuVbUrndGFQ5Oc1PXoJEmT2ZY8fSOwT2t7frOv7XjgXICq+iYwl85d+yRp1pqsQH4JcExVXTe6o6quBV4MvLSbgUmSpmRb8vQlwH5JFibZgc5FeOdt1ua/gCMBkvwOnQLZqXaSZrXJ5iBvX1W3br6zqjYk2b5LMUmSpm6r83RVbUrySuArdO6699GquiLJW4DVVXUe8FrgQ81odAHHVZXLfGqgLJ/CevAnHHhCDyLRbDFZgfyrrTwmSeqNbcrTVXU+nRUv2vtOaT2/ks4UDkkaGpMVyL+b5I4x9ofOx2ySpP4yT0vSNJuwQK6qOb0KRJK05czTkjT9pnqjEEmSJGkoWCBLkiRJLRbIkiRJUosFsiRJktQy2SoWkiRJUtecvvKaSducdNSiHkRyP0eQJUmSpBZHkCX9hkvvWNG1cx/8sBd27dySJE0HR5AlSZKkFgtkSZIkqcUCWZIkSWqxQJYkSZJavEhPkiRNyfI1y/sdgmagqSzjNmgcQZYkSZJaHEGWttSqU/sdgSRJ6iILZEl9MYh3TpIkCZxiIUmSJD2ABbIkSZLU4hQLSZIm47UH0lDp2ghyko8muSXJ5a19uyZZmeQHzdddmv1J8t4k65KsTXJwt+KSJEmSJtLNKRZnAYs323cycEFV7Qdc0GwDPAvYr3ksBT7QxbgkSZKkcXWtQK6qi4DbNtu9BDi7eX428NzW/o9Xx8XAI5Ls2a3YJEmSpPH0+iK9Parqpub5T4A9mud7Aze02q1v9v2GJEuTrE6yesOGDd2LVJIkSUOpb6tYVFUBtRWvO7OqRqpqZN68eV2ITJKGR5LFSa5urgE5eZw2L0hyZZIrkvxrr2OUpF7r9SoWNyfZs6puaqZQ3NLsvxHYp9VufrNPktQlSeYA7weOovPJ3SVJzquqK1tt9gPeABxaVbcneWR/olU3LV+zvN8hSAOl1yPI5wHHNs+PBf6ttf+lzWoWTwV+1pqKIUnqjkOAdVV1bVX9CjiHzjUhbX8JvL+qbgeoqluQpFmum8u8fQr4JrB/kvVJjgdOA45K8gPg6c02wPnAtcA64EPACd2KS5J0n6lc/7EIWJTk/ya5OMnmqxMBXh8iaXbp2hSLqjpmnENHjtG2gBO7FYskaattR2cJzsPpTH+7KMkTquqn7UZVdSZwJsDIyMgWX18iSYPEW01L0vCayvUf64HzquqeqroOuIZOwSxJs5YFsiQNr0uA/ZIsTLIDcDSda0LavkBn9Jgku9OZcnFtD2OUpJ6zQJakIVVVm4BXAl8BrgLOraorkrwlyXOaZl8BNia5ElgF/K+q2tifiCWpN3q9zJskaYBU1fl0LpRu7zul9byA1zQPSRoKjiBLkiRJLRbIkiRJUosFsiRJktRigSxJkiS1WCBLkiRJLRbIkiRJUosFsiRJktRigSxJkiS1WCBLkiRJLRbIkiRJUou3mpa6aPlP1/Y7BEmStIUcQZYkSZJaLJAlSZKkFgtkSZIkqcUCWZIkSWqxQJYkSZJaXMVCkiRpwJy+8pp+hzDUHEGWJEmSWhxBljSwpjqCctJRi7ociTTAVp06tXZHvKG7cQy45WuWT9rmhANP6EEkmgkcQZYkSZJaLJAlSZKkFgtkSZIkqcU5yJIkST3mKhWDzRFkSZIkqcURZA2PqV7pLQ2RJIuB9wBzgA9X1WnjtPsT4DPAk6tqdQ9DlKRJR9ynezUjR5AlaUglmQO8H3gWcABwTJIDxmi3M/DXwLd6G6Ek9YcFsiQNr0OAdVV1bVX9CjgHWDJGu7cCbwfu6mVwktQvFsiSNLz2Bm5oba9v9t0nycHAPlX1fyY6UZKlSVYnWb1hw4bpj1SSesgCWZI0piQPAt4NvHaytlV1ZlWNVNXIvHnzuh+cJHWRBbIkDa8bgX1a2/ObfaN2Bh4PfD3J9cBTgfOSjPQsQknqA1exkGa4b/5wY79D0Mx1CbBfkoV0CuOjgT8bPVhVPwN2H91O8nXgda5iIWm2cwRZkoZUVW0CXgl8BbgKOLeqrkjyliTP6W90ktQ/jiBL0hCrqvOB8zfbd8o4bQ/vRUyS1G+OIEuSJEktFsiSJElSiwWyJEmS1GKBLEmSJLV4kZ4G36pT+x2BJEkaIn0pkJsF5+8E7gU2VdVIkl2BFcAC4HrgBVV1ez/ikyRJ0vDq5wjyEVV1a2v7ZOCCqjotycnN9uv7E5okSZJOX3nNhMdPOmpRjyLprUGag7wEOLt5fjbw3P6FIkmSpGHVrwK5gK8m+U6Spc2+Parqpub5T4A9+hOaJEmShlm/plg8rapuTPJIYGWS77cPVlUlqbFe2BTUSwH23Xff7kcqSZKkodKXEeSqurH5egvweeAQ4OYkewI0X28Z57VnVtVIVY3MmzevVyFLkiRpSPS8QE6yY5KdR58DzwAuB84Djm2aHQv8W69jkyRJkvoxxWIP4PNJRt//X6vqy0kuAc5NcjzwI+AFfYhNkiRJQ67nBXJVXQv87hj7NwJH9joeSZIkqc076UmSNIst/+nazpM1y/sbiDSDDNI6yJIkSVLfOYKsoXbfyIokSVLDEWRJkiSpxQJZkiRJarFAliRJkloskCVJkqQWC2RJkiSpxQJZkiRJarFAliRJklpcB1nSjHf6ymsmbXPSUYt6EMnMk2Qx8B5gDvDhqjpts+OvAf4C2ARsAF5WVT/qeaCS1EOOIEvSkEoyB3g/8CzgAOCYJAds1uy7wEhVPRH4DPCO3kYpSb1ngSxJw+sQYF1VXVtVvwLOAZa0G1TVqqr6RbN5MTC/xzFKUs9ZIEvS8NobuKG1vb7ZN57jgS+NdSDJ0iSrk6zesGHDNIYoSb3nHGR1z6pT+x2BpGmS5MXACHDYWMer6kzgTICRkZHqYWiSNO0skCX11KV3rOjauQ9+2Au7du5Z6kZgn9b2/GbfAyR5OvAm4LCqurtHsUk9t3zN8im1O+HAE7ocifrNKRaSNLwuAfZLsjDJDsDRwHntBkkOAv4ZeE5V3dKHGCWp5yyQJWlIVdUm4JXAV4CrgHOr6ookb0nynKbZO4GdgE8nWZPkvHFOJ0mzhlMsJGmIVdX5wPmb7Tul9fzpPQ9KkvrMEWRJkiSpxRFkSZIkbZWp3Ml0JnIEWZIkSWqxQJYkSZJaLJAlSZKkFgtkSZIkqcUCWZIkSWpxFQtJ0syx6tR+RyBpCDiCLEmSJLU4gqzf5AiNJEkaYhbIGnjLf7q23yFI0sx33X9Mrd3C3+tuHNIM4BQLSZIkqcUCWZIkSWqxQJYkSZJaLJAlSZKkFi/S07TwQjpJkjRbWCDPJi7PJm2T01deM2mbk45a1INIJEn95BQLSZIkqcURZElDYSqjw5IkgQWyJEnSFlm+ZvmkbU448IQeRKJucYqFJEmS1GKBLEmSJLU4xWIQNKtPdHuptBMe8cSunl/qt0vvWNHV8x/8sBd29fySpMHgCLIkSZLUMnAjyEkWA+8B5gAfrqrT+hzSrOHNPCRtbrKcm+TBwMeBJwEbgRdW1fW9jlOSemmgCuQkc4D3A0cB64FLkpxXVVf2N7JxeGMOSTPYFHPu8cDtVfXbSY4G3g50Z66JOVXSgBioAhk4BFhXVdcCJDkHWAJMb4FsEpYkmFrOXQIsa55/BnhfklRV9TJQSeqlQSuQ9wZuaG2vB57SbpBkKbC02fx5kqt7FNvW2B24td9BTKPZ1B/7MpgGui//wim8Zste0u7Po6c7nmkwac5tt6mqTUl+BuzGZj+nGZabNzfQv3ddMEl/z+lZID3Sl5/viZzY67ccNZS/z1uYm9vGzM2DViBPqqrOBM7sdxxTkWR1VY30O47pMpv6Y18G02zqC8y+/kxkJuXmzQ3Tzwns72xnf6fHoK1icSOwT2t7frNPkjT9ppJz72uTZDvg4XQu1pOkWWvQCuRLgP2SLEyyA3A0cF6fY5Kk2WoqOfc84Njm+fOB/8/5x5Jmu4GaYtHMb3sl8BU6Sw59tKqu6HNY22JGftw4gdnUH/symGZTX2DA+zNezk3yFmB1VZ0HfAT4RJJ1wG10iujZZqB/Tl1gf2c3+zsN4kCAJEmSdL9Bm2IhSZIk9ZUFsiRJktRigbwVkuyaZGWSHzRfdxmn3bFNmx8kOba1/21Jbkjy883aH5dkQ5I1zeMvZnBfHpxkRZJ1Sb6VZEGXuzL6vtvanycluayJ+71J0uxfluTG1s/m2V3sw+IkVzcxnDzG8XG/t0ne0Oy/Oskzp3rObulSX65vfkZrkqzuUVe2ui9JdkuyKsnPk7xvs9eM+fum3kvyziTfT7I2yeeTPKLfMXVTkj9NckWSXyeZlUuC9Svv9UuSjya5Jcnl/Y6l25Ls0+TVK5vf47+e9jepKh9b+ADeAZzcPD8ZePsYbXYFrm2+7tI836U59lRgT+Dnm73mOOB9s6QvJwAfbJ4fDayYIf35dtOnAF8CntXsXwa8rgfxzwF+CPwWsAPwPeCAqXxvgQOa9g8GFjbnmTOVc86UvjTHrgd27/Hfybb0ZUfgacDLN//7Hu/3zUfvH8AzgO2a528fK3fMpgfwO8D+wNeBkX7H04X+9SXv9bnPvw8cDFze71h60Nc9gYOb5zsD10z3z9cR5K2zBDi7eX428Nwx2jwTWFlVt1XV7cBKYDFAVV1cVTf1ItAp6FZf2uf9DHBkj0bHtro/SfYEHtb0qYCPj/P6brrv1r9V9Ss6t7Raslmb8b63S4BzquruqroOWNecbyrnnCl96Zet7ktV/XdVfQO4q914QH7f1Kiqr1bVpmbzYjprQs9aVXVVVc2kux1uqX7lvb6pqovorDQz61XVTVV1afP8TuAqOnf9nDYWyFtnj1ZR+BNgjzHajHUL16n88P6k+YjvM0n2mbz5NutWXx5we1pg9Pa03bYt/dm7eb75/lGvbH42Hx1v6sY0mMr3erzv7UT92prfxW3Vjb4AFPDVJN9J5/bGvbAtfZnonBP9vql/XkZnRF8zV7/ynnqsmc52EPCt6TzvQK2DPEiSfA141BiH3tTeqKpKMl1r5f078KmqujvJX9EZjfqDbT1pn/rSNX3qzweAt9Ipzt4K/BOdf0TVe0+rqhuTPBJYmeT7zciJNKGJckdV/VvT5k3AJuCTvYytG6bSX2kmS7IT8Fngb6rqjuk8twXyOKrq6eMdS3Jzkj2r6qbmY9Jbxmh2I3B4a3s+nbleE71n+/atH6Yzn3ab9aMv3H972vWZ5tvTdrE/N/LAj1Xvu+1uVd3ceo8PAV/c2vgnsSW3/t38ezvRa/txC/eu9KWqRr/ekuTzdD5K7XaBvC19meicY/6+qTsmyh3QuVAa+CPgyGbay4w2WX9nuan8zWoGS7I9neL4k1X1uek+v1Mstk771qvHAmP9T/wrwDOS7NJ8HP+MZt+4moJu1HPozKnptq70hf7dnnar+9NMzbgjyVObebAvHX39Zj+b5wHdukp4W279ex5wdLOawkJgPzoXgfXrFu7T3pckOybZGSDJjnR+dr24Ynvab8k80e+bei/JYuBvgedU1S/6HY+2Wb/ynnqgyZkfAa6qqnd35U26dYXhbH7QmVd4AfAD4GvArs3+EeDDrXYvo3Nx0Trgz1v730FnPtSvm6/Lmv2nAlfQudp2FfDYGdyXucCnm/bfBn5rhvxsRugUXD8E3sf9d5v8BHAZsJZOkt2zi314Np0rcn9I56NQgLfQ+Yd7wu8tnWkmPwSuprUiwljn7NHPY1r7QueK9O81jytmUF+up3PxzM+bv5MDJvp989H7R/NzuwFY0zw+2O+Yutzf5zW/i3cDN9MZJOh7XNPcx77kvT7291PATcA9zc/2+H7H1MW+Po3OlMe1rb/ZZ0/ne3iraUmSJKnFKRaSJElSiwWyJEmS1GKBLEmSJLVYIEuSJEktFsiSJElSiwWyZqQkz01SSR47Sbu/SfLQ1vb5SR6xFe/3iCQntLb3SvKZLT2PJM1m5mbNFi7zphkpyQpgLzo3Y3jzBO2uB0aq6tZtfL8FwBer6vHbch5Jms3MzZotHEHWjNPce/1pwPF07o5EkjlJ3pXk8iRrk7wqyavpJOpVSVY17a5PsnuS05Kc2DrnsiSvS7JTkguSXJrksiRLmianAY9JsibJO5MsSHJ589q5ST7WtP9ukiOa/ccl+VySLyf5QZJpuXW4JA0ic7Nmk+36HYC0FZYAX66qa5JsTPIk4BBgAXBgVW1KsmtV3ZbkNcARY4xSrADOAN7fbL8AeCZwF/C8qrojye7AxUnOA04GHl9VB8J9oxajTgSqqp7QfKz41SSLmmMHAgfRuVvV1Un+d1XdMG3fCUkaHOZmzRoWyJqJjgHe0zw/p9leSOfWsJsAquq2iU5QVd9N8sgkewHzgNur6oYk2wP/mOT36dw+e29gj0nieRrwv5vzfj/Jj4DRJHxBVf0MIMmVwKPp3M5WkmYbc7NmDQtkzShJdgX+AHhCkgLm0Lkf+yVbcbpPA88HHkVn1ALgRXSS8pOq6p5mntzcbQj57tbze/FvTtIsZG7WbOMcZM00zwc+UVWPrqoFVbUPcB3wPeCvkmwH9yVrgDuBncc51wo68+SeTychAzwcuKVJwEfQGVWY7Dz/QSd503x8ty9w9Vb2T5JmInOzZhULZM00xwCf32zfZ4E9gf8C1ib5HvBnzbEzgS+PXgjSVlVX0EmsN1bVTc3uTwIjSS4DXgp8v2m7Efi/zYUm79zsVMuBBzWvWQEcV1V3I0nDw9ysWcVl3iRJkqQWR5AlSZKkFgtkSZIkqcUCWZIkSWqxQJYkSZJaLJAlSZKkFgtkSZIkqcUCWZIkSWr5/wEUlUTjbvhxhAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -1254,7 +1286,7 @@ "rnd_neuron = 4\n", "\n", "f, (ax1, ax2) = plt.subplots(1, 2, figsize=(10,5))\n", - "ax1.set_title('Small weights')\n", + "ax1.set_title('Low weights')\n", "ax1.set_xlabel('Activation')\n", "ax1.set_ylabel('Density')\n", "ax1.hist(act_exc_balanced[rnd_neuron], bins=10, alpha=0.5, density=True, label='E')\n", @@ -1284,13 +1316,13 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 28, "id": "22933de6", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAswAAAFgCAYAAACv5y8SAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAzF0lEQVR4nO3dfbhcVX33//enMRAVlKcUkYChFrRFa8Aj2qoVpFTEVvSuVaxWsPaXCni3Ynu3UH+XUu9atbVFrUaL9QGtSqhVS/2hFRWhtgUNGMKTYhQsSRFikKcq0eD398feByaHOXMm55yZOQ/v13XNdfZee82e7+yZWfM9a9ZeO1WFJEmSpO5+atQBSJIkSXOZCbMkSZLUgwmzJEmS1IMJsyRJktSDCbMkSZLUgwmzJEmS1IMJsxa8JCuTVJIHtetfSvK7A3y8pyf5Rp91j0yyaVCxSNJsSXJNkiP7rHtjkl8ZbEQ7PN6BSe5OsqSPujt8J0j9MGHWyCR5WpL/SHJHktuS/HuSJ406rpmqqn+rqsfMxr6SfDDJn8/GviRpMt0S3CQnJfny+HpVHVpVXxp6cH2oqv+qqt2q6t6Z7ivJmUn+YTbi0sLhf1caiSQPAz4NnAycB+wCPB3YNsq4JEmSJrKHWaNyCEBVfayq7q2qH1bV56pqA9zXs/HvSc5KcnuSbyf5pbb8piS3JjlxfGdJnpPka0nubLefubMBJVmW5IdJ9mnXX5tke5vck+T/Jnlbu7xrkrcm+a8ktyR5T5IHt9t2GGaR5PA2truS/GOStRN7jZP8Yfucbk7y8rZsNfAS4I/bnxr/pS3/kySb2/19I8nRO/tcJWlndfZCJ3lwknOSfD/JdUn+uMvwslVJNrS/Iq5NsmyS/X4nyRPb5Ze0wyUObddfkeRT7fJPJTk9ybeSbE1yXpK92m0Th94dlOSStp38fJJ3dek1fknbhn8vyWvb+x0L/CnworbdvbItP6n9HroryQ1JXjILh1TziAmzRuV64N62wX12kj271HkysAHYG/gocC7wJOBngZcC70yyW1v3f4CXAXsAzwFOTvK8nQmoqu4Bvgo8oy16BvAd4Kkd6xe3y2+mSfpXtfHsD7xu4j6T7AJ8EvggsBfwMeD5E6o9Anh4u49XAO9KsmdVnQ18BPjL9qfGX0/yGOBVwJOqanfgWcCNO/M8JWkWvB5YCfwMcAxNmzzRC4FjgYOAXwBOmmRfFwNHtsvPAL4N/HLH+ni7+7+B57VljwS+D7xrkn1+FPgKzffHmcBvd6nzNOAxwNHA65L8XFV9FvgLYG3b7j4hyUOBdwDPbtvdXwLWT/K4WqBMmDUSVXUnTWNVwHuBLUnOT7JvR7UbquoD7Zi0tcABwBuqaltVfQ74EU2ySlV9qaquqqqftL3UH+P+xHdnXAw8o+2l+AWaRvIZbc/Ik4BLkgRYDZxWVbdV1V00DewJXfb3FJqhT++oqh9X1SdoGvFOP26f14+r6gLgbppGvJt7gV2Bn0+ytKpurKpvTeN5StJEn2p/0bs9ye3Amh51Xwj8RVV9v6o20bSVE72jqv67qm4D/oWmg6Gbi7m/vX468CZ27LgYT5hfCby2qjZV1TaaRPgFmXDyXpIDadrr11XVj6rqy8D5XR73z9pfN68ErgSe0OP5/gR4XJIHV9XNVXVNj7pagEyYNTJVdV1VnVRVK4DH0fQYvK2jyi0dyz9s7zOxbDeAJE9OclGSLUnuoGlY95lGWOM9HYcDVwEX0jTYTwE2VtVWYDnwEODyji+Wz7blEz0S2FxV1VF204Q6W6tqe8f6D8af10RVtRF4Nc0Xxa1Jzk3yyJ14fpI0medV1R7jN+CUHnUfyY5t2cR2DeC7HcuTtms07e7Tk+wHLKE5r+WpSVbS/Pq2vq33KOCTHe3udTSdCPtO2N8jgduq6gezEV9V/Q/wIprvlZuT/H9JHjvJc9ECZcKsOaGqvk4zbOFx09zFR2l6EA6oqocD7wEyjf38B03v7vOBi6vqWuBA4Dju7+X4Hk2yfmjHl8vDq6pbY3szsH/bKz3ugJ2Ipx5QUPXRqnoazZdHAW/Zif1J0my4GVjRsb4z7doO2o6AH9AMubik/QXyuzS/5H25qn7SVr2JZljEHh23ZVW1uUtseyV5yDTj69bu/mtVHQPsB3yd5pdRLSImzBqJJI9tT3Rb0a4fALwYuHSau9ydpkfhniRHAL81nZ20PRKXA6dyf4L8HzQ9Cxe3dX5C01ieleSn2/j3T/KsLrv8T5oekFcleVCS44EjdiKkW2jGCNI+zmOSPDPJrsA9NIn7Tya7syQNyHnAGUn2TLI/zbkVM3Fxu4/xdvdLE9ah6Qh5Y5JHASRZ3rapO6iq7wDrgDOT7JLkF4Ff34lYbgFWJvmp9nH2TXJ8O5Z5G82wOdvdRcaEWaNyF81JfZcl+R+aRPlq4A+nub9TgDckuYvm5LvzZhDbxcBS7h9rfDFNQn5JR50/ATYClya5E/g8XcYdV9WPgP9FczLf7TQnxnya/qfPex/NeOXb2zPFd6U54fB7ND0wPw2c0f9Tk6RZ8QZgE3ADTfv3cWY2LejEdrZbu/t2ml8SP9e29ZfSfI908xLgF4GtwJ/TnAfTb3z/2P7dmuQKmlzpNcB/A7fRDNM7uc99aYHIjkMrJQ1aksuA91TVB0YdiyTNhiQnAydU1XROth64JGuBr1fV60cdi+Yne5ilAUvyjCSPaIdknEgz+8ZnRx2XJE1Xkv2SPLWdG/kxNL8OfnLUcY1L8qQkj27jOxY4HvjUiMPSPOaV/qTBewzNEJGH0swv+oKqunm0IUnSjOwC/B3NHMu308yT32saumF7BPAJmnmYNwEnV9XXRhuS5jOHZEiSJEk9OCRDkiRJ6mFeD8nYZ599auXKlaMOQ5Km5fLLL/9eVXW74M28YBssab7rtx2e1wnzypUrWbdu3ajDkKRpSfKdUccwE7bBkua7ftthh2RIkiRJPZgwS5IkST2YMEuSJEk9zOsxzN38+Mc/ZtOmTdxzzz2jDmWgli1bxooVK1i6dOmoQ5EkSfPQYsmZYOZ504JLmDdt2sTuu+/OypUrSTLqcAaiqti6dSubNm3ioIMOGnU4kiRpHloMORPMTt604IZk3HPPPey9994L+oVPwt57770o/iOUJEmDsRhyJpidvGnBJczAgn/hYXE8R0mSNFiLJZ+Y6fNckAmzJEmSNFsW3Bjmic668PpZ3d9pxxwyZZ0lS5bw+Mc//r71E044gdNPP31W45AkSZpN5kyTW/AJ8yg8+MEPZv369aMOQ5IkaU6bLzmTQzIkSZKkHkyYB+CHP/whq1atuu+2du3aUYckSZI058yXnMkhGQMwX35ekEahnzFy/Yx7k7QwrFm/pmv5KatOGXIkGoX5kjMNvIc5yZIkX0vy6Xb9oCSXJdmYZG2SXdryXdv1je32lYOOTZIkSZrKMHqY/wC4DnhYu/4W4KyqOjfJe4BXAO9u/36/qn42yQltvRcNIT5Js2S2z7CWJGkuGGjCnGQF8BzgjcBr0swa/Uzgt9oq5wBn0iTMx7fLAB8H3pkkVVUziWEUP+2Oj8cZd+yxx/LmN7956HFIkiT1y5xpcoPuYX4b8MfA7u363sDtVbW9Xd8E7N8u7w/cBFBV25Pc0db/XucOk6wGVgMceOCBg4x92u69995RhyBJ90myDLgE2JWm3f94Vb1+Qp1dgQ8BTwS2Ai+qqhuHHKqkRWa+5EwDG8Oc5NeAW6vq8tncb1WdXVVjVTW2fPny2dy1JC1U24BnVtUTgFXAsUmeMqHOfcPigLNohsVJkhjsSX9PBZ6b5EbgXJqhGG8H9kgy3rO9AtjcLm8GDgBotz+cppdDkjQD1bi7XV3a3iYOdzueZpgcNMPijm6H0UnSojewhLmqzqiqFVW1EjgB+GJVvQS4CHhBW+1E4J/b5fPbddrtX5zp+GVJUqOdsWg9cCtwYVVdNqHKDsPigPFhcZK06I3iwiV/QnMC4Eaaxvh9bfn7gL3b8tcAc+9C4pI0T1XVvVW1iuaXvSOSPG46+0myOsm6JOu2bNkyqzFK0lw1lAuXVNWXgC+1y98GjuhS5x7gN4cRjyQtVlV1e5KLgGOBqzs2jQ+L29RrWFxVnQ2cDTA2NuavgJIWBS+NLUkLXJLlSfZolx8MHAN8fUI1h8VJ0iQW/qWxL3rT7O7vqDOmrLLbbrtx9913T1lPkoZkP+CcJEtoOkrOq6pPJ3kDsK6qzqcZFvfhdljcbTTnnkhaTMyZJrXwE2ZJWuSqagNwWJfy13UsOyxOkibhkAxJkiSpBxNmSZIkqQcTZkmSJKkHE2ZJkiSpBxNmSZIkqYeFP0tGH1OaSJIkLXrmTJOyh3kA5sN8gpIkSaM2X3ImE2ZJkiSpBxNmSZIkqQcTZkmSJKkHE2ZJkiSpBxNmSZIkqQcTZkmSJKmHBT8P85r1a2Z1f6esOqXn9q1bt3L00UcD8N3vfpclS5awfPlyAL7yla+wyy673Ff3bW97G6tXr+YhD3lIz30eeeSRvPWtb2VsbGyG0UuSJHVnzjS5BZ8wD9vee+/N+vXrATjzzDPZbbfd+KM/+qOudd/2trfx0pe+dMoXX5IkaaGZTzmTQzKG4Atf+AKHHXYYj3/84/md3/kdtm3bxjve8Q7++7//m6OOOoqjjjoKgJNPPpmxsTEOPfRQXv/61484akmSpOGaqzmTCfOA3XPPPZx00kmsXbuWq666iu3bt/Pud7+b3//93+eRj3wkF110ERdddBEAb3zjG1m3bh0bNmzg4osvZsOGDSOOXpIkaTjmcs5kwjxg9957LwcddBCHHHIIACeeeCKXXHJJ17rnnXcehx9+OIcddhjXXHMN11577TBDlSRJGpm5nDM5hnmOuOGGG3jrW9/KV7/6Vfbcc09OOukk7rnnnlGHJUmSNKeMImeyh3nAlixZwo033sjGjRsB+PCHP8wznvEMAHbffXfuuusuAO68804e+tCH8vCHP5xbbrmFz3zmMyOLWZIkadjmcs604HuYp5rSZNCWLVvGBz7wAX7zN3+T7du386QnPYlXvvKVAKxevZpjjz32vnE5hx12GI997GM54IADeOpTnzrSuCVJ0uJizjS5VNXAH2RQxsbGat26dTuUXXfddfzcz/3ciCIarsX0XDU/nHXh9bOyn9OOOWRW9jPXJbm8qubtBOvd2mBpZ0029++ok7fFYLHlEd2eb7/t8MCGZCRZluQrSa5Mck2SP2vLP5jkhiTr29uqtjxJ3pFkY5INSQ4fVGySJElSvwY5JGMb8MyqujvJUuDLScYHmfyfqvr4hPrPBg5ub08G3t3+lSRJkkZmYAlzNWM97m5Xl7a3XuM/jgc+1N7v0iR7JNmvqm6exmOTZKdjnk/m81AaSdLiNNuXXtbMLYacCWaeNw10lowkS5KsB24FLqyqy9pNb2yHXZyVZNe2bH/gpo67b2rLJu5zdZJ1SdZt2bLlAY+5bNkytm7duqATyqpi69atLFu2bNShSJKkeWox5EwwO3nTQGfJqKp7gVVJ9gA+meRxwBnAd4FdgLOBPwHesBP7PLu9H2NjYw94hVesWMGmTZvolkwvJMuWLWPFihWjDkOSJM1TiyVngpnnTUOZVq6qbk9yEXBsVb21Ld6W5APAH7Xrm4EDOu62oi3bKUuXLuWggw6aUbySJEkLnTlT/wY5S8bytmeZJA8GjgG+nmS/tizA84Cr27ucD7ysnS3jKcAd0xm/LEmSJM2mQfYw7weck2QJTWJ+XlV9OskXkywHAqwHXtnWvwA4DtgI/AB4+QBjkyRJkvoyyFkyNgCHdSl/5iT1Czh1UPFIkiRJ0zHQWTIkSZKk+c6EWZIkSerBhFmSJEnqwYRZkiRJ6sGEWZIkSerBhFmSFrgkByS5KMm1Sa5J8gdd6hyZ5I4k69vb60YRqyTNRUO50p8kaaS2A39YVVck2R24PMmFVXXthHr/VlW/NoL4JGlOs4dZkha4qrq5qq5ol+8CrgP2H21UkjR/mDBL0iKSZCXNRaUu67L5F5NcmeQzSQ4dbmSSNHc5JEOSFokkuwH/BLy6qu6csPkK4FFVdXeS44BPAQd32cdqYDXAgQceONiAJWmOsIdZkhaBJEtpkuWPVNUnJm6vqjur6u52+QJgaZJ9utQ7u6rGqmps+fLlA49bkuYCE2ZJWuCSBHgfcF1V/c0kdR7R1iPJETTfD1uHF6UkzV0OyZCkhe+pwG8DVyVZ35b9KXAgQFW9B3gBcHKS7cAPgROqqkYQqyTNOSbMkrTAVdWXgUxR553AO4cTkSTNLw7JkCRJknowYZYkSZJ6MGGWJEmSejBhliRJknowYZYkSZJ6MGGWJEmSejBhliRJknowYZYkSZJ6MGGWJEmSejBhliRJknowYZYkSZJ6GFjCnGRZkq8kuTLJNUn+rC0/KMllSTYmWZtkl7Z813Z9Y7t95aBikyRJkvo1yB7mbcAzq+oJwCrg2CRPAd4CnFVVPwt8H3hFW/8VwPfb8rPaepIkSdJIDSxhrsbd7erS9lbAM4GPt+XnAM9rl49v12m3H50kg4pPkiRJ6sdAxzAnWZJkPXArcCHwLeD2qtreVtkE7N8u7w/cBNBuvwPYu8s+VydZl2Tdli1bBhm+JEmSNNiEuarurapVwArgCOCxs7DPs6tqrKrGli9fPtPdSZIkST0NZZaMqroduAj4RWCPJA9qN60ANrfLm4EDANrtDwe2DiM+SZIkaTKDnCVjeZI92uUHA8cA19Ekzi9oq50I/HO7fH67Trv9i1VVg4pPkiRJ6seDpq4ybfsB5yRZQpOYn1dVn05yLXBukj8Hvga8r63/PuDDSTYCtwEnDDA2SZIkqS8DS5iragNwWJfyb9OMZ55Yfg/wm4OKR5IkSZoOr/QnSZIk9WDCLEmSJPVgwixJkiT1YMIsSZIk9WDCLEmSJPUwyGnlJEmSpmXN+jUPKDtl1SkjiESyh1mSJEnqyYRZkiRJ6sGEWZIkSerBhFmSJEnqwYRZkiRJ6sGEWZIkSerBhFmSJEnqwYRZkiRJ6sGEWZIkSerBhFmSJEnqwYRZkha4JAckuSjJtUmuSfIHXeokyTuSbEyyIcnho4hVkuaiB406AEnSwG0H/rCqrkiyO3B5kgur6tqOOs8GDm5vTwbe3f6VpEXPHmZJWuCq6uaquqJdvgu4Dth/QrXjgQ9V41JgjyT7DTlUSZqTTJglaRFJshI4DLhswqb9gZs61jfxwKRakhYlE2ZJWiSS7Ab8E/DqqrpzmvtYnWRdknVbtmyZ3QAlaY5yDLOkOeesC6+fss5pxxwyhEgWjiRLaZLlj1TVJ7pU2Qwc0LG+oi3bQVWdDZwNMDY2VgMIVZLmHHuYJWmBSxLgfcB1VfU3k1Q7H3hZO1vGU4A7qurmoQUpSXOYPcyStPA9Ffht4Kok69uyPwUOBKiq9wAXAMcBG4EfAC8ffpiSZmqqX+j8dW56TJglaYGrqi8DmaJOAacOJyJJml8GNiRjsonyk5yZZHOS9e3tuI77nNFOmv+NJM8aVGySJElSvwbZw9x1ovx221lV9dbOykl+HjgBOBR4JPD5JIdU1b0DjFGSJEnqaWA9zH1OlN/peODcqtpWVTfQjKM7YlDxSZIkSf0YyiwZXSbKf1WSDUnen2TPtsxJ8yVJkjTnDDxh7jJR/ruBRwOrgJuBv97J/TlpviRJkoZmoAlzt4nyq+qWqrq3qn4CvJf7h130PWl+VY1V1djy5csHGb4kSZI00Fkyuk6Un2S/jmrPB65ul88HTkiya5KDgIOBrwwqPkmSJKkfg5wlY7KJ8l+cZBVQwI3A7wFU1TVJzgOupZlh41RnyJAkSdKoDSxh7jFR/gU97vNG4I2DikmSJEnaWUOZJUOSJEmar0yYJUmSpB5MmCVJkqQeTJglSZKkHvpKmJN8IslzkphgS9II2R5L0vD12+CuAX4L+GaSNyd5zABjkiRNzvZYkoasr4S5qj5fVS8BDqeZO/nzSf4jycvbq/lJkobA9liShq/vn/SS7A2cBPwu8DXg7TQN9oUDiUyS1JXtsSQNV18XLknySeAxwIeBX6+qm9tNa5OsG1RwkqQd2R5L0vD1e6W/91bVDlfoS7JrVW2rqrEBxCVJ6s72WJKGrN8hGX/epew/ZzMQSVJfbI8lach69jAneQSwP/DgJIcBaTc9DHjIgGOTJLVsjyVpdKYakvEsmhNLVgB/01F+F/CnA4pJkvRAtseSNCI9E+aqOgc4J8lvVNU/DSkmSdIEtseSNDpTDcl4aVX9A7AyyWsmbq+qv+lyN0nSLLM9lqTRmWpIxkPbv7sNOhBJUk+2x5I0IlMNyfi79u+fDSccSVI3tseSNDp9TSuX5C+TPCzJ0iRfSLIlyUsHHZwkaUe2x5I0fP3Ow/yrVXUn8GvAjcDPAv9nUEFJkiZleyxJQ9Zvwjw+dOM5wD9W1R0DikeS1JvtsSQNWb+Xxv50kq8DPwROTrIcuGdwYUmSJmF7LElD1lcPc1WdDvwSMFZVPwb+Bzh+kIFJkh7I9liShq/fHmaAx9LM/9l5nw/NcjySpKnZHkvSEPWVMCf5MPBoYD1wb1tc2EBL0lDZHkvS8PXbwzwG/HxV1SCDkSRNyfZYc96a9WtGHYI0q/qdJeNq4BGDDESS1BfbY0kasn57mPcBrk3yFWDbeGFVPXeyOyQ5gOYnwn1pfi48u6renmQvYC2wkmYO0RdW1feTBHg7cBzwA+Ckqrpip5+RJC1sO90eS5Jmpt+E+cxp7Hs78IdVdUWS3YHLk1wInAR8oarenOR04HTgT4BnAwe3tycD727/SpLud+bO3iHJ+2kudHJrVT2uy/YjgX8GbmiLPlFVb5h+iJK0sPSVMFfVxUkeBRxcVZ9P8hBgyRT3uRm4uV2+K8l1wP400x8d2VY7B/gSTcJ8PPChdlzepUn2SLJfux9JEtNrj4EPAu+k94mB/1ZVvzZLYWqii97Ue/tRZwwnDknT0tcY5iT/D/Bx4O/aov2BT/X7IElWAocBlwH7diTB36UZsjG+z5s67rapLZu4r9VJ1iVZt2XLln5DkKQFYTrtcVVdAtw22MgkaeHq96S/U4GnAncCVNU3gZ/u545JdgP+CXh1Vd3Zua3tTd6pM72r6uyqGquqseXLl+/MXSVpIZh2ezyFX0xyZZLPJDl0FvYnSQtGv2OYt1XVj5rz8qCdLH/KRDfJUppk+SNV9Ym2+JbxoRZJ9gNubcs3Awd03H1FWyZJut+02uMpXAE8qqruTnIcTY/1wd0qJlkNrAY48MADZ/iw88BUQynA4RTSItBvD/PFSf4UeHCSY4B/BP6l1x3aWS/eB1xXVX/Tsel84MR2+USaE03Gy1+WxlOAOxy/LEkPsNPt8VSq6s6qurtdvgBYmmSfSer6K5+kRaffhPl0YAtwFfB7wAXA/zvFfZ4K/DbwzCTr29txwJuBY5J8E/iVdp12n98GNgLvBU7ZmSciSYvEdNrjnpI8ou3kIMkRNN8NW2cYpyQtGP3OkvGTJJ8CPlVVfZ1pV1VfBjLJ5qO71C+asXmSpElMpz1O8jGa2Yn2SbIJeD2wtN3fe4AXACcn2Q78EDjBKwlK0v16Jsxtj8PrgVfR9kYnuRf4W+folKThmUl7XFUvnmL7O2mmnZMkdTHVkIzTaIZWPKmq9qqqvWguJvLUJKcNPDpJ0jjbY0kakakS5t8GXlxV41d/oqq+DbwUeNkgA5Mk7cD2WJJGZKqEeWlVfW9iYTtubulgQpIkdWF7LEkjMlXC/KNpbpMkzS7bY0kakalmyXhCkju7lAdYNoB4JEnd2R5L0oj0TJirasmwApE0t5114fWjDmFRsz2ew/q5GqCkea3fS2NLkiRpnuvV+XHaMYcMMZL5pd8r/UmSJEmLkgmzJEmS1IMJsyRJktSDCbMkSZLUgyf9SZqX+pm1wxNYJEmzwR5mSZIkqQcTZkmSJKkHE2ZJkiSpBxNmSZIkqQdP+pN21mxdBveoM2ZnP5IkaaBMmLV4zFaiK0mSFhUTZkmSJE05XedinqrTMcySJElSD/YwSyO0Zv2aWd/nKatOmfV9SpK0mJkwSwvMbCfhJuCSpMXOhFmSJM0Lk3UI+I+9Bs0xzJIkSVIPA0uYk7w/ya1Jru4oOzPJ5iTr29txHdvOSLIxyTeSPGtQcUmSJEk7Y5A9zB8Eju1SflZVrWpvFwAk+XngBODQ9j5rkiwZYGySJElSXwaWMFfVJcBtfVY/Hji3qrZV1Q3ARuCIQcUmSZIk9WsUY5hflWRDO2Rjz7Zsf+Cmjjqb2rIHSLI6ybok67Zs2TLoWCVJkrTIDXuWjHcD/xeo9u9fA7+zMzuoqrOBswHGxsZqtgPUHOQlrSVJ0ggNNWGuqlvGl5O8F/h0u7oZOKCj6oq2TJKkB+rnH+mjzhh8HJIWhaEOyUiyX8fq84HxGTTOB05IsmuSg4CDga8MMzZJkiSpm4H1MCf5GHAksE+STcDrgSOTrKIZknEj8HsAVXVNkvOAa4HtwKlVde+gYpMkSdLccdaF1/fcftoxhwwpku4GljBX1Yu7FL+vR/03Am8cVDySJEnSdHilP0mSJKkHE2ZJkiSpBxNmSZIkqQcTZkmSJKkHE2ZJWgTaq6vemuTqSbYnyTuSbGyvxnr4sGOUpLnKhFmSFocPAsf22P5smjnwDwZW01yZVZKECbMkLQpVdQlwW48qxwMfqsalwB4TLjYlSYuWCbMkCWB/4KaO9U1t2Q6SrE6yLsm6LVu2DC04SRolE2ZJUt+q6uyqGquqseXLl486HEkaChNmSRLAZuCAjvUVbZkkLXomzJIkgPOBl7WzZTwFuKOqbh51UJI0Fzxo1AFIkgYvyceAI4F9kmwCXg8sBaiq9wAXAMcBG4EfAC8fTaSSNPeYMEs7Yc3tG2ZvZ+vXzN6+pClU1Yun2F7AqUMKR5LmFRNmSZIkzWlnXXh9z+2nHXPIQB/fMcySJElSDybMkiRJUg8OyZBG5YZ/m539HPT02dmPJEnqyh5mSZIkqQcTZkmSJKkHE2ZJkiSpBxNmSZIkqQcTZkmSJKkHE2ZJkiSpBxNmSZIkqQcTZkmSJKmHgSXMSd6f5NYkV3eU7ZXkwiTfbP/u2ZYnyTuSbEyyIcnhg4pLkiRJ2hmDvNLfB4F3Ah/qKDsd+EJVvTnJ6e36nwDPBg5ub08G3t3+1Xx20ZtGHYEkSdKMDayHuaouAW6bUHw8cE67fA7wvI7yD1XjUmCPJPsNKjZJkiSpX4PsYe5m36q6uV3+LrBvu7w/cFNHvU1t2c1MkGQ1sBrgwAMPHFykkgBYs34NAFfcuXVW9nf4w140K/uRJGlYRnbSX1UVUNO439lVNVZVY8uXLx9AZJIkSdL9hp0w3zI+1KL9e2tbvhk4oKPeirZMkiRJGqlhJ8znAye2yycC/9xR/rJ2toynAHd0DN2QJEmSRmZgY5iTfAw4EtgnySbg9cCbgfOSvAL4DvDCtvoFwHHARuAHwMsHFZckSZK0MwaWMFfViyfZdHSXugWcOqhYJEmSpOnySn+SJElSDybMkiRJUg/DnodZkiQtEOPztEsLnQmzJEmjdtGbpq5z1BmDj0NSVybMkvjPb83OVfwkSVqIHMMsSZIk9WAPsyRJ0hxy1oXXT7rttGMOGWIkGmcPsyRJktSDPcxa0NbcvmHUIUiSNGt69T5rcOxhliRJknowYZYkSZJ6MGGWJEmSejBhliRJknowYZYkSZJ6cJYMSZI0r61Zv+YBZaesOmUEkWihsodZkhaBJMcm+UaSjUlO77L9pCRbkqxvb787ijglaS6yh1mSFrgkS4B3AccAm4CvJjm/qq6dUHVtVb1q6AEOykVvmrrOUWcMPg5J8549zJK08B0BbKyqb1fVj4BzgeNHHJMkzRsmzJK08O0P3NSxvqktm+g3kmxI8vEkB3TbUZLVSdYlWbdly5ZBxCpJc45DMvRA/fyMKWmh+RfgY1W1LcnvAecAz5xYqarOBs4GGBsbq+GGKEmjYQ+zJC18m4HOHuMVbdl9qmprVW1rV/8eeOKQYpOkOc+EWZIWvq8CByc5KMkuwAnA+Z0VkuzXsfpc4LohxidJc5pDMiRpgauq7UleBfwrsAR4f1Vdk+QNwLqqOh/4/STPBbYDtwEnjSxgSZpjTJglLVhnXXj9lHVOO+aQIUQyelV1AXDBhLLXdSyfATjHmiR1YcIsSZKkgeunE2OuGknCnORG4C7gXmB7VY0l2QtYC6wEbgReWFXfH0V8kiRJ0rhRnvR3VFWtqqqxdv104AtVdTDwhXZdkiRJGqm5NEvG8TTzftL+fd7oQpEkSZIao0qYC/hcksuTrG7L9q2qm9vl7wL7jiY0SZIk6X6jOunvaVW1OclPAxcm+XrnxqqqJF2vINUm2KsBDjzwwMFHKkkaPq84KmkOGUkPc1Vtbv/eCnwSOAK4ZXzi/PbvrZPc9+yqGquqseXLlw8rZEmSJC1SQ0+Ykzw0ye7jy8CvAlfTXHXqxLbaicA/Dzs2SZIkaaJRDMnYF/hkkvHH/2hVfTbJV4HzkrwC+A7wwhHEJkmSJO1g6AlzVX0beEKX8q3A0cOOR5K0iDlWWlIfvNKfJEmSpjTVlfpOO+aQIUUyfHNpHmZJkiRpzjFhliRJknowYZYkSZJ6cAyzJEnzQT8nKB51xuDjkBYhe5glSZKkHuxhljRUV9y5dlb3d/jDXjSr+5MkTc9Us2jMZybMmlPW3L5h1CFIkrpYs37NqEOQRsaEWZI0XF4sRNI84xhmSZIkqQcTZkmSJKkHE2ZJkiSpB8cwLySOC5QkSZp19jBLkiRJPZgwS5IkST04JEPSotbPRPunHXPIECKRJM1V9jBLkiRJPdjDrGnzqnzzw39+a+uoQ5AkaV6zh1mSJEnqwR5mSZJ0nzXr14w6hFkx2fM4ZdUpQ45EC4E9zJIkSVIPJsySJElSDybMkiRJUg+OYZ4LvKS1NKc5V7MkLW72MEuSJEk9mDBLkiRJPcy5IRlJjgXeDiwB/r6q3jzikBYMLzQiLV5Tta1JdgU+BDwR2Aq8qKpuHHackjQXzamEOckS4F3AMcAm4KtJzq+qa2f1gWZrzPBRZ8zOfiZhgitpNvTZtr4C+H5V/WySE4C3AC8afrSSNPfMtSEZRwAbq+rbVfUj4Fzg+BHHJEnzXT9t6/HAOe3yx4Gjk2SIMUrSnDWnepiB/YGbOtY3AU/urJBkNbC6Xb07yTem8Tj7AN+bVoQ7+NOZ76IxS/HMGuPpbY7Fc+4ciwcY4jH6B17XT7WBx/Oanas+Hs+jBhFLF1O2rZ11qmp7kjuAvZlw3GapDZ6uufJenytxwANimbXvpRnGMTJTxnEqp86JOIZkrsQBA45lJ9rgiXH01Q7PtYR5SlV1NnD2TPaRZF1Vjc1SSDNmPL0ZT29zLR6YezEZz+yZjTZ4uubKcZsrccDcicU4jGMqcyWW6cYx14ZkbAYO6Fhf0ZZJkqavn7b1vjpJHgQ8nObkP0la9OZawvxV4OAkByXZBTgBOH/EMUnSfNdP23o+cGK7/ALgi1VVQ4xRkuasOTUkox039yrgX2mmPnp/VV0zgIcayc+JPRhPb8bT21yLB+ZeTIs6nsna1iRvANZV1fnA+4APJ9kI3EaTVM81c+V1nCtxwNyJxTh2ZBwPNFdimVYcsQNBkiRJmtxcG5IhSZIkzSkmzJIkSVIP8zphTrJXkguTfLP9u+ck9U5s63wzyYkd5W9MclOSuyfUf02Sa5NsSPKFJI/q2HZvkvXt7QEnJA4wpl2TrE2yMcllSVZ2bDujLf9GkmfNcjxPTHJVu/93jF/IoI1l/DjcmGR9W74yyQ87tr1nSPGcmWRzx+MeN+Lj81dJvt6+hz6ZZI9exyfJsW18G5Oc3uXxd/r1n2yfaU78uqwtX5vmJLCJjzer8SQ5IMlFaT5X1yT5g476k752g4qnLb+xfe3WJ1nXUT7le2IAx+cxHc9/fZI7k7y63+OzUE32OepSr+frMQtx/Gb7vv1Jkkmno5rsPTWiWAZ9TPptO3t+Z87g8af9GZxNfcRxUpItHcfgdwcUx/uT3Jrk6km2J8131Mb283T4iOI4MskdHcejr4n0pxHHpN85HXV27phU1by9AX8JnN4unw68pUudvYBvt3/3bJf3bLc9BdgPuHvCfY4CHtIunwys7dh294hiOgV4T7t8wnhMwM8DVwK7AgcB3wKWzGI8X2ljCvAZ4Nld7v/XwOva5ZXA1QM8Pl3jAc4E/qjLvkZyfIBfBR7ULr9lfL/djg/NSVjfAn4G2KWN9+dn8vr32idwHnBCu/we4OQhxLMfcHhbZ3fg+o54ur52g4yn3XYjsM/OvkcHFc+E/X8XeFQ/x2ch35jkc7Szr8csxPFzwGOALwFjPep1fU8NO5YhHZMp2852W8/vzGk+9rQ/gyOI4yTgnYN8T7SP88vA4Uzy/QscR/MdFZrvrMtGFMeRwKeHcDwm/c6Z7jGZ1z3M7Hgp13OA53Wp8yzgwqq6raq+D1wIHAtQVZdW1c0T71BVF1XVD9rVS2nmLB1pTEx+2drjgXOraltV3QBspLkM7ozjSbIf8LA2pgI+NPH+bQwvBD7WZb/dDDSeSR5v6Menqj5XVdvb+0/1HprJZYsne35d99ne55ntPiZ7zrMeT1XdXFVXtMfmLuA6mivL9WMQx6eXqd4Tg47naOBbVfWdKeJc8Pr8HPXzesw0juuqaphXNJxUn7EM/JjQX9s5KHPlUu/DOM59qapLaGa3mczxwIeqcSmwR/sdNuw4hqLP75ydOibzPWHetyO5/C6wb5c63S4J2+8XNcAraP4DGbcsyboklyZ53hBj2uGytcD4ZWun2tdM4tm/Xe4V59OBW6rqmx1lByX5WpKLkzx9Qv1BxvOq9meV93f8PDjq4wPwO+z4Hpp4fPp5P+zs6z9Z+d7A7R1JSM/HmsV47tP+NHoYcFlHcbfXbtDxFPC5JJenudzzuKneEwM9PjS9YRP/Ae11fBaLiZ+jcTNt42fTZO+pYRvGMemn7YSpvzOnYyafwdnU73H+jfbz+/EkB3TZPgxz6XPyi0muTPKZJIcO+sEm+c6BnTwmcz5hTvL5JFd3ue3wX1zbw1ez/NgvBcaAv+oofhRwO81P8+cluX6YMU3i9PEYgOcDfzPEeF7Mjl/uNwPrgKU0b7wvtmOIBh3Pu4FHA6vaGP66Y9vIjk+S1wLbgY+0RTcDB1bVYcBrgI8CD57Nx5zLkuwG/BPw6qq6sy3u9doN0tOq6nDg2cCpSX55YoUhfoYBSDOe/LnAP3YUj+r4DEU/bXyXz9FI4ujDlO+pIcYyY7P0/fuoai5D/FvA25I8etBxzzH/Aqysql+g+XXynCnqL3RX0LwnngD8LfCpQT7YJN850zKnLlzSTVX9ymTbktySZL+qurntRr+1S7XNNGNmxq2gGfvVU5JfAV4LPKOqtnXEsxn4lbbOB2nG4ny8436Dimn8srWbsuNlazcDH6mqN7WP/6/AmVX1n7MQz2Z2/Al0h8vptnH8L+CJ42XtsXpGR50v0Yy/XDfIeKrqlo7HfC/w6Y59jer4nAT8GnB0+4Uyfny2tcuXJ/kWzeew38sWd3v9J7tvt/KtND87Pajtdel5ieTZjCfJUpqG6yNV9YnxCj1eu4HG036Wqapbk3yS5ufVS4Cp3hMDiaf1bOCKzmPSx/GZ13q18dD9czRBP6/HjOPocx+TvaeGHcvAj0mfbWfnMfl2+31wGM2435mYyWdwNk0ZR1V1Pubf04z9HoVZeU/MVGfSWlUXJFmTZJ+q+t5sP9Zk3zkddu6Y1IAHXg/yRtPz23nSwV92qbMXcANNj/Ce7fJeE+pMPMFu/AN98ITyPYFd2+V9gG/ywEHkg4rpVHY8geG8dvlQdjyJ6NvseFLbjOLhgSe1Hddxv2OBiyfsazn3n1T1M+2bb69BxwPs13H/02jGiY7s+LTH5lpgeR/HZ3kb10Hcf+LIoTN5/WmS8K77pOm97Dzp75QJjzXpfWcQT2jGeL+ty/Ht+toNOJ6HAru3dR4K/AdwbD/viUHE03G/c4GX78zxWcg3Jvkc7ezrMYvxfInJT7Sb9D01glgGfkym+py05VN+Z07zsaf9GZzlY9BPHJ2f3+cDlw7wPbGSyU+2ew47nuD2lRHF8Qjuv2jeEcB/ja/PcgyTfudM95gM5GAN60YzHukL7Yfw89yfxIwBf99R73doTq7Z2PllRPOf3ibgJ+3fM9vyzwO3AOvb2/lt+S8BV7UfiquAVwwxpmU0ic5GmiTtZzru81qaBP8bTJjFYhbiGQOubvf/zs43NvBB4JUTHu83gGva43YF8OvDiAf4cPuabADOZ8dGaujHp613U8d76D29jg/N2brXt/t5bVv2BuC50339u+2zLf+Zdh8b233u2uV9PKvxAE+j+cl2Q8cxOW6q126A8fwMzef4yvb16Dw+Xd8Tg4ynLX8oTQ/Ywyc81pTHZ6HemPxz9Ejggqne67MYx/Np2uNtNN8N/zoxjl7vqWHHMqRjMmXbSR/fmTN4/Gl/Bmf5OEwVx5va98OVwEXAYwcUx8dohmz9uH1/vAJ4Je13NE1S+K42zqvoMdvLgON4VcfxuBT4pQHF0fU7ZybHxEtjS5IkST3M+ZP+JEmSpFEyYZYkSZJ6MGGWJEmSejBhliRJknowYZYkSZJ6MGHWvJfkeUkqyWOnqPfqJA/pWL8gyR7TeLw9kpzSsf7IJB/vdR9JWqhsg7UYOK2c5r0ka2nmIP1iVb2+R70baeZZnNEVhdJcl/7TVfW4mexHkhYC22AtBvYwa15rrxP/NJrJ0U9oy5YkeWuSq5NsSPK/k/w+TYN+UZKL2no3JtknyZuTnNqxzzOT/FGS3ZJ8IckVSa5Kcnxb5c3Ao5OsT/JXSVYmubq977IkH2jrfy3JUW35SUk+keSzSb6ZZFSXR5WkWWMbrMXiQaMOQJqh44HPVtX1SbYmeSLN5TZXAquqanuSvarqtiSvAY7q0ruxFngbzRV/AF4IPAu4B3h+Vd2ZZB/g0iTn01wG9nFVtQru6+0YdypQVfX49ufJzyU5pN22iuay69uAbyT526q6adaOhCQNn22wFgUTZs13Lwbe3i6f264fRHMJ3e0AVXVbrx1U1deS/HSSRwLLge9X1U1JlgJ/keSXaS5Vvj+w7xTxPA3423a/X0/yHWC8sf5CVd0BkORa4FE0l/2VpPnKNliLggmz5q0kewHPBB6fpIAlNNeO/+o0dvePwAuAR9D0dgC8hKbxfmJV/bgdf7dsBiFv61i+Fz9/kuYx22AtJo5h1nz2AuDDVfWoqlpZVQcANwBXAr+X5EFwX6MOcBew+yT7Wksz/u4FNA03wMOBW9uG+iia3oip9vNvNI087c+ABwLfmObzk6S5zDZYi4YJs+azFwOfnFD2T8B+wH8BG5JcCfxWu+1s4LPjJ5x0qqpraBrgzVV1c1v8EWAsyVXAy4Cvt3W3Av/entDyVxN2tQb4qfY+a4GTqmobkrTw2AZr0XBaOUmSJKkHe5glSZKkHkyYJUmSpB5MmCVJkqQeTJglSZKkHkyYJUmSpB5MmCVJkqQeTJglSZKkHv5/gp4HripDjGkAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1303,7 +1335,7 @@ ], "source": [ "f, (ax1, ax2) = plt.subplots(1, 2, figsize=(10,5))\n", - "ax1.set_title('Small weights')\n", + "ax1.set_title('Low weights')\n", "ax1.set_xlabel('Activation')\n", "ax1.set_ylabel('Density')\n", "ax1.hist(act_exc_balanced.mean(axis=0), bins=10, alpha=0.5, density=True, label='E')\n", @@ -1328,15 +1360,14 @@ "id": "a22be55c", "metadata": {}, "source": [ - "We first note that the the total activation is close to zero with a slight shift to negative values.\n", - "This self balancing gives the networks stability and prevents the divergence of the activity.
\n", + "We first note that the the total activation is close to zero with a slight shift to negative values, this prevents the divergence of activity.
\n", "Secondly, we observe that the width of the distributions is orders of magnitude larger in the high weight case as compared to the low weight network.
\n", "Finally, we look at the evolution of the mean activation over time. To this end we plot three random sample:" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 29, "id": "d7d38f3d", "metadata": { "scrolled": true @@ -1344,7 +1375,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1359,7 +1390,7 @@ "time_steps = np.arange(offset, num_steps, 1)\n", "\n", "f, (ax1, ax2) = plt.subplots(1, 2, figsize=(8,4))\n", - "ax1.set_title('Small weights')\n", + "ax1.set_title('Low weights')\n", "ax1.set_xlabel('Time step')\n", "ax1.set_ylabel('Activation')\n", "for i in range(3):\n", @@ -1381,10 +1412,9 @@ "id": "88197c24", "metadata": {}, "source": [ - "We observe, in accordance with the above histograms, that the distribution of the total activation in the small weights case is much narrower than in the high weights network.
\n", - "Moreover, we see that the intrinsic time scale of the fluctuation of the total activation is very different in both networks:\n", - "In the high weights network, the fluctuation evolves on a very long time scale as compared to the other network.
\n", - "This implies that a neuron can sustain it's active, bursting state over longer periods of time leading to memory in the network as well as activity at the edge of chaos: the different states are caused by the *vastly different activation regimes* induced by the recurrent activity.
" + "We see that the temporal evolution of the total activation in the low weights case is much narrower than in the high weights network.
\n", + "Moreover, we see that in the high weights network, the fluctuations of the activations evolve on a very long time scale as compared to the other network.
\n", + "This implies that a neuron can sustain it's active, bursting state over longer periods of time leading to memory in the network as well as activity at the edge of chaos.
" ] }, { @@ -1392,7 +1422,7 @@ "id": "a3358a9d", "metadata": {}, "source": [ - "### Runnig a ProcessModel bit-accurate with Loihi\n", + "### Running a ProcessModel bit-accurate with Loihi\n", "So far, we have used neuron models and weights that are internally represented as floating point numbers.
\n", "Next, we turn to bit-accurate implementations of the LIF and Dense process where only a fixed precision for the numerical values is allowed. Here, the parameters need to be mapped to retain the dynamical behavior of the network.
\n", "First, we define a method for mapping the parameters. It consists of finding an optimal scaling function that consistently maps all appearing floating-point numbers to fixed-point numbers." @@ -1400,7 +1430,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 30, "id": "3cf38774", "metadata": {}, "outputs": [], @@ -1525,7 +1555,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 31, "id": "3d0043ce-2f6f-4f37-8b61-4a8607bac86b", "metadata": {}, "outputs": [ @@ -1565,13 +1595,13 @@ "id": "933c833f-f492-46ad-b2af-d101cb401f33", "metadata": {}, "source": [ - "We note that for both variables the distributions attain high (small) values with low probability. We hence will remove them in the dynamical range to increase the precision of the overall representation. We do so by choosing $0.15$ and $0.85$ quantiles as minimal resp. maximal values for the dynamic ranges.
\n", + "We note that for both variables the distributions attain large (small) values with low probability. We hence will remove them in the dynamical range to increase the precision of the overall representation. We do so by choosing $0.15$ and $0.85$ quantiles as minimal resp. maximal values for the dynamic ranges.
\n", "We finally also need to pass some information about the concrete implementation, e.g. the precision and the bit shifts performed.
" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 32, "id": "daab0580-90a7-4e55-97c3-fcf596399f74", "metadata": {}, "outputs": [], @@ -1604,7 +1634,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 33, "id": "c3cfecc6", "metadata": {}, "outputs": [], @@ -1638,7 +1668,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 34, "id": "8b10fe25", "metadata": {}, "outputs": [], @@ -1681,7 +1711,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 35, "id": "a29e3abe", "metadata": {}, "outputs": [ @@ -1716,7 +1746,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 36, "id": "b5881949", "metadata": {}, "outputs": [], @@ -1728,20 +1758,10 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 37, "id": "92cee6ee", "metadata": {}, "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { "image/png": "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\n", @@ -1764,7 +1784,8 @@ "plt.ylabel('Covariance')\n", "plt.plot(lags, ac_fct_lif_critical_fixed, label='Bit accurate model')\n", "plt.plot(lags, ac_fct_lif_critical, label='Floating point model')\n", - "plt.legend()" + "plt.legend()\n", + "plt.show()" ] }, {