def evaluate_protocol(evaluate_config_path,model_config_path,image_config_path,write=False):
model_config_gen = get_config(model_config_path)
image_config_gen = get_config(image_config_path)
overall_config_gen = SON([('models',model_config_gen['models']),
('images',image_config_gen['images'])])
feature_hash = get_config_string(overall_config_gen)
feature_certificate = '../.feature_certificates/' + feature_hash
evaluate_config = get_config(evaluate_config_path)
task_config = evaluate_config.pop('train_test')
D = []
ext_hashes = []
for task in task_config:
overall_config_gen = SON([('models',model_config_gen),
('image',image_config_gen),('task',task)])
ext_hash = get_config_string(overall_config_gen)
outfile = '../.performance_certificates/' + ext_hash
op = ('svm_evaluation_' + ext_hash,evaluate,(outfile,feature_certificate,
evaluate_config_path,task,ext_hash))
D.append(op)
ext_hashes.append(ext_hash)
if write:
actualize(D)
return D,ext_hashes
def extract_and_evaluate_protocol(evaluate_config_path,model_config_path,image_config_path,convolve_func_name='numpy', write=False,parallel=False):
model_config_gen = get_config(model_config_path)
model_hash = get_config_string(model_config_gen['models'])
model_certificate = '../.model_certificates/' + model_hash
image_config_gen = get_config(image_config_path)
image_hash = get_config_string(image_config_gen['images'])
image_certificate = '../.image_certificates/' + image_hash
evaluate_config = get_config(evaluate_config_path)
task_config = evaluate_config.pop('train_test')
D = []
DH = {}
for task in task_config:
overall_config_gen = SON([('models',model_config_gen),('images',image_config_gen),('task',task)])
ext_hash = get_config_string(overall_config_gen)
if not parallel:
performance_certificate = '../.performance_certificates/' + ext_hash
op = ('evaluation_' + ext_hash,extract_and_evaluate,(performance_certificate,image_certificate,model_certificate,evaluate_config_path,convolve_func_name,task,ext_hash))
D.append(op)
DH[ext_hash] = [op]
else:
performance_certificate = '../.performance_certificates/' + ext_hash
batch_certificate = '../.batch_certificates/' + ext_hash
op = ('evaluation' + ext_hash,extract_and_evaluate_parallel,(batch_certificate,image_certificate,model_certificate,evaluate_config_path,convolve_func_name,task,ext_hash))
D.append(op)
DH[ext_hash] = [op]
if write:
actualize(D)
return DH
def v1_greedy_optimization_protocol(config_path,use_cpu = False,write=False):
D = DBAdd(image_initialize,args = (config_path,))
oplist = do_initialization(image_initialize,args = (config_path,))
image_certificate = oplist[0]['outcertpaths'][0]
if use_cpu or not GPU_SUPPORT:
convolve_func = v1f.v1like_filter_numpy
else:
convolve_func = v1f.v1like_filter_pyfft
config = get_config(config_path)
task = config['evaluation_task']
initial_model = config['model']
modifier_args = config['modifier_args']
modifier_class = config.get('modifier')
rep_limit = config.get('rep_limit')
if modifier_class is None:
modifier = config_modifiers.BaseModifier(modifier_args)
else:
modifier = modifier_class(modifier_args)
newhash = get_config_string(config)
outfile = '../.optimization_certificates/' + newhash
op = ('optimization_' + newhash,greedy_optimization,(outfile,task,image_certificate,initial_model,convolve_func,rep_limit,modifier_args,modifier))
D.append(op)
if write:
actualize(D)
return D
def test_learning_initialize(config_path):
config = get_config(config_path)
image_params = SON([('image',config['image'])])
model_params = SON([('model',config['model'])])
return [('generate_images', render_image, {'args':(image_params,)}),
('generate_models', learn_filterbank, {'params':model_params})]
def v1_evaluation_protocol(task_config_path,feature_config_path,use_cpu=False):
oplist = do_initialization(v1_initialize,args = (feature_config_path,use_cpu))
feature_creates = tuple(oplist[-1]['outcertpaths'])
hash = get_config_string(oplist[-1]['out_args'])
feature_config = get_config(feature_config_path)
task_config = get_config(task_config_path)
D = []
for task in task_config['train_test']:
c = (feature_config,task)
newhash = get_config_string(c)
outfile = '../.performance_certificates/' + newhash
op = ('svm_evaluation_' + newhash,train_test_loop,(outfile,feature_creates,task,feature_config_path,hash))
D.append(op)
return D
def model_protocol(config_path,write = False,parallel=False):
config = get_config(config_path)
model_hash = get_config_string(config['models'])
model_certificate = '../.model_certificates/' + model_hash
D = [('generate_models',generate_models,(model_certificate,model_hash,config))]
if write:
actualize(D)
return D,model_hash
def extract_features_protocol(image_config_path,
model_config_path,
convolve_func_name = 'numpy',
write = False,
parallel=False,
batch_size=1000):
model_config_gen = get_config(model_config_path)
model_hash = get_config_string(model_config_gen['models'])
model_certificate = '../.model_certificates/' + model_hash
image_config_gen = get_config(image_config_path)
image_hash = get_config_string(image_config_gen['images'])
image_certificate = '../.image_certificates/' + image_hash
overall_config_gen = SON([('models',model_config_gen['models']),('images',image_config_gen['images'])])
feature_hash = get_config_string(overall_config_gen)
feature_certificate = '../.feature_certificates/' + feature_hash
if not parallel:
D = [('extract_features',
extract_features,(feature_certificate,
image_certificate,
model_certificate,
overall_config_gen,
feature_hash,
convolve_func_name))]
else:
D = [('extract_features',
extract_features_parallel,(feature_certificate,
image_certificate,
model_certificate,
overall_config_gen,
feature_hash,
convolve_func_name,
batch_size))]
if write:
actualize(D)
return D, feature_hash
def image_protocol(config_path,write = False,parallel=False):
config = get_config(config_path)
image_hash = image_protocol_hash(config_path)
image_certificate = '../.image_certificates/' + image_hash
if not parallel:
D = [('generate_images',generate_images,(image_certificate,image_hash,config))]
else:
D = [('generate_images',generate_images_parallel,(image_certificate,image_hash,config))]
if write:
actualize(D)
return D,image_hash
def train_test_loop(outfile,extract_creates,task_config,feature_config_path,hash):
feature_config = get_config(feature_config_path)
base_query = SON([('__config_hash__',hash)])
image_params = SON([('image',feature_config['image'])])
models_params = feature_config['models']
ntrain = task_config['ntrain']
ntest = task_config['ntest']
ntrain_pos = task_config.get('ntrain_pos')
N = task_config.get('N',10)
query = task_config['query']
base_query.update(reach_in('config',task_config.get('universe',SON([]))))
print('\n')
print('BASE',base_query)
print('\n')
conn = pm.Connection(document_class=SON)
db = conn['v1']
fs = gridfs.GridFS(db, collection = 'model_performance')
cquery = reach_in('config',query)
for m in models_params:
base_query_copy = base_query.copy()
base_query_copy.update(reach_in('config.model',m))
splitdata, results = train_test(cquery,'v1','features',ntrain,ntest,ntrain_pos=ntrain_pos,N=N,universe=base_query_copy)
splitpickle = cPickle.dumps(splitdata)
data = SON([('feature_config_path',feature_config_path),
('model',m),
('task',son_escape(task_config)),
('image__aggregate__',son_escape(feature_config['image']))])
filename = get_filename(data)
data.update(results)
data['filename'] = filename
fs.put(splitpickle,**data)
createCertificateDict(outfile,{'task_config':task_config,'feature_config':feature_config,'feature_config_path':feature_config_path})
def run_full_protocol(config_path,
extract_and_evaluate=True,
parallel=False,
feature_batch_size=1000,
convolve_func_name='numpy'):
config = get_config(config_path)
hashes = []
if 'images' in config:
im_hash = images(config_path,parallel=parallel)
hashes.append(im_hash)
if 'models' in config:
m_hash = models(config_path,parallel=parallel)
hashes.append(m_hash)
if 'images' in config and 'models' in config:
if not 'train_test' in config:
f_hash = extract_features(config_path,
config_path,
convolve_func_name=convolve_func_name,
parallel=parallel,
batch_size=feature_batch_size)
hashes.append(f_hash)
elif extract_and_evaluate:
e_hashes = extract_and_evaluate(config_path,config_path,config_path,
convolve_func_name=convolve_func_name)
hashes.extend(e_hashes)
else:
f_hash = extract_features(config_path,
config_path,
convolve_func_name=convolve_func_name,
parallel=parallel,
batch_size=feature_batch_size)
e_hashes = evaluate(config_path,config_path,config_path)
hashes.append(f_hash).extend(e_hashes)
codes = ['^.*' + h for h in hashes]
update.FullUpdate(AU=codes)
def image_initialize(config_path):
config = get_config(config_path)
image_params = SON([('image',config['image'])])
return [{'step':'generate_images','func':v1e.render_image, 'params':(image_params,)},
]
def image_protocol_hash(config_path):
config = get_config(config_path)
image_hash = get_config_string(config['images'])
return image_hash
