def simulate(seed, dt): """ simulate 10 progressive recall of the original pattern at different dt according to the STDP rule found experimentally """ ncells = 3000 # number of cells c = 0.5 # connection probability a = 0.1 # activity of a pattern m = 50 # number of patterns to store g1 = 0.433 # slope of inhibitory component W = topology(ncells, c, seed) Z = Pattern(ncells, a) Y = generate(Z, m) J = clipped_Hebbian(Y, W) J = J*delta_t(dt) overlap = np.empty(10) X = Y[0] # initial pattern for i in range(10): h = np.inner(J.T, X)/float(ncells) spk_avg = np.mean(X) X = ( h < g1*spk_avg ).choose(1,0) overlap[i] = get_overlap(Z, X) return(overlap)
def __init__(self, n, c, a, m, g1, seed=None): """ Create the connectivity matrix W and generate the matrix of synaptic weigths J according to Gibson & Robinson 1992 Arguments: n -- number of cells c -- connection probability a -- activity of a pattern m -- number of patterns to store g1 -- slope of the inhibitory component """ self.n = n self.c = c self.a = a self.m = m self.g1 = g1 # this can be only return by getters self.W = None self.Z = Pattern(self.n, self.a) self.Y = generate(self.Z, self.m) self.J = None # self.seed = seed self.__call__(seed) # will update self.seed
def create_synaptic_weights(seed): """ create a matrix of synaptic weigths according to the clipped_Hebbian rule describied in Gibson & Robinson 1992 returns the matrix of connectivity, the original pattern and the matrix of synaptic weights """ W = topology(ncells, c, seed) Z = Pattern(ncells, a) Y = generate(Z, m) J = clipped_Hebbian(Y,W) return(W, Z, Y, J)
def create_synaptic_weights(seed): """ simulate 10 progressive recalls of a partial pattern at different dt according to the STDP rule found experimentally Returns: The connectivity matrix The original pattern to be recall The matrix of synaptic weights """ W = topology(ncells, c, seed) Z = Pattern(ncells, a) Y = generate(Z, m) J = clipped_Hebbian(Y, W) return(W, Z, Y, J)
# ========================================================================= from network import topology from firings import Pattern from firings import generate, get_valid, get_spurious, get_overlap from plasticity import clipped_Hebbian from plots import raster_plot import numpy as np import sys myseed = int(sys.argv[1]) # read the first argument of the command ncells = 3000 W = topology(n=ncells, c=0.5, seed=myseed) Z = Pattern(n=ncells, a=0.1) Y = generate(Z, m=50) J = clipped_Hebbian(Y, W) # 8.93 s # Recall X = Y[0] # The initial state is exactly the same as the initial pattern nrecall = 6 spikes = np.empty((nrecall, ncells)) X = Y[0] # The initial state is exactly the same as the initial pattern for i in range(6): # progressive recall in 6 steps h = np.inner(J.T, X) / float(ncells) # 86.8 ms per loop print("recall [%d]:" % i),
""" test_clipped.py To test the clipped_Hebbian rule """ import numpy as np from firings import Pattern, generate from plasticity import clipped_Hebbian W = np.array(([0,1,0,0,0], [0,0,1,0,0], [0,0,0,1,0], [0,0,0,0,1], [1,0,1,0,0]),dtype=int) Z = Pattern(n=5, a=.6) Y = generate(Z, m=3) J = clipped_Hebbian(Y,W) print(J)