def I_networks(landscape, nrow, ncol, ncon, kappa, theta, shift=0, seed=0, **kwargs): np.random.seed(seed) npop = nrow * ncol if landscape['mode'] != 'symmetric': move = cl.move(nrow) ll = cl.__dict__[landscape['mode']](nrow, landscape.get('specs', {})) conmat = [] for ii in range(npop): targets, delay = lcrn.lcrn_gamma_targets(ii, nrow, ncol, nrow, ncol, ncon, kappa, theta) if landscape['mode'] != 'symmetric': # asymmetry targets = (targets + shift * move[ll[ii] % len(move)]) % npop targets = targets[targets != ii] # no selfconnections hist_targets = np.histogram(targets, bins=range(npop + 1))[0] conmat.append(hist_targets) return np.array(conmat)
def EI_networks(landscape, nrowE, ncolE, nrowI, ncolI, p, stdE, stdI, shift=0, seed=0, **kwargs): np.random.seed(seed) npopE = nrowE * ncolE npopI = nrowI * ncolI if landscape['mode'] != 'symmetric': move = cl.move(nrowE) ll = cl.__dict__[landscape['mode']](nrowE, landscape.get('specs', {})) conmatEE, conmatEI, conmatIE, conmatII = [], [], [], [] for idx in range(npopE): # E -> E source = idx, nrowE, ncolE, nrowE, ncolE, int(p * npopE), stdE, False targets, delay = lcrn.lcrn_gauss_targets(*source) if landscape['mode'] != 'symmetric': # asymmetry targets = (targets + shift * move[ll[idx] % len(move)]) % npopE targets = targets[targets != idx] hist_targets = np.histogram(targets, bins=range(npopE + 1))[0] conmatEE.append(hist_targets) # E -> I source = idx, nrowE, ncolE, nrowI, ncolI, int(p * npopI), stdI, False targets, delay = lcrn.lcrn_gauss_targets(*source) hist_targets = np.histogram(targets, bins=range(npopI + 1))[0] conmatEI.append(hist_targets) for idx in range(npopI): # I -> E source = idx, nrowI, ncolI, nrowE, ncolE, int(p * npopE), stdE, False targets, delay = lcrn.lcrn_gauss_targets(*source) hist_targets = np.histogram(targets, bins=range(npopE + 1))[0] conmatIE.append(hist_targets) # I -> I source = idx, nrowI, ncolI, nrowI, ncolI, int(p * npopI), stdI, False targets, delay = lcrn.lcrn_gauss_targets(*source) targets = targets[targets != idx] hist_targets = np.histogram(targets, bins=range(npopI + 1))[0] conmatII.append(hist_targets) return np.array(conmatEE), np.array(conmatEI), np.array( conmatIE), np.array(conmatII)
noise = nest.Create('noise_generator') # Create recording devices sd = nest.Create('spike_detector', params={ 'start': p.recstart, 'to_file': True, 'label': output_file, }) """ Connect nodes """ landscape = cl.__dict__[p.landscape['mode']](p.nrow, p.landscape.get('specs', {})) move = cl.move(p.nrow) offset = pop[0] # Connect neurons to neurons for ii in range(npop): source = ii, p.nrow, p.ncol, p.nrow, p.ncol, p.ncon, p.kappa, p.theta targets, delay = lcrn.lcrn_gamma_targets(*source) if landscape is not None: # asymmetry targets = (targets + p.shift * move[landscape[ii] % len(move)]) % npop # no selfconnections targets = targets[targets != ii] nest.Connect([pop[ii]], (targets + offset).tolist(), syn_spec={'weight': p.Ji}) # Connect noise input device to all neurons nest.Connect(noise, pop)
""" Get spatial connection landscape """ # landscape = None # Symmetric # landscape = cl.random(nrowE, {'seed': 0}) # Homogeneous # landscape = cl.homogeneous(nrowE, {'phi': 3}) # Homogeneous # landscape = cl.Perlin(nrowE, {'size': 4}) # Perlin landscape = cl.Perlin_uniform(nrowE, {'size': 4, 'base': 0}) # Perlin uniform """ Connect neurons """ move = cl.move(nrowE) offsetE = popE[0] offsetI = popI[0] p = 0.05 # 0.05 - 0.1 stdE = 12 stdI = 9 # 9 - 11 shift = 1 # 1 - 3 Jx = 10.0 g = 8 # 4 - 8 syn_specE = {'weight': Jx} for idx in range(npopE): # E-> E
def create_connectivity_EI_random_dir(neuron_parameters, connectivity_parameters, save_AM_parameters): [ nrowE, ncolE, nrowI, ncolI, nE, nI, nN, neuron_type, neuron_paramsE, neuron_paramsI ] = neuron_parameters [landscape_type, landscape_size, asymmetry, p, shift, std, alpha, seed] = connectivity_parameters [pEE, pEI, pIE, pII] = p [stdEE, stdEI, stdIE, stdII] = std [AM_address, fname] = save_AM_parameters if asymmetry[0] == 'E': nrowL = nrowE else: nrowL = nrowI if asymmetry[-1] == 'E': nrowM = nrowE else: nrowM = nrowI move = cl.move(nrowM) if landscape_type == 'symmetric': landscape = None elif landscape_type == 'random': landscape = cl.random(nrowL, {'seed': 0}) elif landscape_type == 'homogenous': landscape = cl.homogeneous(nrowL, {'phi': 3}) elif landscape_type == 'perlin': landscape = cl.Perlin(nrowL, {'size': int(landscape_size)}) elif landscape_type == 'perlinuniform': landscape = cl.Perlin_uniform(nrowL, { 'size': int(landscape_size), 'base': seed }) ran_AM = np.zeros((nN, nN)) dir_AM = np.zeros((nN, nN)) [alphaEE, alphaEI, alphaIE, alphaII] = [0, 0, 0, 0] if asymmetry == 'EE': alphaEE = alpha elif asymmetry == 'EI': alphaEI = alpha elif asymmetry == 'IE': alphaIE = alpha elif asymmetry == 'II': alphaII = alpha for idx in range(nE): targets = [] if (asymmetry == 'EE') and (landscape is not None): targets, delays = lcrn.lcrn_gauss_targets(idx, nrowE, ncolE, nrowE, ncolE, int(pEE * nE * alphaEE), stdEE) targets = (targets + shift * move[landscape[idx] % len(move)]) % nE targets = targets[targets != idx].astype(int) dir_AM[idx, targets] = 1. r_targets = get_random_targets(idx, nrowE, ncolE, nrowE, ncolE, int(pEE * nE * (1 - alphaEE))) r_targets = np.setdiff1d(r_targets, targets) ran_AM[idx, r_targets] = 1. targets = [] if (asymmetry == 'EI') and (landscape is not None): targets, delays = lcrn.lcrn_gauss_targets(idx, nrowE, ncolE, nrowI, ncolI, int(pEI * nI * alphaEI), stdEI) targets = (targets + shift * move[landscape[idx] % len(move)]) % nI dir_AM[idx, targets + nE] = 1. r_targets = get_random_targets(idx, nrowE, ncolE, nrowI, ncolI, int(pEI * nI * (1 - alphaEI))) r_targets = np.setdiff1d(r_targets, targets) ran_AM[idx, r_targets + nE] = 1. for idx in range(nI): targets = [] if (asymmetry == 'IE') and (landscape is not None): targets, delays = lcrn.lcrn_gauss_targets(idx, nrowI, ncolI, nrowE, ncolE, int(pIE * nE * alphaIE), stdIE) targets = (targets + shift * move[landscape[idx] % len(move)]) % nI dir_AM[idx + nE, targets] = 1. r_targets = get_random_targets(idx, nrowI, ncolI, nrowE, ncolE, int(pIE * nE * (1 - alphaIE))) r_targets = np.setdiff1d(r_targets, targets) ran_AM[idx + nE, r_targets] = 1. targets = [] if (asymmetry == 'II') and (landscape is not None): targets, delays = lcrn.lcrn_gauss_targets(idx, nrowI, ncolI, nrowI, ncolI, int(pII * nI * alphaII), stdII) targets = (targets + shift * move[landscape[idx] % len(move)]) % nI targets = targets[targets != idx].astype(int) dir_AM[idx + nE, targets + nE] = 1. r_targets = get_random_targets(idx, nrowI, ncolI, nrowI, ncolI, int(pII * nI * (1 - alphaII))) r_targets = np.setdiff1d(r_targets, targets) ran_AM[idx + nE, r_targets + nE] = 1. print('Multiple connections') print(np.where(ran_AM + dir_AM > 1.)) sparse.save_npz(AM_address + fname + 'random_rAM', sparse.coo_matrix(ran_AM)) sparse.save_npz(AM_address + fname + 'random_dAM', sparse.coo_matrix(dir_AM)) sparse.save_npz(AM_address + fname + 'landscape', sparse.coo_matrix(landscape)) return [ran_AM, dir_AM, landscape, nrowL]
def create_connectivity_EI(neuron_parameters, connectivity_parameters, save_AM_parameters): [ nrowE, ncolE, nrowI, ncolI, nE, nI, nN, neuron_type, neuron_paramsE, neuron_paramsI ] = neuron_parameters [landscape_type, landscape_size, asymmetry, p, std, shift, seed] = connectivity_parameters [pEE, pEI, pIE, pII] = p [stdEE, stdEI, stdIE, stdII] = std [AM_address, fname] = save_AM_parameters if asymmetry[0] == 'E': nrowL = nrowE else: nrowL = nrowI if asymmetry[-1] == 'E': nrowM = nrowE else: nrowM = nrowI move = cl.move(nrowM) if landscape_type == 'symmetric': landscape = None elif landscape_type == 'random': landscape = cl.random(nrowL, {'seed': 0}) elif landscape_type == 'homogenous': landscape = cl.homogeneous(nrowL, {'phi': 3}) elif landscape_type == 'perlin': landscape = cl.Perlin(nrowL, {'size': int(landscape_size)}) elif landscape_type == 'perlinuniform': landscape = cl.Perlin_uniform(nrowL, { 'size': int(landscape_size), 'base': seed }) AM = np.zeros((nN, nN)) for idx in range(nE): targets, delays = lcrn.lcrn_gauss_targets(idx, nrowE, ncolE, nrowE, ncolE, int(pEE * nE), stdEE) if asymmetry == 'EE': if landscape is not None: targets = (targets + shift * move[landscape[idx] % len(move)]) % nE targets = targets[targets != idx].astype(int) AM[idx, targets] = 1. targets, delays = lcrn.lcrn_gauss_targets(idx, nrowE, ncolE, nrowI, ncolI, int(pEI * nI), stdEI) if asymmetry == 'EI': if landscape is not None: targets = ( (targets + shift * move[landscape[idx] % len(move)]) % nI).astype(int) AM[idx, targets + nE] = 1. for idx in range(nI): targets, delays = lcrn.lcrn_gauss_targets(idx, nrowI, ncolI, nrowE, ncolE, int(pIE * nE), stdIE) if asymmetry == 'IE': if landscape is not None: targets = ( (targets + shift * move[landscape[idx] % len(move)]) % nE).astype(int) AM[idx + nE, targets] = 1. targets, delays = lcrn.lcrn_gauss_targets(idx, nrowI, ncolI, nrowI, ncolI, int(pII * nI), stdII) if asymmetry == 'II': if landscape is not None: targets = (targets + shift * move[landscape[idx] % len(move)]) % nI targets = targets[targets != idx].astype(int) AM[idx + nE, targets + nE] = 1. sparse.save_npz(AM_address + fname + 'normalAM', sparse.coo_matrix(AM)) sparse.save_npz(AM_address + fname + 'landscape', sparse.coo_matrix(landscape)) return [AM, landscape, nrowL]