def test_tpl_biphasic_ft():
duration = 42.5
damping = 0.38
delay = 0.0
biphasic_ft = tpl.create_biphasic_ft(duration,
damping,
delay)
assert abs(biphasic_ft(-0.0245436926062) - complex(22.7988820989, -3.1173542118)) < complex(1e-10, 1e-10)
assert abs(biphasic_ft(-0.294524311274) - complex(-1.1286928585, 0.0062065364)) < complex(1e-10, 1e-10)
assert abs(biphasic_ft(-0.564504929942) - complex(-0.3555288674, -0.0651266984)) < complex(1e-10, 1e-10)
assert abs(biphasic_ft(-0.83448554861) - complex(-0.0760582312, -0.0917320759)) < complex(1e-10, 1e-10)
assert abs(biphasic_ft(-1.10446616728) - complex(-0.0021875183, 0.0152324929)) < complex(1e-10, 1e-10)
assert abs(biphasic_ft(-1.37444678595) - complex(-0.0445794299, 0.0315679060)) < complex(1e-10, 1e-10)
assert abs(biphasic_ft(-1.64442740461) - complex(-0.0392905913, 0.0014546807)) < complex(1e-10, 1e-10)
assert abs(biphasic_ft(-1.91440802328) - complex(-0.0259257859, 0.0006440208)) < complex(1e-10, 1e-10)
duration = 20.6
damping = 0.88
delay = 44.5
biphasic_ft = tpl.create_biphasic_ft(duration,
damping,
delay)
assert abs(biphasic_ft(-2.20893233456) - complex(0.0355236623, -0.0472345014)) < complex(1e-10, 1e-10)
assert abs(biphasic_ft(-2.47891295322) - complex(0.0327956407, 0.0088992464)) < complex(1e-10, 1e-10)
assert abs(biphasic_ft(-2.74889357189) - complex(0.0044665680, 0.0035356123)) < complex(1e-10, 1e-10)
assert abs(biphasic_ft(-3.01887419056) - complex(0.0192555610, 0.0001958484)) < complex(1e-10, 1e-10)
def test_biphasic_delta():
integrator = pylgn.Integrator(nt=10, nr=5, dt=0.1, dr=1)
t_vec, x_vec, y_vec = integrator.meshgrid()
w_vec, kx_vec, ky_vec = integrator.freq_meshgrid()
delay_W = t_vec.flatten()[6]
delay_K = t_vec.flatten()[10]
shift_x = x_vec.flatten()[-3]
shift_y = y_vec.flatten()[8]
phase, damping = 42.5 * pq.ms, 0.38
W_ft = tpl.create_biphasic_ft(phase=phase, damping=damping,
delay=delay_W)(w_vec) * spl.create_delta_ft(
shift_x=shift_x)(kx_vec, ky_vec)
K_ft = tpl.create_delta_ft(delay_K)(w_vec) * spl.create_delta_ft(
shift_y=shift_y)(kx_vec, ky_vec)
G = integrator.compute_inverse_fft(W_ft * K_ft)
F = tpl.create_biphasic(phase=phase, damping=damping,
delay=delay_W)(t_vec - delay_K) * spl.create_delta(
1, shift_x=shift_x)(x_vec, y_vec - shift_y)
assert (abs(G - F) < complex(1e-3, 1e-12)).all()
import pylgn.kernels.spatial as spl
import pylgn.kernels.temporal as tpl
import quantities as pq
# create network
network = pylgn.Network()
# create integrator
integrator = network.create_integrator(nt=8,
nr=9,
dt=1 * pq.ms,
dr=0.1 * pq.deg)
# create kernels
Wg_r = spl.create_dog_ft()
Wg_t = tpl.create_biphasic_ft()
# create neurons
ganglion = network.create_ganglion_cell(kernel=(Wg_r, Wg_t))
# create stimulus
stimulus = pylgn.stimulus.create_natural_image(filenames="natural_scene.png",
delay=40 * pq.ms,
duration=80 * pq.ms)
network.set_stimulus(stimulus, compute_fft=True)
# compute
network.compute_response(ganglion)
# visulize
pylgn.plot.animate_cube(ganglion.response,
def create_dynamicnetwork(params=None):
"""
Create PyLGN network with temporal kernels.
Parameters
----------
params : None, dict, str
passed to util._parse_parameters
"""
params = util.parse_parameters(params)
# network
network = pylgn.Network()
integrator = network.create_integrator(nt=params['nt'],
nr=params['nr'],
dt=params['dt'],
dr=params['dr'])
# neurons
ganglion = network.create_ganglion_cell()
relay = network.create_relay_cell()
cortical = network.create_cortical_cell()
# RGC impulse-response function
Wg_r = spl.create_dog_ft(A=params['A_g'],
a=params['a_g'],
B=params['B_g'],
b=params['b_g'])
Wg_t = tpl.create_biphasic_ft(phase=params['phase_g'],
damping=params['damping_g'])
ganglion.set_kernel((Wg_r, Wg_t))
# excitatory FF connection
Krg_r = spl.create_gauss_ft(A=params['A_rg_ex'], a=params['a_rg_ex'])
Krg_t = tpl.create_exp_decay_ft(tau=params['tau_rg_ex'],
delay=params['delay_rg_ex'])
network.connect(ganglion, relay, (Krg_r, Krg_t), weight=params['w_rg_ex'])
# inhibitory FF
Krig_r = spl.create_gauss_ft(A=params['A_rg_in'], a=params['a_rg_in'])
Krig_t = tpl.create_exp_decay_ft(tau=params['tau_rg_in'],
delay=params['delay_rg_in'])
network.connect(ganglion,
relay, (Krig_r, Krig_t),
weight=params['w_rg_in'])
# excitatory FB
Krc_ex_r = spl.create_gauss_ft(A=params['A_rc_ex'], a=params['a_rc_ex'])
Krc_ex_t = tpl.create_exp_decay_ft(tau=params['tau_rc_ex'],
delay=params['delay_rc_ex'])
network.connect(cortical,
relay, (Krc_ex_r, Krc_ex_t),
weight=params['w_rc_ex'])
# inhibitory FB
Krc_in_r = spl.create_gauss_ft(A=params['A_rc_in'], a=params['a_rc_in'])
Krc_in_t = tpl.create_exp_decay_ft(tau=params['tau_rc_in'],
delay=params['delay_rc_in'])
network.connect(cortical,
relay, (Krc_in_r, Krc_in_t),
weight=params['w_rc_in'])
# TC feed-forward
Kcr_r = spl.create_delta_ft()
Kcr_t = tpl.create_delta_ft()
network.connect(relay, cortical, (Kcr_r, Kcr_t), weight=params['w_cr'])
return network
# create integrator
integrator = network.create_integrator(nt=10,
nr=7,
dt=1 * pq.ms,
dr=0.1 * pq.deg)
# create spatial kernels
Wg_s = spl.create_dog_ft(A=1, a=0.62 * pq.deg, B=0.85, b=1.26 * pq.deg)
Krg_s = spl.create_gauss_ft(A=1, a=0.1 * pq.deg)
Kcr_s = spl.create_delta_ft()
Krcr_cen_s = spl.create_gauss_ft(A=1, a=(0.1) * pq.deg)
Krcr_sur_s = spl.create_gauss_ft(A=2, a=(0.9) * pq.deg)
# create temporal kernels
Wg_t = tpl.create_biphasic_ft(phase_duration=42.5 * pq.ms,
damping_factor=0.38,
delay=0 * pq.ms)
Krg_t = tpl.create_exp_decay_ft(18 * pq.ms, delay=0 * pq.ms)
Kcr_t = tpl.create_delta_ft()
Krcr_cen_t = tpl.create_exp_decay_ft(1 * pq.ms, delay=0 *
pq.ms) # decay: 10 ms, delay: 30 ms
Krcr_sur_t = tpl.create_exp_decay_ft(1 * pq.ms, delay=30 *
pq.ms) # decay: 20 ms, delay: 30 ms
# create neurons
ganglion = network.create_ganglion_cell(kernel=(Wg_s, Wg_t))
relay = network.create_relay_cell()
cortical_cen = network.create_cortical_cell()
cortical_sur = network.create_cortical_cell()
# connect neurons
def test_core():
dt = 5 * pq.ms
dr = 0.1 * pq.deg
# create network
network = pylgn.Network()
# create integrator
integrator = network.create_integrator(nt=10, nr=7, dt=dt, dr=dr)
# create neurons
ganglion = network.create_ganglion_cell()
relay = network.create_relay_cell(2. / pq.s)
cortical = network.create_cortical_cell(0 / pq.s)
# connect neurons
Wg_r = spl.create_dog_ft(A=1, a=0.62 * pq.deg, B=0.83, b=1.26 * pq.deg)
Wg_t = tpl.create_biphasic_ft(phase=43 * pq.ms,
damping=0.38,
delay=0 * pq.ms)
Krg_r = spl.create_delta_ft(shift_x=0 * pq.deg, shift_y=0 * pq.deg)
Krg_t = tpl.create_delta_ft(delay=0 * pq.ms)
Krc_r = spl.create_dog_ft(A=1 * 0.9,
a=0.1 * pq.deg,
B=2 * 0.9,
b=0.9 * pq.deg)
Krc_t = tpl.create_delta_ft(delay=20 * pq.ms)
Kcr_r = spl.create_delta_ft(shift_x=0 * pq.deg, shift_y=0 * pq.deg)
Kcr_t = tpl.create_delta_ft(delay=0 * pq.ms)
ganglion.set_kernel((Wg_r, Wg_t))
network.connect(ganglion, relay, (Krg_r, Krg_t))
network.connect(cortical, relay, (Krc_r, Krc_t))
network.connect(relay, cortical, (Kcr_r, Kcr_t))
print(ganglion.annotations["kernel"], "\n")
# create stimulus
k_g = integrator.spatial_angular_freqs[2]
w_g = -integrator.temporal_angular_freqs[40]
# stimulus = pylgn.stimulus.create_patch_grating_ft(angular_freq=w_g,
# wavenumber=k_g,
# orient=0.0,
# patch_diameter=3,
# contrast=4)
stimulus = pylgn.stimulus.create_flashing_spot_ft(patch_diameter=4 *
pq.deg,
contrast=4,
delay=4 * pq.ms,
duration=20 * pq.ms)
network.set_stimulus(stimulus, compute_fft=False)
# network.set_stimulus(stimulus)
# print(pylgn.closure_params(stimulus))
#
# # compute
# network.compute_irf(relay)
network.compute_response(relay)
# network.compute_response(ganglion)
#
# # write
# print("shape cube: ", relay.irf_ft.shape)
# print("Unit irf:", relay.irf.units)
# # print("Units irf_ft: ", relay.irf_ft.units)
# print("Units resp: ", relay.response.units)
# visulize
# import matplotlib.pyplot as plt
# # import matplotlib.animation as animation
# # plt.imshow(relay.irf[0, :, :].real)
#
# plt.figure()
# # plt.plot(integrator.times, relay.response[:, 64, 64])
# w_g = w_g.rescale(pq.Hz) * integrator.times/integrator.times.max()
# plt.plot(w_g/2./np.pi, relay.response[:, 64, 64])
# plt.show()
# pylgn.plot.animate_cube(relay.response)
# clear network
network.clear()
