def optimize_model(im, gt, extra_vars, parameters):
#Get data
if extra_vars['figure_name'] == 'f4': #precalculated
x = im.transpose(0, 2, 3, 1) #need to copy or what?
with tf.device('/gpu:0'):
with tf.variable_scope('aux'):
aux_ctx = ContextualCircuit(lesions=parameters.lesions)
aux_ctx.run(
extra_vars['aux_data']) #builds tf graph with shape of x
elif extra_vars['figure_name'] == 'tbp' or extra_vars[
'figure_name'] == 'tbtcso' or extra_vars['figure_name'] == 'bw':
x = im.transpose(0, 2, 3, 1)
else:
x = model_utils.get_population2(
im,
npoints=extra_vars['npoints'],
kind=extra_vars['kind'],
scale=extra_vars['scale']).astype(
parameters._DEFAULT_FLOATX_NP).transpose(0, 2, 3,
1) #transpose to bhwc
#Build graph
with tf.device('/gpu:0'):
with tf.variable_scope('main'):
ctx = ContextualCircuit(lesions=parameters.lesions)
ctx.run(x) #builds tf graph with shape of x
#Special case for fig 4
if extra_vars['figure_name'] == 'f4':
extra_vars['aux_y'], _ = compute_shifts(
x=extra_vars['aux_data'],
ctx=aux_ctx,
extra_vars=extra_vars,
default_parameters=parameters)
oy, run_time = compute_shifts(x=x,
ctx=ctx,
extra_vars=extra_vars,
default_parameters=parameters)
y, aux_data = model_utils.data_postprocessing(x, oy, extra_vars)
import ipdb
ipdb.set_trace()
it_score = get_fits(y, gt, extra_vars)
#Add to database
update_data(parameters, extra_vars['figure_name'], parameters._id,
it_score)
return
def optimize_model(im, gt, extra_vars, parameters):
#Do outer loop of lesions -- embed in variable scopes
for lesion in parameters.lesions:
outer_parameters = deepcopy(parameters)
outer_parameters.lesions = lesion
print('Running optimizations on problem ' + extra_vars['figure_name'] +
' after lesioning: ' + ' '.join(outer_parameters.lesions))
#Optional stuff and data prep
if extra_vars['figure_name'] == 'f4': #precalculated
x = im.transpose(0, 2, 3, 1) #need to copy or what?
with tf.device('/gpu:0'):
with tf.variable_scope('aux_' + lesion):
aux_ctx = ContextualCircuit(lesions=lesion)
aux_ctx.run(extra_vars['aux_data']
) #builds tf graph with shape of x
elif extra_vars['figure_name'] == 'tbp' or extra_vars[
'figure_name'] == 'tbtcso' or extra_vars[
'figure_name'] == 'bw' or extra_vars[
'figure_name'] == 'cross_orientation_suppression':
x = im.transpose(0, 2, 3, 1)
else:
x = model_utils.get_population2(
im,
npoints=extra_vars['npoints'],
kind=extra_vars['kind'],
scale=extra_vars['scale']).astype(
outer_parameters._DEFAULT_FLOATX_NP).transpose(
0, 2, 3, 1) #transpose to bhwc
# Build main graph
with tf.device('/gpu:0'):
with tf.variable_scope('main_' + lesion):
ctx = ContextualCircuit(lesions=outer_parameters.lesions)
ctx.run(x) # builds tf graph with shape of x
# Do hp optimization
num_sets = count_sets(lesion, extra_vars['figure_name'])[0]['count']
if num_sets > 0:
idx = 0 # keep a count
# Initialize the session
with tf.Session(config=tf.ConfigProto(
allow_soft_placement=True)) as sess:
while 1: # while we have hp to run on this lesion
hp_set = get_lesion_rows_from_db(lesion,
extra_vars['figure_name'],
get_one=True)
if hp_set is None and parameters.pachaya is not True:
break
else:
if parameters.pachaya:
random_parameters = prepare_hps(
outer_parameters, None)
else:
random_parameters = prepare_hps(
outer_parameters, hp_set)
# Special case for fig 4
if extra_vars['figure_name'] == 'f4':
extra_vars['aux_y'], _ = compute_shifts(
x=extra_vars['aux_data'],
sess=sess,
ctx=aux_ctx,
extra_vars=extra_vars,
default_parameters=random_parameters)
# Apply the model to the data
oy, run_time = compute_shifts(
x=x,
sess=sess,
ctx=ctx,
extra_vars=extra_vars,
default_parameters=random_parameters)
# Postprocess the model's outputs
y, aux_data = model_utils.data_postprocessing(
x, oy, extra_vars) # maybe return a dict instead?
# Correlate simulation and ground truth
it_score = get_fits(y, gt, extra_vars)
# Add to database
if parameters.pachaya and idx == 1:
break
else:
update_data(random_parameters,
extra_vars['figure_name'],
hp_set['_id'], it_score)
printProgress(idx,
num_sets,
prefix=extra_vars['figure_name'] +
' progress on lesion ' + lesion + ':',
suffix='Iteration time: ' +
str(np.around(run_time, 2)) +
'; Correlation: ' +
str(np.around(it_score, 2)),
bar_length=30)
if parameters.gaussian_spatial or parameters.gaussian_channel:
break
else:
idx += 1
def optimize_model(gt, extra_vars, parameters):
# parameters
###########
nw = len(extra_vars['ws'])
abs_cohs = sp.linspace(0, 100, extra_vars['ncoh'] // 2 + 1) / 100.
dirs = sp.linspace(0, 9, extra_vars['ndirs'], dtype=int) / float(
extra_vars['ndirs'])
coh50 = (extra_vars['ndirs'] / 2.0 - 1.0) / (extra_vars['ndirs'] - 1.0)
scoh = coh50
coherences = sp.linspace(-100, 100, extra_vars['ncoh']) / 100.
coherences4fit = sp.linspace(-100, 100, extra_vars['ncoh4fit']) / 100.
#Taking the MurakamiShimojo1996 code and integrating with the hp_optim
#Do outer loop of lesions -- embed in variable scopes
for lesion in parameters.lesions:
outer_parameters = deepcopy(parameters)
outer_parameters.lesions = lesion
print('Running optimizations on problem ' + extra_vars['figure_name'] +
' after lesioning: ' + ' '.join(outer_parameters.lesions))
build_graph = True
#Do hp optimization
num_sets = count_sets(lesion, extra_vars['figure_name'])[0]['count']
idx = 0
#keep a count
while 1: #while we have hp to run on this lesion
hp_set = get_lesion_rows_from_db(lesion,
extra_vars['figure_name'],
get_one=True)
if hp_set is None:
break
else:
random_parameters = prepare_hps(outer_parameters, hp_set)
for ol, w in enumerate(extra_vars['ws']):
# generate stimuli at various center coherences
im_poscoh = [
get_rdots(cval=extra_vars['value_down'],
ccoh=ccoh,
sval=extra_vars['value_down'],
scoh=scoh,
density=extra_vars['rdd'],
size=extra_vars['size'],
w=w,
dirs=dirs,
ndirs=extra_vars['ndirs'])
for ccoh in abs_cohs
]
im_negcoh = [
get_rdots(cval=extra_vars['value_up'],
ccoh=ccoh,
sval=extra_vars['value_down'],
scoh=scoh,
density=extra_vars['rdd'],
size=extra_vars['size'],
w=w,
dirs=dirs,
ndirs=extra_vars['ndirs'])
for ccoh in abs_cohs
]
im = sp.array(im_negcoh[1:][::-1] + im_poscoh)
im.shape = (extra_vars['ncoh'], 1, extra_vars['size'],
extra_vars['size'])
# get population
x = model_utils.get_population2(
im,
kind=extra_vars['kind'],
scale=extra_vars['scale'],
npoints=extra_vars['nunits']).transpose(
0, 2, 3, 1) #transpose to bhwc
if build_graph:
with tf.device('/gpu:0'):
with tf.variable_scope('main_' + lesion):
ctx = ContextualCircuit(lesions=lesion)
ctx.run(x) #builds tf graph with shape of x
build_graph = False
# generate random dot stimuli and simulate circuit
##################################################
dec_dir_vote = sp.zeros(
(extra_vars['ncoh'], extra_vars['ntrials']))
dec_variance = sp.zeros(
(extra_vars['ncoh'], extra_vars['ntrials']))
for il in range(extra_vars['ntrials']):
oy, run_time = compute_shifts(
x=x,
ctx=ctx,
extra_vars=extra_vars,
default_parameters=random_parameters)
dec_dir_vote[:,
il], dec_variance[:, il] = model_utils.data_postprocessing(
x, oy, extra_vars
) #maybe return a dict instead?
PSE_vote = sp.zeros((nw, ))
PSE_variance = sp.zeros((nw, ))
dec_dir_vote_fit = sp.zeros((nw, extra_vars['ncoh4fit']))
dec_variance_fit = sp.zeros((nw, extra_vars['ncoh4fit']))
_, PSE_vote[ol], dec_dir_vote_fit[ol] = fit_logistic(
x=coherences,
y=dec_dir_vote[ol].mean(-1),
x_eval=coherences4fit)
_, _, _, dec_variance_fit[ol] = fit_gaussian(
x=coherences,
y=dec_variance[ol].mean(-1),
x_eval=coherences4fit)
PSE_variance[ol] = coherences4fit[
dec_variance_fit[ol].argmax()]
PSE_mixed = (PSE_vote + PSE_variance) / 2.0
y = PSE_mixed * 100 #this is unnecessary for correlation, but let's keep for plotting purposes
import ipdb
ipdb.set_trace()
it_score = np.corrcoef(y, gt)[0, 1] # ** 2
#Add to database
update_data(random_parameters, extra_vars['figure_name'],
hp_set['_id'], it_score)
printProgress(idx,
num_sets,
prefix=extra_vars['figure_name'] +
' progress on lesion ' + lesion + ':',
suffix='Iteration time: ' +
str(np.around(run_time, 2)) + '; Correlation: ' +
str(np.around(it_score, 2)),
bar_length=30)
idx += 1
def optimize_model(gt, extra_vars, parameters):
#Do outer loop of lesions -- embed in variable scopes
for lesion in parameters.lesions:
outer_parameters = deepcopy(parameters)
outer_parameters.lesions = lesion
print('Running optimizations on problem ' + extra_vars['figure_name'] +
' after lesioning: ' + ' '.join(outer_parameters.lesions))
build_graph = True
stimuli = np.load(outer_parameters.f7_stimuli_file)
#Do hp optimization
num_sets = count_sets(lesion, extra_vars['figure_name'])[0]['count']
if num_sets > 0:
idx = 0
#keep a count
#Initialize the session
with tf.Session(config=tf.ConfigProto(
allow_soft_placement=True)) as sess:
while idx < max_its: #while we have hp to run on this lesion
start = timer()
hp_set = get_lesion_rows_from_db(lesion,
extra_vars['figure_name'],
get_one=True)
if hp_set is None:
break
else:
random_parameters = prepare_hps(
outer_parameters, hp_set)
shift_phase = sp.zeros((extra_vars['n_cps'], ))
shift_anti = sp.zeros((extra_vars['n_cps'], ))
for il, col in enumerate(extra_vars['test_colors']):
x = stimuli[il]
extra_vars['x'] = x
extra_vars['test_color'] = col
if build_graph:
with tf.device('/gpu:0'):
with tf.variable_scope('main_' + lesion):
ctx = ContextualCircuit(
lesions=lesion,
parameters=random_parameters.
_DEFAULT_PARAMETERS)
ctx.run(
x
) #builds tf graph with shape of x
build_graph = False
y = compute_shifts(
x=x,
sess=sess,
ctx=ctx,
extra_vars=extra_vars,
default_parameters=random_parameters)
phase, anti = model_utils.data_postprocessing(
x, y, extra_vars)
shift_phase += phase / float(extra_vars['n_col'])
shift_anti += anti / float(extra_vars['n_col'])
phase_score = np.corrcoef(shift_phase * -1,
gt[0])[0, 1] # ** 2
anti_score = np.corrcoef(shift_anti * -1,
gt[1])[0, 1] # ** 2
it_score = np.mean([phase_score, anti_score])
#Add to database
update_data(random_parameters,
extra_vars['figure_name'], hp_set['_id'],
it_score)
end = timer()
printProgress(idx,
num_sets,
prefix=extra_vars['figure_name'] +
' progress on lesion ' + lesion + ':',
suffix='Iteration time: ' +
str(np.around(end - start, 2)) +
'; Correlation: ' +
str(np.around(it_score, 2)) + '\n',
bar_length=30)
if parameters.gaussian_spatial or parameters.gaussian_channel:
break
else:
idx += 1
def optimize_model(im, gt, extra_vars, parameters):
#Do outer loop of lesions -- embed in variable scopes
for lesion in parameters.lesions:
outer_parameters = deepcopy(parameters)
outer_parameters.lesions = lesion
print('Running optimizations on problem ' + extra_vars['figure_name'] +
' after lesioning: ' + ' '.join(outer_parameters.lesions))
#Optional stuff and data prep
if extra_vars['figure_name'] == 'f4': #precalculated
x = im.transpose(0, 2, 3, 1) #need to copy or what?
with tf.device('/gpu:0'):
with tf.variable_scope('aux_' + lesion):
aux_ctx = ContextualCircuit(lesions=lesion)
aux_ctx.run(extra_vars['aux_data']
) #builds tf graph with shape of x
elif extra_vars['figure_name'] == 'tbp' or extra_vars[
'figure_name'] == 'tbtcso' or extra_vars[
'figure_name'] == 'bw' or extra_vars[
'figure_name'] == 'cross_orientation_suppression':
x = im.transpose(0, 2, 3, 1)
else:
x = model_utils.get_population2(
im,
npoints=extra_vars['npoints'],
kind=extra_vars['kind'],
scale=extra_vars['scale']).astype(
outer_parameters._DEFAULT_FLOATX_NP).transpose(
0, 2, 3, 1) #transpose to bhwc
# Build main graph
with tf.device('/gpu:0'):
with tf.variable_scope('main_' + lesion):
ctx = ContextualCircuit(lesions=outer_parameters.lesions)
ctx.run(x) # builds tf graph with shape of x
# Do hp optimization
num_sets = count_sets(lesion, extra_vars['figure_name'])[0]['count']
if num_sets > 0:
idx = 0 # keep a count
# Initialize the session
with tf.Session(config=tf.ConfigProto(
allow_soft_placement=True)) as sess:
while idx < max_its: # while we have hp to run on this lesion
start = timer()
hp_set = get_lesion_rows_from_db(lesion,
extra_vars['figure_name'],
get_one=True)
if hp_set is None and parameters.pachaya is not True and to_opt > 0:
dat = np.array(
get_all_lesion_data(
lesion, table_name=defaults['table_name']))
hist = dat[:, 2:8]
perf = -np.array([[perf_it] for perf_it in dat[:, 8]])
bds = defaults['_DEFAULT_DOMAINS']
# bds = [{'name': 'alpha', 'type': 'continuous', 'domain': (0,1)},
# {'name': 'beta', 'type': 'continuous', 'domain': (0,1)},
# {'name': 'mu', 'type': 'continuous', 'domain': (0,1)},
# {'name': 'nu', 'type': 'continuous', 'domain': (0,1)},
# {'name': 'gamma', 'type': 'continuous', 'domain': (0,1)},
# {'name': 'delta', 'type': 'continuous', 'domain': (0,1)}]
opt_me = GPyOpt.methods.BayesianOptimization(
f=None,
X=hist,
Y=perf,
domain=bds,
evaluator_type='local_penalization')
next_samp = opt_me.suggested_sample[0].tolist()
opt_list = [
'alpha', 'beta', 'mu', 'nu', 'gamma', 'delta'
]
hp_set = dict(zip(opt_list, next_samp))
random_parameters = prepare_hps(
outer_parameters, hp_set)
hp_set['_id'] = max(dat[:, 0]) + 1
add_row_to_db(hp_set, opt_list)
else:
if parameters.pachaya:
random_parameters = prepare_hps(
outer_parameters, None)
else:
random_parameters = prepare_hps(
outer_parameters, hp_set)
# Special case for fig 4
if extra_vars['figure_name'] == 'f4':
extra_vars['aux_y'] = compute_shifts(
x=extra_vars['aux_data'],
sess=sess,
ctx=aux_ctx,
extra_vars=extra_vars,
default_parameters=random_parameters)
# Apply the model to the data
oy = compute_shifts(x=x,
sess=sess,
ctx=ctx,
extra_vars=extra_vars,
default_parameters=random_parameters)
# Postprocess the model's outputs
y, aux_data = model_utils.data_postprocessing(
x, oy, extra_vars) # maybe return a dict instead?
# Correlate simulation and ground truth
it_score = get_fits(y, gt, extra_vars)
# Add to database
if parameters.pachaya and idx == 1:
break
else:
update_data(random_parameters,
extra_vars['figure_name'], hp_set['_id'],
it_score)
end = timer()
printProgress(idx,
max_its,
prefix=extra_vars['figure_name'] +
' progress on lesion ' + lesion + ':',
suffix='Iteration time: ' +
str(np.around(end - start, 2)) +
'; Correlation: ' +
str(np.around(it_score, 5)) + '\n',
bar_length=30)
if parameters.gaussian_spatial or parameters.gaussian_channel:
break
else:
idx += 1
def optimize_model(im, gt, extra_vars, parameters):
#Do outer loop of lesions -- embed in variable scopes
for lesion in parameters.lesions:
print('Running hyperparameter optimizations after lesioning: ' +
' '.join(parameters.lesions))
#Optional stuff and data prep
if extra_vars['figure_name'] == 'f4': #precalculated
x = im.transpose(0, 2, 3, 1) #need to copy or what?
with tf.device('/gpu:0'):
with tf.variable_scope('aux_' + lesion):
aux_ctx = ContextualCircuit(lesions=lesion)
aux_ctx.run(extra_vars['aux_data']
) #builds tf graph with shape of x
elif extra_vars['figure_name'] == 'tbp' or extra_vars[
'figure_name'] == 'tbtcso' or extra_vars['figure_name'] == 'bw':
x = im.transpose(0, 2, 3, 1)
else:
x = model_utils.get_population2(
im,
npoints=extra_vars['npoints'],
kind=extra_vars['kind'],
scale=extra_vars['scale']).astype(
parameters._DEFAULT_FLOATX_NP).transpose(
0, 2, 3, 1) #transpose to bhwc
#Build main graph
with tf.device('/gpu:0'):
with tf.variable_scope('main_' + lesion):
ctx = ContextualCircuit(lesions=parameters.lesions)
ctx.run(x) #builds tf graph with shape of x
#Do hp optimization
for idx in range(parameters.iterations):
hp_sets = get_lesion_row_from_db(lesion)
import ipdb
ipdb.set_trace()
random_parameters = prepare_hps(parameters, hp_sets, idx)
#Special case for fig 4
if extra_vars['figure_name'] == 'f4':
extra_vars['aux_y'], _ = compute_shifts(
x=extra_vars['aux_data'],
ctx=aux_ctx,
extra_vars=extra_vars,
default_parameters=random_parameters)
oy, run_time = compute_shifts(x=x,
ctx=ctx,
extra_vars=extra_vars,
default_parameters=random_parameters)
y, aux_data = model_utils.data_postprocessing(
x, oy, extra_vars) #maybe return a dict instead?
it_score = get_fits(y, gt, extra_vars)
#Add to database
update_data(random_parameters, extra_vars['figure_name'],
hp_sets['idx'][idx], it_score)
printProgress(idx,
parameters.iterations,
prefix='Progress on lesion ' + lesion + ':',
suffix='Iteration time: ' +
str(np.around(run_time, 2)) + '; Rsquared: ' +
str(np.around(it_score, 2)),
bar_length=30)
print('\n')