Alexander/P-unit_model
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

add actual input scaling

Browse Source
This commit is contained in:
a.ott 2020-03-03 09:24:10 +01:00
parent 7e65ebae4e
commit 04815de85c
1 changed files with 11 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
models/LIFACnoise.py
View File

@ -7,6 +7,7 @@ from numba import jit
import helperFunctions as hF import helperFunctions as hF
from stimuli.SinusAmplitudeModulation import SinusAmplitudeModulationStimulus from stimuli.SinusAmplitudeModulation import SinusAmplitudeModulationStimulus
from scipy.optimize import curve_fit from scipy.optimize import curve_fit
from warnings import warn
class LifacNoiseModel(AbstractModel): class LifacNoiseModel(AbstractModel):
@ -27,6 +28,8 @@ class LifacNoiseModel(AbstractModel):
def __init__(self, params: dict = None): def __init__(self, params: dict = None):
super().__init__(params) super().__init__(params)
if self.parameters["step_size"] >= 0.0001:
warn("LifacNoiseModel: The step size is quite big simulation could fail.")
self.voltage_trace = [] self.voltage_trace = []
self.adaption_trace = [] self.adaption_trace = []
self.spiketimes = [] self.spiketimes = []
@ -49,7 +52,7 @@ class LifacNoiseModel(AbstractModel):
for i in range(1, len(time), 1): for i in range(1, len(time), 1):
time_point = time[i] time_point = time[i]
# rectified input: # rectified input:
stimulus_strength = fu.rectify(stimulus.value_at_time_in_s(time_point)) stimulus_strength = fu.rectify(stimulus.value_at_time_in_s(time_point)) * self.parameters["input_scaling"]
v_next = self._calculate_voltage_step(current_v, stimulus_strength - current_a) v_next = self._calculate_voltage_step(current_v, stimulus_strength - current_a)
a_next = self._calculate_adaption_step(current_a) a_next = self._calculate_adaption_step(current_a)
@ -99,9 +102,10 @@ class LifacNoiseModel(AbstractModel):
v_offset = self.parameters["v_offset"] v_offset = self.parameters["v_offset"]
mem_tau = self.parameters["mem_tau"] mem_tau = self.parameters["mem_tau"]
noise_strength = self.parameters["noise_strength"] noise_strength = self.parameters["noise_strength"]
input_scaling = self.parameters["input_scaling"]
rectified_stimulus = rectify_stimulus_array(stimulus.as_array(time_start, total_time_s, step_size)) rectified_stimulus = rectify_stimulus_array(stimulus.as_array(time_start, total_time_s, step_size))
parameters = np.array([v_zero, a_zero, step_size, threshold, v_base, delta_a, tau_a, v_offset, mem_tau, noise_strength, time_start]) parameters = np.array([v_zero, a_zero, step_size, threshold, v_base, delta_a, tau_a, v_offset, mem_tau, noise_strength, time_start, input_scaling])
voltage_trace, adaption, spiketimes = simulate_fast(rectified_stimulus, total_time_s, parameters) voltage_trace, adaption, spiketimes = simulate_fast(rectified_stimulus, total_time_s, parameters)
@ -161,6 +165,9 @@ class LifacNoiseModel(AbstractModel):
:return: baseline_freq, vs, sc :return: baseline_freq, vs, sc
""" """
base_stimulus = SinusAmplitudeModulationStimulus(base_stimulus_freq, 0, 0) base_stimulus = SinusAmplitudeModulationStimulus(base_stimulus_freq, 0, 0)
import matplotlib.pyplot as plt
plt.plot(base_stimulus.as_array(0,30,0.00005))
plt.show()
_, spiketimes = self.simulate_fast(base_stimulus, 30) _, spiketimes = self.simulate_fast(base_stimulus, 30)
time_x = 5 time_x = 5
baseline_freq = hF.mean_freq_of_spiketimes_after_time_x(spiketimes, time_x) baseline_freq = hF.mean_freq_of_spiketimes_after_time_x(spiketimes, time_x)
@ -263,6 +270,7 @@ def simulate_fast(rectified_stimulus_array, total_time_s, parameters: np.ndarray
mem_tau = parameters[8] mem_tau = parameters[8]
noise_strength = parameters[9] noise_strength = parameters[9]
time_start = parameters[10] time_start = parameters[10]
input_scaling = parameters[11]
time = np.arange(time_start, total_time_s, step_size) time = np.arange(time_start, total_time_s, step_size)
length = len(time) length = len(time)
@ -279,7 +287,7 @@ def simulate_fast(rectified_stimulus_array, total_time_s, parameters: np.ndarray
noise_value = np.random.normal() noise_value = np.random.normal()
noise = noise_strength * noise_value / np.sqrt(step_size) noise = noise_strength * noise_value / np.sqrt(step_size)
output_voltage[i] = output_voltage[i-1] + ((v_base - output_voltage[i-1] + v_offset + stimulus_values[i] - adaption[i-1] + noise) / mem_tau) * step_size output_voltage[i] = output_voltage[i-1] + ((v_base - output_voltage[i-1] + v_offset + (stimulus_values[i]*input_scaling) - adaption[i-1] + noise) / mem_tau) * step_size
adaption[i] = adaption[i-1] + ((-adaption[i-1]) / tau_a) * step_size adaption[i] = adaption[i-1] + ((-adaption[i-1]) / tau_a) * step_size
if output_voltage[i] > threshold: if output_voltage[i] > threshold: