# 1.4. Changelog¶

4.6.3

• pre_spike and post_spike fields of a spiking neuron can now modify pre and post synaptic variables:

pre_spike = """
g_target += w
post.nb_spikes += 1
"""

• SpikeSourceArray available on CUDA.

• Monitor.mean_fr() and Monitor.histogram() now work with PopulationViews (thanks @ilysym).

• Many bug fixes with Python3 and CUDA.

4.6.2

• Rate-coded neurons can now use sum() to sum over all targets, instead of specifying them.
• Constant objects can now be created to define global-level parameters which do not need to be explicitly defined in Neurons/Synapses.
• Parameter definitions can use constants. Note that changing the constant after compilation does not change the parameter.
• The initial value of a variable (init=) can use constants instead of numerical values.
• report() has been improved and can now generate Markdown reports, which can be converted to html or pdf by pandoc.

4.6.1

• Issue 44: The performance of spiking networks with CUDA has been improved.
• Population.compute_firing_rate can now be called anytime to change the window over which the mean firing rate of a spiking neuron is computed.
• The performance of the exponential numerical method has been improved by computing the step size outside the loop (when possible).
• Mean-firing rate computation is now available for CUDA devices (slow!).
• Issue 43: the path to the CUDA installation can now be set in a config file at ~/.config/ANNarchy/annarchy.json.
• Simulations on GPU can be started on the command line by using --gpu or --gpu=2 if you have multiple GPUs.

4.6.0

• CUDA implementation for rate-code networks revised and fixed several errors.

• CUDA now supports now the simulation of spiking neurons (please refer to the documentation to discover limitations).

• CUDA allows now the monitoring of dendrites.

• Added the command line argument –cuda to run simulations on CUDA devices.

• Issue 38: user-defined functions are now available in user space:

add_function('sigmoid(x) = 1.0 / (1.0 + exp(-x))')

compile()

x = np.linspace(-10., 10., 1000)
y = functions('sigmoid')(x)

• Major reimplementation of data structures for the connectivity patterns (LIL, CSR).

• Added the TimedArray population to store the temporal evolution of a population’s firing rate internally. See Setting inputs.

• Fixed structural plasticity and added an example in examples/structural_plasticity.

• Added the projection keyword allowing to declare a single parameter/variable for the whole projection, instead of one value per synapse (the default) or one value per post-synaptic neuron (keyword postsynaptic).

• Parameters can now also be recorded by Monitors.

• Projections can now be monitored, if the user knows what he does...

• The global parameters of populations and projections can now be saved/loaded to/from a JSON file for manual parameterization.

• Many bug fixes.

• Deprecated recording functions and objects such as RateNeuron are removed.

4.5.7

• Sympy 1.0 introduced a regression to the != operator.
• Issue 30: PopulationViews had a bug hen modifying variables on a multidimensional population.
• Issue 33: connect_one_to_one now accepts any kind of popview (even with random indices), as long as they have the same size.
• Issue 33: recording spikes on popviews did not work correctly.
• The normal distribution is fixed in CUDA.
• Delays are now rounded to the next multiple of dt, not cast into a int (i.e. 1.99 is now 2, not 1 with dt=1.0).
• SpikeSourceArray is now tolerant to very high firing schedules.

4.5.6

• Spiking networks can now use variable delays, at the cost of extra computations.

• Fixed bug in parser when a synapse uses pre/post variables with one name containing the other (e.g. r and r_mean).

• Fixed bug when assigning postsynptic variable a random distribution.

• Added the ability to access the weighted sums of a rate-coded population with:

pop.sum('exc')

• Added the ability to record these weighted sums:

m = monitor(pop, ['r', 'sum(exc)'])


4.5.5

• Added the every decorator allowing functions to be called periodically during a simulation:

result = []

@every(period=1000.)
def set inputs(n):
# Set inputs to the network
pop.I = Uniform(0.0, 1.0)
# Save the output of the previous step
result.append(pop.r)

simulate(100 * 1000.)

• Fixed installation with non-standard Python distribution (e.g. Anaconda).

• Added a HomogeneousCorrelatedSpikeTrains class allowing to generate homogeneous correlated spike trains:

pop = HomogeneousCorrelatedSpikeTrains(geometry=200, rates=10., corr=0.3, tau=10.)

• Installing through pip does not forget CUDA files anymore.

• Added Population.clear() to clear all spiking events (also delayed) without resetting the network.

• Population.reset() and Projection.reset() now accept a list of attributes to be reset, instead of resetting all of them.

• Unit tests are now performed on Travis CI to get a badge.

• Bug fixed: min/max bounds on g_target was wrongly analyzed when depending on a parameter.

• parallel_run() now accepts additional arbitrary arguments that can be passed to the simulation callback.

• Added an ite(cond, statement1, statement2) conditional function replicating if cond: statement1 else: statement2, but which can be combined:

r = 1.0 + ite(sum(exc) > 1.0, sum(exc), 0.0) + ite(sum(inh) > 1.0, -sum(inh), 0.0)

• The Network class has several bugs fixed (e.g. disabled populations stay disabled when put in a network).

• Populations have now an “enabled” attribute to read their status.

4.5.4:

• Spiking neurons now define the variable t_last storing the time (in ms) of the last emitted spike.
• Added a method compute_firing_rate() that allows spiking neurons to compute their mean firing rate over a prefined window and store the result (in Hz) into the reserved variable r.
• Fixed bug when using “if a == b”.
• Pre- and post-synaptic occuring at the same time are now both evaluated. The flag unless_post can be set in pre_spike to disable the evaluation of the pre-spike in that case (default behavior for simple_stdp example).
• Fixed code generation for MacOS X, especially when using a non-standard Python installation (e.g. anaconda).
• compile() now accepts a different compiler (g++ or clang++) and custom flags.
• Now works correctly in ipython notebooks.
• Added iPython notebooks to the examples.
• Fixed the load() method when using a single weight, or for very sparse random projections.

4.5.3:

• Projections can be assigned a name.

• A list or Numpy array can be used to slice a Population:

neurons = [1, 4, 17, 34]
subpop = pop[neurons]

• Synapses can be accessed directly at the Projection level with:

proj.synapse(pre, post) # equivalent to proj[post][pre]

• Bugfix: pop[0] now returns a PopulationView containing the neuron 0, not an IndividualNeuron (accessible through pop.neuron(0))

• Various bugfixes in CUDA.

• Bugfix: connect_from_sparse now works with popviews whose ranks are not linearly increasing (e.g. columns)

• Bugfix: IO access to projection data should now be much faster.

• Spiking neurons can have delayed variables.

4.5.2:

• parallel_run() has now control over the seeds.
• report(): fixed nested conditionals and power functions
• Synaptic transmission can be stopped using proj.transmission = False
• Synaptic update can be disabled using proj.update = False
• Synaptic plasticity can be disabled using proj.plasticity = False
• enable_learning() accepts period and offset arguments.

4.5.1:

• Fixed compilation on MacOSX
• Fixed compatibility with Python 3.4
• Refactoring of the generation templates
• Fixed bug introduced by Sympy 0.7.6
• Multiple blocks of ODEs and assignments can now be used in the equations field.
• Parser simplified
• Dense all-to-all connectivity matrices use indices instead of vectors, improves performance.
• Projections initialized with a single weight value and without plasticity now use a double for the weight instead of vector<vector<double>>
• Regression on get_record(reshape=True) fixed.
• CUDA backend improved.
• parallel_run() now uses the minimum between the number of available cores and the total number of networks.
• Several bugs in report.

4.5.0:

• A Network object has been added to run multiple simulations in parallel (parallel_run()). See Parallel simulations and networks.
• Recording goes through the Monitor object. Old recording methods are depreciated. See Recording with Monitors.
• The flag exact is replaced by event-driven. Still works, but will be suppressed in future versions.
• The behavior of a spiking neuron with two coupled variables (e.g. Izhikevich) during the refractory period is changed. The ODEs are not evaluated at all during the refractory period (except the conductances). The unless-refractory flag has no effect anymore. Before, u started decaying during the refractory period.
• Variables updated in pre-spike or post-spike (spiking synapse) can now define min/max bounds. Useful to avoid clipping explicitly the weights.
• Change in hybrid populations. PoissonPopulation should be used for rate-to-spike conversion, DecodingProjection for spike-to-rate. See Hybrid networks.
• Bug when using conditionals in pre-spike and post-spike.
• Bug when using t_pre and t_post explicitly.
• Speed-up of connect_fixed_number_pre/post.

4.4.0:

• Experimental support for CUDA backend for rate-coded networks.
• Any pre-synaptic variable can be delayed if used in the synapse.
• g_target can define min/max flags.
• Support for MacOS X.
• Parallel performance for OpenMP and spiking networks improved.
• Sequential code (1T) does not use OMP.
• psp argument can use global operations and global variables.
• Added connect_from_sparse() method.

4.3.5:

• Small bug fixes.

4.3.4:

• Several bug fixes.
• The distinction between Rate- and SpikeNeuron objects is deprecated, use Neuron instead.
• The distinction between Rate- and SpikeSynapse objects is deprecated, use Synapse instead.

4.3.3:

• Structural plasticity can be defined at the synaptic level.

4.3.2:

• Random distributions are available in synapses.
• Populations can be momentarily disabled/enabled.
• Recording can be done with a given period instead of every time step.
• Different modes for Spike2Rate conversion.
• Extension for shared projections (convolution/pooling) improved.

4.3.1:

• CUDA implementation for rate-coded networks with small restrictions.
• Weight-sharing for convolutions and pooling.
• Possibility to create projections using a dense connection matrix or data saved in a file.
• A seed can be defined for the random number generators.

4.3.0:

• Simplified internal structure for the generated code.
• Major speed-up for compilation and execution times.
• Rate-coded projections can perform other functions than sum (min/max/mean) over the connected synapses.

4.2.4:

• Neuron and Synapse replace RateNeuron, SpikeNeuron, RateSynapse, SpikeSynapse in the main interface (kept for backward compatibility).
• Default PyNN neural models are now available (Izhikevich, IF_curr_exp, IF_cond_exp, IF_curr_alpha, IF_cond_alpha, HH_cond_exp, EIF_cond_alpha_isfa_ista, EIF_cond_exp_isfa_ista).
• Bug fixes for delays and spike propagation.
• Connectivity matrices (CSR) are more efficient.
• Several PyNN examples are added to the examples/ folder.

4.2.3

• Spike conditions can depend on several variables.
• The midpoint numerical method is added.
• Ability to choose globally the numerical method.

4.2.2

• The Euler implicit method is added.
• Systems of equations are now solved concurrentely.

4.2.1:

• Early-stopping of simulations (simulate_until).

4.2.0:

• Added hybrid populations (Spike2RatePopulaton, Rate2SpikePopulation).
• Individual save/load of populations and projections.
• PopulationViews can be used to build Projections.
• CSR objects are simplified.
• Default conductance behaviour (g_target = 0.0).
• Random distribution objects can take global parameters as arguments.
• min and max bounds can depend on other variables.
• Logical operators (and, or..) can be used in conditions.

4.1.2:

• Rate-coded neurons must output “r”, not “rate”. Synapses must use “w”, not “value”.
• Synapses can access pre-synaptic weighted sums (pre.sum(exc)).
• Created PoissonPopulation.

4.1.1:

• Connectivity matrices are now created in Cython.
• Recording methods have changed.
• Spiking neurons have a refractory period.
• Added clip() functions for semi-linear transfer functions.
• Added smoothed_firing_rate() method for visualizing spiking networks.

4.1.0:

• First stable release with both rate-coded and spiking networks.