def test_lead_field_class_same_output_as_function():
global old_code
lf = Lead_Field()
for i in range(len(old_code)):
lead_field_class = lf.calculate(old_code[i]['gen_conf'])
lead_field_function = calculate_lead_field(old_code[i]['gen_conf'])
assert_array_equal(lead_field_class, lead_field_function)
def __init__(self, parameter_list=None, parameters=None, n_sub=23, n_gen=1):
# Optimal bounds for fitting
self.magnitude_bounds = (0, None) # unnecessary?
self.depth_bounds = (4.49, 7.05) # cortex
self.theta_bounds = (0,pi/2)
self.phi_bounds = (0,2*pi) # unnecessary?
self.orientation_bounds = (0, pi/2)
self.orientation_phi_bounds = (0,2*pi) # unnecessary?
self.gen_variance_bounds = (None, None)
self.gen_covariance_bounds = (None, None)
self.el_variance_bounds = (None, None)
# Parameter limits for randomizing model
self.magnitude_lim = (1, 10000000)
self.depth_lim = (4.49, 7.05) # cortex
self.phi_lim = (0,2*pi)
self.theta_lim = (0,pi/2)
self.orientation_lim = (0, pi/2) # cortex
self.orientation_phi_lim = (0,2*pi)
self.gen_variance_lim = [0, 1000000]
self.gen_covariance_lim = [0, 1000000]
self.el_variance_lim = [0, 20]
# Variability parameters
self.sigma_e = 0
self.sigma_g = 0
self.sigma_c = 0
self.n_gen = n_gen
self.n_sub = n_sub
self.n_el = 60
self.lf = Lead_Field()
self.gen_conf = None
self.up_to_date = {}
if parameter_list == None or 'locations and orientations' not in parameter_list:
self.set_random_parameters(['locations and orientations'])
# Amplitudes should be set separately, but for now they're not...
#self.set_random_parameters(['locations and orientations',
# 'amplitudes'])
if parameter_list != None:
self.set_parameters(parameter_list, parameters)
# This is not working, amplitudes are being set above along with
# locations and orientations, which shouldn't be the case
#if 'amplitudes' not in parameter_list:
# self.set_random_parameters(['amplitudes'])
self.recalculate_model()
def __init__(
self, n_sub, n_gen, variability_electrodes="none", variability_generators="none", variability_connections="none"
):
self.n_gen = n_gen # generators
self.n_sub = n_sub # subjects
self.n_el = 60 # Hard-coded to use a specific electrode set
self.up_to_date = {}
self.set_parameter_limits()
self.gen_conf = None
self.lf = Lead_Field()
self.set_variability_type(variability_electrodes, variability_generators, variability_connections)
self.sigma_e = 0
self.sigma_g = zeros(self.n_gen)
self.sigma_c = zeros((self.n_gen, self.n_gen))
class ERP_Variability_Model:
def __init__(
self, n_sub, n_gen, variability_electrodes="none", variability_generators="none", variability_connections="none"
):
self.n_gen = n_gen # generators
self.n_sub = n_sub # subjects
self.n_el = 60 # Hard-coded to use a specific electrode set
self.up_to_date = {}
self.set_parameter_limits()
self.gen_conf = None
self.lf = Lead_Field()
self.set_variability_type(variability_electrodes, variability_generators, variability_connections)
self.sigma_e = 0
self.sigma_g = zeros(self.n_gen)
self.sigma_c = zeros((self.n_gen, self.n_gen))
def print_model(self, topographies=False):
print ("ERP Model Parameters")
print ("====================")
print ("Number of generators: " + str(self.n_gen) + "\n")
print ("Variability")
print ("-----------")
print ("* Electrodes (self.sigma_e)")
print self.sigma_e
print ("* Generators (self.cov_gen)")
print self.cov_gen
print ("* Final covariance matrix (self.cov)")
print self.cov
for gen in range(self.n_gen):
print ("\nGenerator " + str(gen + 1))
print ("-------------------")
print ("LOCATION, Depth: " + str(self.gen_conf[gen]["depth"]))
print ("LOCATION, Theta: " + str(self.gen_conf[gen]["theta"]))
print ("LOCATION, Phi: " + str(self.gen_conf[gen]["phi"]))
print ("ORIENTATION: " + str(self.gen_conf[gen]["orientation"]))
print ("ORIENTATION, Phi: " + str(self.gen_conf[gen]["orientation_phi"]))
print ("MAGNITUDE: " + str(self.gen_conf[gen]["magnitude"]))
if topographies:
pyplot.figure()
plot_topographic_map((self.gen_conf[gen]["magnitude"] * self.lf.calculate([self.gen_conf[gen]]))[:, 0])
def plot_model(self, to_plot):
for one_plot in to_plot:
if one_plot == "mean":
plot_topographic_map(self.mean)
pyplot.title("Topographic map of mean")
# Individual generator means
pyplot.figure()
for i in range(self.n_gen):
pyplot.subplot(1, self.n_gen, i)
plot_topographic_map(self.mean)
pyplot.figtext(0.5, 0.75, "Topographic maps of means of each generator", ha="center")
if one_plot == "variance":
pyplot.figure()
plot_topographic_map(self.cov.diagonal())
pyplot.title("Topographic map of variance")
# Individual generator variances
pyplot.figure()
for i in range(self.n_gen):
pyplot.subplot(1, self.n_gen, i)
single_cov = dot(transpose(self.lead_field[:, i][newaxis]), self.lead_field[:, i][newaxis])
if self.variability_generators == "constant":
single_cov = self.sigma_g * single_cov
elif self.variability_generators == "individual":
single_cov = self.sigma_g[i] * single_cov
plot_topographic_map(single_cov.diagonal())
pyplot.figtext(0.5, 0.75, "Topographic maps of variance of each generator", ha="center")
if one_plot == "covariance matrix":
pyplot.figure()
plot_covariance_matrix(self.data, self.cov)
pyplot.title("Covariance matrix")
def set_parameter_limits(self):
# Parameter bounds for randomizing model parameters
self.limits = {}
# Location and orientation
self.limits["depth"] = (4.49, 7.05) # roughly the cortex
self.limits["phi"] = (0, 2 * pi)
self.limits["theta"] = (0, pi / 2)
self.limits["orientation"] = (0, pi / 2) # cortex
self.limits["orientation_phi"] = (0, 2 * pi)
# Magnitude
self.limits["magnitude"] = (0, 1000)
# Variability
self.limits["generator_variance"] = [0, 1000000]
self.limits["electrode_variance"] = [0, 20]
# Covariance needs no limits becuase it is limited by the variance of
# the two generators in question
# self.limits['generator_covariance'] = [0, 1000000]
# Constant number of generators
self.limits["n_gen"] = (self.n_gen, self.n_gen)
def set_variability_type(self, variability_electrodes, variability_generators, variability_connections):
if variability_electrodes not in ["constant", "individual", "none"]:
raise ValueError
else:
self.variability_electrodes = variability_electrodes
if variability_generators not in ["constant", "individual", "none"]:
raise ValueError
else:
self.variability_generators = variability_generators
if variability_connections not in ["individual", "none"]:
raise ValueError
else:
self.variability_connections = variability_connections
def set_gen_conf(self, gen_conf):
self.gen_conf = gen_conf
self.n_gen = len(gen_conf)
def set_random(self):
self.set_random_locations_orientations()
self.set_random_magnitudes()
self.set_random_variability()
def set_random_locations_orientations(self):
self.gen_conf = random_generator_placement(self.limits)
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
def set_random_magnitudes(self):
limits = self.limits["magnitude"]
for i in range(self.n_gen):
self.gen_conf[i]["magnitude"] = limits[0] + uniform(limits[1] - limits[0])
self.up_to_date["mean"] = False
def set_random_variability(self):
self.set_random_variability_electrodes()
self.set_random_variability_generators()
self.set_random_variability_connections()
def set_random_variability_electrodes(self):
limits = self.limits["electrode_variance"]
if self.variability_electrodes == "none":
self.sigma_e = 0
elif self.variability_electrodes == "constant":
self.sigma_e = limits[0] + uniform(limits[1] - limits[0])
elif self.variability_electrodes == "individual":
self.sigma_e = []
for i in range(self.n_el):
self.sigma_e.append(limits[0] + uniform(limits[1] - limits[0]))
def set_random_variability_generators(self):
limits = self.limits["generator_variance"]
if self.variability_generators == "none":
self.sigma_g = 0
elif self.variability_generators == "constant":
self.sigma_g = limits[0] + uniform(limits[1] - limits[0])
elif self.variability_generators == "individual":
self.sigma_g = []
for i in range(self.n_gen):
self.sigma_g.append(limits[0] + uniform(limits[1] - limits[0]))
def set_random_variability_connections(self):
if self.variability_connections == "none":
self.sigma_c = zeros((self.n_gen, self.n_gen))
elif self.variability_connections == "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 = uniform(sqrt(self.sigma_g[row] * self.sigma_g[column]))
self.sigma_c[row, column] = sigma_c
self.sigma_c[column, row] = sigma_c
def calculate_lead_field(self):
self.lead_field = self.lf.calculate(self.gen_conf)
self.up_to_date["lead field"] = True
self.up_to_date["mean"] = False
self.up_to_date["covariance generators"] = False
self.up_to_date["covariance"] = False
return self.lead_field
def calculate_mean(self):
if not self.up_to_date["lead field"]:
self.calculate_lead_field()
gen_amplitudes = []
for i in range(self.n_gen):
gen_amplitudes.append(self.gen_conf[i]["magnitude"])
self.mean = dot(self.lead_field, gen_amplitudes)
self.up_to_date["mean"] = True
return self.mean
def calculate_cov_gen(self):
if not self.up_to_date["lead field"]:
self.calculate_lead_field()
self.cov_gen = zeros((self.n_gen, self.n_gen))
for row in range(self.n_gen):
for column in range(self.n_gen):
if row == column:
if self.variability_generators == "individual":
self.cov_gen[row, column] = self.sigma_g[row]
elif self.variability_generators == "constant":
self.cov_gen[row, column] = self.sigma_g
elif column > row:
if self.variability_connections == "individual":
self.cov_gen[row, column] = self.sigma_c[row, column]
self.cov_gen[column, row] = self.sigma_c[row, column]
self.up_to_date["covariance generators"] = True
self.up_to_date["covariance"] = False
return self.cov_gen
def calculate_cov(self):
if not self.up_to_date["lead field"]:
self.calculate_lead_field()
if not self.up_to_date["covariance generators"]:
self.calculate_cov_gen()
# TODO: Make it work for individual electrode variance as well
self.cov = dot(dot(self.lead_field, self.cov_gen), transpose(self.lead_field)) + self.sigma_e * identity(
self.n_el
)
self.up_to_date["covariance"] = True
return self.cov
def simulate(self):
self.data = multivariate_normal(self.mean, self.cov, self.n_sub)
return self.data
def recalculate_model(self):
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
self.calculate_lead_field()
self.calculate_mean()
self.calculate_cov()
self.simulate()
class ERP_Model():
def __init__(self, parameter_list=None, parameters=None, n_sub=23, n_gen=1):
# Optimal bounds for fitting
self.magnitude_bounds = (0, None) # unnecessary?
self.depth_bounds = (4.49, 7.05) # cortex
self.theta_bounds = (0,pi/2)
self.phi_bounds = (0,2*pi) # unnecessary?
self.orientation_bounds = (0, pi/2)
self.orientation_phi_bounds = (0,2*pi) # unnecessary?
self.gen_variance_bounds = (None, None)
self.gen_covariance_bounds = (None, None)
self.el_variance_bounds = (None, None)
# Parameter limits for randomizing model
self.magnitude_lim = (1, 10000000)
self.depth_lim = (4.49, 7.05) # cortex
self.phi_lim = (0,2*pi)
self.theta_lim = (0,pi/2)
self.orientation_lim = (0, pi/2) # cortex
self.orientation_phi_lim = (0,2*pi)
self.gen_variance_lim = [0, 1000000]
self.gen_covariance_lim = [0, 1000000]
self.el_variance_lim = [0, 20]
# Variability parameters
self.sigma_e = 0
self.sigma_g = 0
self.sigma_c = 0
self.n_gen = n_gen
self.n_sub = n_sub
self.n_el = 60
self.lf = Lead_Field()
self.gen_conf = None
self.up_to_date = {}
if parameter_list == None or 'locations and orientations' not in parameter_list:
self.set_random_parameters(['locations and orientations'])
# Amplitudes should be set separately, but for now they're not...
#self.set_random_parameters(['locations and orientations',
# 'amplitudes'])
if parameter_list != None:
self.set_parameters(parameter_list, parameters)
# This is not working, amplitudes are being set above along with
# locations and orientations, which shouldn't be the case
#if 'amplitudes' not in parameter_list:
# self.set_random_parameters(['amplitudes'])
self.recalculate_model()
def print_model(self, topographies=False):
print('ERP Model Parameters')
print('====================')
print('Number of generators: ' + str(self.n_gen) + '\n')
print('Variability')
print('-----------')
if self.sigma_e == 0:
print('* No electrode variance.')
else:
print('* Electrode variance: ' + str(self.sigma_e))
print('* Generator covariance matrix:')
print(self.cov_gen)
#if self.n_gen > 1 and isinstance(self.sigma_g, list):
# print('* Individual generator variance.')
#elif self.n_gen > 1:
# print('* Generator variance: ' + str(self.sigma_g))
#if self.n_gen > 1 and isinstance(self.sigma_c, list):
# print('* Individual generator covariance.')
#elif self.n_gen > 1:
# print('* Generator variance: ' + str(self.sigma_g))
for gen in range(self.n_gen):
print('Generator ' + str(gen+1))
print('-------------------')
print('LOCATION, Depth: ' + str(self.gen_conf[gen]['depth']))
print('LOCATION, Theta: ' + str(self.gen_conf[gen]['theta']))
print('LOCATION, Phi: ' + str(self.gen_conf[gen]['phi']))
print('ORIENTATION: ' + str(self.gen_conf[gen]['orientation']))
print('ORIENTATION, Phi: ' + str(self.gen_conf[gen]['orientation_phi']))
print('MAGNITUDE: ' + str(self.gen_conf[gen]['magnitude']))
if topographies:
pyplot.figure()
plot_topographic_map((self.gen_conf[gen]['magnitude'] *
self.lf.calculate(
[self.gen_conf[gen]]))[:,0])
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
def set_parameters(self, parameter_list, parameters):
"""This function enables you to fit any sets of parameters, i.e.:
* location and orientations
* amplitudes
* generator variance
* generator variances individual
* generator covariance
* generator covariances individual
* electrode variance
You need to pass the list of parameters and a list of their values:
set_parameters(self, parameter_list, parameters),
where parameter_list would be of the form (GLVM model):
['locations and orientations', 'amplitudes', 'equal variance']
and depending on what parameters are listed, the parameters variable
will be expected to hold different values, but always in a list
"""
par = 0 # the current parameter
for i in range(len(parameter_list)):
gen_amplitudes = []
for j in range(self.n_gen):
gen_amplitudes.append(self.gen_conf[j]['magnitude'])
if parameter_list[i] == 'locations and orientations':
self.gen_conf = []
n_gen_parameters = 5
# Creating generator configuration
for gen in range(self.n_gen):
self.gen_conf.append({})
self.gen_conf[gen]['depth'] = parameters[par]
self.gen_conf[gen]['orientation'] = parameters[par + 1]
self.gen_conf[gen]['orientation_phi'] = parameters[par + 2]
self.gen_conf[gen]['phi'] = parameters[par + 3]
self.gen_conf[gen]['theta'] = parameters[par + 4]
self.gen_conf[gen]['magnitude'] = gen_amplitudes[gen]
par += n_gen_parameters
if parameter_list[i] == 'amplitudes':
if self.gen_conf == None:
print('WARNING: Trying to set amplitudes without generators')
for gen in range(self.n_gen):
self.gen_conf[gen]['magnitude'] = parameters[par]
par += 1
if parameter_list[i] == 'generator variance':
self.sigma_g = parameters[par]
par += 1
if parameter_list[i] == 'generator variances individual':
self.sigma_g = list(parameters[par : par + self.n_gen])
par += self.n_gen
if parameter_list[i] == 'generator covariance':
self.sigma_c = parameters[par]
par += 1
if parameter_list[i] == 'generator covariances individual':
self.sigma_c = zeros((self.n_gen, self.n_gen))
for row in range(self.n_gen):
for col in range(self.n_gen):
if row < col:
self.sigma_c[row,col] = parameters[par]
self.sigma_c[col,row] = parameters[par]
par += 1
if parameter_list[i] == 'electrode variance':
self.sigma_e = parameters[par]
par += 1
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
def get_parameters(self, parameter_list):
parameters = []
for i in range(len(parameter_list)):
if parameter_list[i] == 'locations and orientations':
for gen in range(self.n_gen):
parameters.append(self.gen_conf[gen]['depth'])
parameters.append(self.gen_conf[gen]['orientation'])
parameters.append(self.gen_conf[gen]['orientation_phi'])
parameters.append(self.gen_conf[gen]['phi'])
parameters.append(self.gen_conf[gen]['theta'])
if parameter_list[i] == 'amplitudes':
for gen in range(self.n_gen):
parameters.append(self.gen_conf[gen]['magnitude'])
if parameter_list[i] == 'generator variance':
if not isinstance(self.sigma_g, list):
parameters.append(self.sigma_g)
else:
print('WARNING: Variances expected to be identical for \
all generators, however self.sigma_g holds a list, \
not a single value')
if parameter_list[i] == 'generator variances individual':
if isinstance(self.sigma_g, list):
for j in range(len(self.sigma_g)):
parameters.append(self.sigma_g[j])
else:
print('WARNING: Variances expected to be different for \
all generators, however self.sigma_g does not hold \
a list')
if parameter_list[i] == 'generator covariance':
if not isinstance(self.sigma_c, ndarray):
parameters.append(self.sigma_c)
else:
print('WARNING: Generator covariance expected to be \
identical for all generators, however self.sigma_c \
holds an array, not a single value')
if parameter_list[i] == 'generator covariances individual':
if isinstance(self.sigma_c, ndarray):
for row in range(self.n_gen):
for col in range(self.n_gen):
if row < col:
parameters.append(self.sigma_c[row,col])
else:
print('WARNING: Generator covariances expected to be \
different for all generator pairs, however \
self.sigma_c is not an array')
if parameter_list[i] == 'electrode variance':
parameters.append(self.sigma_e)
return parameters
def get_bounds(self, parameter_list):
bounds = []
for i in range(len(parameter_list)):
if parameter_list[i] == 'locations and orientations':
for j in range(self.n_gen):
bounds.append(self.depth_bounds)
bounds.append(self.orientation_bounds)
bounds.append(self.orientation_phi_bounds)
bounds.append(self.phi_bounds)
bounds.append(self.theta_bounds)
if parameter_list[i] == 'amplitudes':
for j in range(self.n_gen):
bounds.append(self.magnitude_bounds)
if parameter_list[i] == 'generator variance':
bounds.append(self.gen_variance_bounds)
if parameter_list[i] == 'generator variances individual':
for j in range(self.n_gen):
bounds.append(self.gen_variance_bounds)
if parameter_list[i] == 'generator covariance':
bounds.append(self.gen_covariance_bounds)
if parameter_list[i] == 'generator covariances individual':
for j in range(self.n_gen*(self.n_gen-1)/2):
bounds.append(self.gen_covariance_bounds)
if parameter_list[i] == 'electrode variance':
bounds.append(self.el_variance_bounds)
return bounds
def calculate_lead_field(self):
self.lead_field = self.lf.calculate(self.gen_conf)
self.up_to_date['lead field'] = True
self.up_to_date['mean'] = False
self.up_to_date['covariance'] = False
return self.lead_field
def calculate_mean(self):
if not self.up_to_date['lead field']: self.calculate_lead_field()
gen_amplitudes = []
for i in range(self.n_gen):
gen_amplitudes.append(self.gen_conf[i]['magnitude'])
self.mean = dot(self.lead_field, gen_amplitudes)
self.up_to_date['mean'] = True
return self.mean
def calculate_cov_gen(self):
self.cov_gen = zeros((self.n_gen, self.n_gen))
for row in range(self.n_gen):
for column in range(self.n_gen):
if row == column:
if isinstance(self.sigma_g, list):
self.cov_gen[row,column] = self.sigma_g[row]
else:
self.cov_gen[row,column] = self.sigma_g
elif column > row:
if isinstance(self.sigma_c, ndarray):
self.cov_gen[row,column] = self.sigma_c[row,column]
self.cov_gen[column,row] = self.sigma_c[row,column]
else:
self.cov_gen[row,column] = self.sigma_c
self.cov_gen[column,row] = self.sigma_c
self.up_to_date['covariance generators'] = True
self.up_to_date['covariance'] = False
return self.cov_gen
def calculate_cov(self):
if not self.up_to_date['lead field']: self.calculate_lead_field()
if not self.up_to_date['covariance generators']:
self.calculate_cov_gen()
self.cov = dot(dot(self.lead_field, self.cov_gen),
transpose(self.lead_field)) + self.sigma_e *\
identity(self.n_el)
self.up_to_date['covariance'] = True
return self.cov
def simulate(self):
self.data = multivariate_normal(self.mean,self.cov,self.n_sub)
return self.data
def recalculate_model(self):
self.calculate_lead_field()
self.calculate_mean()
self.calculate_cov()
self.simulate()
def test_lead_field_class():
global old_code
lf = Lead_Field()
for i in range(len(old_code)):
lead_field = lf.calculate(old_code[i]['gen_conf'])
assert_array_almost_equal(lead_field, old_code[i]['lead_field'], 17)