def condition_2_gen_conf(self, gen_conf_1):
gen_conf_2 = deepcopy(gen_conf_1)
if self.experiment == 1:
for i in range(len(gen_conf_2)):
gen_conf_2[i]['magnitude'] = \
self.experiment_1_magnitude_multiplier *\
gen_conf_2[i]['magnitude']
if self.experiment == 2:
for i in range(len(gen_conf_2)):
gen_conf_2[i]['magnitude'] = \
uniform(0,10) * gen_conf_2[i]['magnitude']
gen_conf_2 = scale_generator_configuration(
gen_conf_2,
self.final_magnitude)[0]
if self.experiment == 3:
# TODO: Generator magnitude stddev scaling not implemented
gen_conf_2 = random_generator_configuration(
self.limits_number,
self.limits_depth,
self.limits_orientation,
self.limits_magnitude,
self.final_magnitude)[0]
if self.experiment == 4:
gen_conf_new = random_generator_configuration(
(1,1),
self.limits_depth,
self.limits_orientation,
self.limits_magnitude,
uniform(2,4))[0]
gen_conf_2.append(gen_conf_new[0])
return gen_conf_2
def fit_model(erp_model, fit_type, target_type, target):
# Fit types could be:
# 'sources'
# 'variability'
# 'all'
#
# Target types could be:
# 'mean'
# 'covariance'
# ['mean', 'covariance']
if fit_type == 'source' and target_type == 'mean':
mean_data = target
fn = lambda parameters: error_sources_real_sim(mean_data,
parameters[0], parameters[1], parameters[2],
parameters[3], parameters[4], parameters[5])
gen_conf = random_generator_configuration((1,1), depth_lim,
orientation_lim,
magnitude_lim)[0]
full_output = optimize.fmin_slsqp(fn, [gen_conf[0]['depth'],
gen_conf[0]['magnitude'], gen_conf[0]['orientation'],
gen_conf[0]['orientation_phi'], gen_conf[0]['phi'],
gen_conf[0]['theta']], bounds=[depth_bounds,
magnitude_bounds, orientation_bounds, orientation_phi_bounds,
phi_bounds, theta_bounds], full_output=True, iprint=0)
def condition_1_gen_conf(self):
[gen_conf_1, magnitude_stddev] = \
random_generator_configuration(self.limits_number,
self.limits_depth,
self.limits_orientation,
self.limits_magnitude,
self.final_magnitude,
magnitude_stddev=2)
return gen_conf_1
def simulate_noise(self, size):
if self.normal_noise_amplitude:
normal_noise_1 = normal(0, self.normal_noise_amplitude, size)
normal_noise_2 = normal(0, self.normal_noise_amplitude, size)
else:
normal_noise_1 = None
normal_noise_2 = None
if self.constant_noise_amplitude:
constant_noise = self.constant_noise_amplitude * ones(size)
else:
constant_noise = None
if self.topographic_noise_amplitude:
noise_conf_1 = \
random_generator_configuration(
self.limits_number,
self.limits_depth,
self.limits_orientation,
self.limits_magnitude,
self.topographic_noise_amplitude)[0]
noise_conf_2 = \
random_generator_configuration(
self.limits_number,
self.limits_depth,
self.limits_orientation,
self.limits_magnitude,
self.topographic_noise_amplitude)[0]
[topographic_noise_1, noise_conf_1, electrodes] = \
gen_simulation(noise_conf_1,
num_sim=self.number_of_subjects)
[topographic_noise_2, noise_conf_2, electrodes] = \
gen_simulation(noise_conf_2,
num_sim=self.number_of_subjects)
else:
topographic_noise_1 = None
topographic_noise_2 = None
return [normal_noise_1, topographic_noise_1,
normal_noise_2, topographic_noise_2, constant_noise]
def set_random_parameters(self, parameter_list):
for i in range(len(parameter_list)):
if parameter_list[i] == 'locations and orientations':
self.gen_conf = random_generator_configuration((self.n_gen,
self.n_gen), self.depth_lim, self.orientation_lim,
self.magnitude_lim)[0]
elif parameter_list[i] == 'generator variance':
self.sigma_g = self.gen_variance_lim[0] +\
uniform(self.gen_variance_lim[1] -\
self.gen_variance_lim[0])
elif parameter_list[i] == 'generator variances individual':
self.sigma_g = []
for j in range(self.n_gen):
sigma_g = self.gen_variance_lim[0] +\
uniform(self.gen_variance_lim[1] -\
self.gen_variance_lim[0])
self.sigma_g.append(sigma_g)
elif parameter_list[i] == 'generator covariance':
self.sigma_c = self.gen_covariance_lim[0] +\
uniform(self.gen_covariance_lim[1] -\
self.gen_covariance_lim[0])
elif parameter_list[i] == 'generator covariances individual':
self.sigma_c = zeros((self.n_gen, self.n_gen))
for row in range(self.n_gen):
for column in range(self.n_gen):
if row < column:
sigma_c = self.gen_covariance_lim[0] +\
uniform(self.gen_covariance_lim[1] -\
self.gen_covariance_lim[0])
self.sigma_c[row,column] = sigma_c
self.sigma_c[column,row] = sigma_c
elif parameter_list[i] == 'electrode variance':
self.sigma_e = self.el_variance_lim[0] +\
uniform(self.el_variance_lim[1] -\
self.el_variance_lim[0])
self.up_to_date['lead field'] = False
self.up_to_date['mean'] = False
self.up_to_date['covariance generators'] = False
self.up_to_date['covariance'] = False
],
]
figure()
plot_topographic_map_array(map_array, scale=scale_array, label_y=label_y_array, title=title_array)
savefig(folder + "/subject_" + str(i + 1) + ".png")
if parameters["todo_plot_grand_averages"]:
print("Drawing grand averages for all imported data")
figure()
plot_ERP(ERP_avg["old"][0])
if parameters["todo_plot_simulated_noise"]:
print("Running simulation to show topographic properties of noise")
gen_conf = random_generator_configuration()
[simulated_data, gen_conf, electrodes] = gen_simulation(
gen_conf,
num_sim=parameters["number_of_subjects"],
gen_magnitude_stddev=parameters["generator_magnitude_stddev"],
)
figure()
plot_topographic_map(mean(simulated_data, 0))
# savefig('Results/' + timestamp + '/simulated_noise')
savefig("Results/" + label + "/simulated_noise")
# Here we will be running the scaling experiments
# se <-- holds all simulation experiments, for all parameter combinations
se = {}
'parallel to the surface')
gen_confs.append([{'depth': 6, 'theta': 0, 'phi': 0, 'orientation': 0,
'orientation_phi': 0, 'magnitude': 1}])
lead_fields.append(calculate_lead_field(gen_confs[-1]))
descriptions.append('A single dipole, located at top of sphere, oriented ' +\
'perpendicular to the surface')
gen_confs.append([{'depth': 5, 'theta': 0, 'phi': 0, 'orientation': pi/2,
'orientation_phi': 0, 'magnitude': 1}])
lead_fields.append(calculate_lead_field(gen_confs[-1]))
descriptions.append('A single dipole, at a specific location')
gen_confs.append([{'depth': 7, 'theta': 3*pi/8, 'phi': 3*pi/4,
'orientation': pi/4, 'orientation_phi': 3*pi/4,
'magnitude': 1}])
lead_fields.append(calculate_lead_field(gen_confs[-1]))
descriptions.append('5 generators in a random configuration (with specified' +\
'seed')
gen_confs.append(random_generator_configuration((5,5))[0])
lead_fields.append(calculate_lead_field(gen_confs[-1]))
old_code = []
for i in range(len(gen_confs)):
old_code.append({'description': descriptions[i],
'gen_conf': gen_confs[i],
'lead_field': lead_fields[i]})
with open('test_lead_field_same_output_as_old_code.data', 'wb') as f:
pickle.dump(old_code, f)
