def test_setitem_key_bytes():
reset_options_instance()
source = {bytes(1): 123}
Options(source, run_parser=False)
assert Options().options == source
Options()[bytes(2)] = 'new value'
assert Options()[bytes(2)] == 'new value'
def test_setitem_key_float():
reset_options_instance()
source = {1.2: 123}
Options(source, run_parser=False)
assert Options().options == source
Options()[1.2] = 'new value'
assert Options()[1.2] == 'new value'
def test_setitem_1():
reset_options_instance()
source = {'abc': 123}
Options(source, run_parser=False)
assert Options().options == source
Options()['abc'] = 'new value'
assert Options()['abc'] == 'new value'
def test_save():
""" Test save and load
"""
reset_options_instance()
sys.argv += ['-o', 'tests/sgd.yaml', '--nested.message', 'save']
path_yaml = 'tests/saved.yaml'
Options().save(path_yaml)
with open(path_yaml, 'r') as yaml_file:
options_yaml = yaml.safe_load(yaml_file)
assert (OptionsDict(options_yaml) == OptionsDict({
"message": "sgd",
"sgd": True,
"nested": {
"message": "save"
}
}))
reset_options_instance()
sys.argv += ['-o', 'tests/saved.yaml']
assert (Options().options == OptionsDict({
"path_opts": "tests/saved.yaml",
"message": "sgd",
"sgd": True,
"nested": {
"message": "save"
}
}))
def test_get_default_value():
reset_options_instance()
source = {'abc': 123}
Options(source, run_parser=False)
assert Options().options == source
value = Options().get('cba', 'default value')
assert value == 'default value'
def test_str_to_bool_no():
reset_options_instance()
source = {'abc': 123}
Options(source, run_parser=False)
assert not Options().str_to_bool('no')
assert not Options().str_to_bool('No')
assert not Options().str_to_bool('NO')
def factory(engine):
opt = Options()['model.network']
if opt['name'] == "beef_hdd":
net = BeefHDD(layers_to_fuse=opt['layers_to_fuse'],
label_fusion_opt=opt['label_fusion'],
blinkers_dim=opt['blinkers_dim'],
gru_opt=opt['gru_opt'],
n_future=opt['n_future'],
detach_pred=opt.get('detach_pred',False))
elif opt['name'] == "driver_hdd":
net = DriverHDD(blinkers_dim=opt['blinkers_dim'],
gru_opt=opt['gru_opt'],
n_future=opt['n_future'])
elif opt['name'] == "baseline_multitask_hdd":
net = BaselineMultitaskHDD(n_classes=opt['n_classes'],
blinkers_dim=opt['blinkers_dim'],
layer_to_extract=opt['layer_to_extract'],
dim_features=opt['dim_features'],
gru_opt=opt['gru_opt'],
n_future=opt['n_future'],
mlp_opt=opt.get('mlp_opt',None))
else:
raise ValueError(opt['name'])
if torch.cuda.device_count()>1:
net = DataParallel(net)
return net
def factory(engine=None):
Logger()('Creating network...')
if 'import' in Options()['model']['network']:
module = importlib.import_module(
Options()['model']['network']['import'])
network = module.factory(engine)
else:
module, class_name = opt['name'].rsplit('.', 1)
cls = getattr(import_module('.' + module, 'counting.models.networks'),
class_name)
print("Network parameters", opt['parameters'])
# check if @ in parameters
print("checking if @ in parameters")
for key, value in opt['parameters'].items(
): # TODO intégrer ça à bootstrap
if value.startswith("@"):
try:
output = eval(value[1:])
opt['parameters'][key] = output
except:
pass
net = cls(**opt['parameters'], )
raise ValueError()
Logger()(f'Network created, of type {type(network)}...')
return network
def init_experiment_directory(exp_dir, resume=None):
# create the experiment directory
if not os.path.isdir(exp_dir):
os.system('mkdir -p ' + exp_dir)
else:
if resume is None:
if click.confirm(
'Exp directory already exists in {}. Erase?'.format(
exp_dir, default=False)):
os.system('rm -r ' + exp_dir)
os.system('mkdir -p ' + exp_dir)
else:
os._exit(1)
# if resume to evaluate the model on one epoch
if resume and Options()['dataset']['train_split'] is None:
eval_split = Options()['dataset']['eval_split']
path_yaml = os.path.join(exp_dir,
'options_eval_{}.yaml'.format(eval_split))
logs_name = 'logs_eval_{}'.format(eval_split)
else:
path_yaml = os.path.join(exp_dir, 'options.yaml')
logs_name = 'logs'
# create the options.yaml file
Options.save_yaml_opts(path_yaml)
# open(write) the logs.txt file and init logs.json path for later
Logger(exp_dir, name=logs_name)
def factory_humanProteome(split, trainingDataset=None):
dataset = HumanProteome(Options()['dataset']['dir'],
split,
batch_size=Options()['dataset']['batch_size'],
nb_threads=Options()['dataset']['nb_threads'],
trainingDataset=trainingDataset)
return dataset
def factory_mixedSpectraCrux(split, trainingDataset=None):
dataset = MixedSpectraCrux(Options()['dataset']['dir'],
split,
batch_size=Options()['dataset']['batch_size'],
nb_threads=Options()['dataset']['nb_threads'],
trainingDataset=trainingDataset)
return dataset
def __init__(self):
super(DoubleNPairL2, self).__init__()
self.aggregation = Options()['model']['criterion'].get(
'aggregation', 'mean')
self.epsilon = Options()['model']['criterion'].get(
'epsilon', 0.00000001)
self.batch_size = Options().get("dataset.batch_size", 100)
self.regularizer = Options()['model']['criterion'].get(
'regularizer', 0.1)
# torch.autograd.set_detect_anomaly(True)
self.access_mask = torch.ones([self.batch_size, self.batch_size],
dtype=torch.bool)
for i in range(self.batch_size):
self.access_mask[i, i] = False
self.access_mask[1::2] = False
if torch.cuda.is_available():
self.access_mask = self.access_mask.cuda()
def load_activation(identifier):
retrieval_dir = os.path.join(Options()['model']['metric']['retrieval_dir'],
os.path.basename(Options()['exp']['dir']))
if not os.path.exists(retrieval_dir):
os.makedirs(retrieval_dir)
file_path = os.path.join(retrieval_dir, '{}.pth'.format(identifier))
return torch.load(file_path)
def test_add_options():
reset_options_instance()
sys.argv += [
'-o',
'tests/default.yaml',
'--dataset',
'421',
'--value',
'2',
'--model.metric',
'm1',
'm2',
]
source = {
'dataset': 123,
'value': 1.5,
'model': {
'criterion': ['mse', 'l1'],
'network': 'I am a network',
'metric': [],
},
'useless': None,
}
Options(source, run_parser=True)
assert Options()['dataset'] == 421
assert Options()['value'] == 2
assert isinstance(Options()['value'], float)
assert Options()['model']['metric'] == ['m1', 'm2']
def test_str_to_bool_false():
reset_options_instance()
source = {'abc': 123}
Options(source, run_parser=False)
assert not Options().str_to_bool('false')
assert not Options().str_to_bool('False')
assert not Options().str_to_bool('FALSE')
def test_str_to_bool_true():
reset_options_instance()
source = {'abc': 123}
Options(source, run_parser=False)
assert Options().str_to_bool('true')
assert Options().str_to_bool('True')
assert Options().str_to_bool('TRUE')
def test_str_to_bool_yes():
reset_options_instance()
source = {'abc': 123}
Options(source, run_parser=False)
assert Options().str_to_bool('yes')
assert Options().str_to_bool('Yes')
assert Options().str_to_bool('YES')
def factory(engine):
mode = list(engine.dataset.keys())[0]
dataset = engine.dataset[mode]
opt = Options()['model.network']
if opt['base'] == 'smrl':
from .smrl_net import SMRLNet as BaselineNet
elif opt['base'] == 'updn':
from .updn_net import UpDnNet as BaselineNet
elif opt['base'] == 'san':
from .san_net import SANNet as BaselineNet
else:
raise ValueError(opt['base'])
orig_net = BaselineNet(
txt_enc=opt['txt_enc'],
self_q_att=opt['self_q_att'],
agg=opt['agg'],
classif=opt['classif'],
wid_to_word=dataset.wid_to_word,
word_to_wid=dataset.word_to_wid,
aid_to_ans=dataset.aid_to_ans,
ans_to_aid=dataset.ans_to_aid,
fusion=opt['fusion'],
residual=opt['residual'],
q_single=opt['q_single'],
)
if opt['name'] == 'baseline':
net = orig_net
elif opt['name'] == 'rubi':
net = RUBiNet(model=orig_net,
output_size=len(dataset.aid_to_ans),
classif=opt['rubi_params']['mlp_q'])
elif opt['name'] == 'cfvqa':
net = CFVQA(model=orig_net,
output_size=len(dataset.aid_to_ans),
classif_q=opt['cfvqa_params']['mlp_q'],
classif_v=opt['cfvqa_params']['mlp_v'],
fusion_mode=opt['fusion_mode'],
is_va=True)
elif opt['name'] == 'cfvqasimple':
net = CFVQA(model=orig_net,
output_size=len(dataset.aid_to_ans),
classif_q=opt['cfvqa_params']['mlp_q'],
classif_v=None,
fusion_mode=opt['fusion_mode'],
is_va=False)
else:
raise ValueError(opt['name'])
if Options()['misc.cuda'] and torch.cuda.device_count() > 1:
net = DataParallel(net)
return net
def factory(model, engine=None):
if Options()['optimizer']['name'] == 'trijoint_fixed_fine_tune':
optimizer = Trijoint(Options()['optimizer'], model, engine)
else:
raise ValueError()
return optimizer
def test_items():
reset_options_instance()
source = {'model': 'mymodel'}
Options(source, run_parser=False)
assert Options().options == source
for key, value in Options().items():
assert key == 'model'
assert value == 'mymodel'
def factory_cifar10(split):
dataset = CIFAR(Options()['dataset']['dir'],
split,
batch_size=Options()['dataset']['batch_size'],
nb_threads=Options()['dataset']['nb_threads'],
shuffle=split == 'train',
name='CIFAR10')
return dataset
def __init__(self):
super(NPair, self).__init__()
self.aggregation = Options()['model']['criterion'].get(
'aggregation', 'mean')
self.epsilon = Options()['model']['criterion'].get(
'epsilon', 0.00000001)
def main():
Logger('.')
#classes = ['pizza', 'pork chops', 'cupcake', 'hamburger', 'green beans']
split = 'test'
dir_exp = '/home/cadene/doc/bootstrap.pytorch/logs/recipe1m/trijoint/2017-12-14-15-04-51'
path_opts = os.path.join(dir_exp, 'options.yaml')
dir_extract = os.path.join(dir_exp, 'extract_mean_features', split)
dir_img = os.path.join(dir_extract, 'image')
dir_rcp = os.path.join(dir_extract, 'recipe')
path_model_ckpt = os.path.join(
dir_exp,
'ckpt_best_val_epoch.metric.recall_at_1_im2recipe_mean_model.pth.tar')
Options.load_from_yaml(path_opts)
utils.set_random_seed(Options()['misc']['seed'])
Logger()('Load dataset...')
dataset = factory(split)
Logger()('Load model...')
model = model_factory()
model_state = torch.load(path_model_ckpt)
model.load_state_dict(model_state)
model.set_mode(split)
if not os.path.isdir(dir_extract):
Logger()('Create extract_dir {}'.format(dir_extract))
os.system('mkdir -p ' + dir_extract)
mean_ingrs = torch.zeros(model.network.recipe_embedding.dim_ingr_out *
2) # bi LSTM
mean_instrs = torch.zeros(model.network.recipe_embedding.dim_instr_out)
for i in tqdm(range(len(dataset))):
item = dataset[i]
batch = dataset.items_tf()([item])
batch = model.prepare_batch(batch)
out_ingrs = model.network.recipe_embedding.forward_ingrs(
batch['recipe']['ingrs'])
out_instrs = model.network.recipe_embedding.forward_instrs(
batch['recipe']['instrs'])
mean_ingrs += out_ingrs.data.cpu().squeeze(0)
mean_instrs += out_instrs.data.cpu().squeeze(0)
mean_ingrs /= len(dataset)
mean_instrs /= len(dataset)
path_ingrs = os.path.join(dir_extract, 'ingrs.pth')
path_instrs = os.path.join(dir_extract, 'instrs.pth')
torch.save(mean_ingrs, path_ingrs)
torch.save(mean_instrs, path_instrs)
Logger()('End')
def test_str():
reset_options_instance()
source = {'abc': 123, 'key1': 'value1'}
Options(source, run_parser=False)
assert Options().options == source
str_representation = Options().__str__()
opt_dict = json.loads(str_representation)
assert isinstance(str_representation, str)
assert opt_dict == source
def test_values():
reset_options_instance()
source = {
'model': 'mymodel',
'dataset': 'mydataset'
}
Options(source, run_parser=False)
assert Options().options == source
assert sorted(Options().values()) == sorted(['mymodel', 'mydataset'])
def eval(self):
self.status = 'evaluating'
ckpt_name, path_ckpt = find_ckpt(self.exp_dir,
Options()['pbt']['resume'])
ckpt = torch.load(path_ckpt)
metric_key = Options()['pbt']['resume'].replace('best_', '') # TODO
self.score = ckpt['best_out'][metric_key]
self.status = 'evaluated'
def __init__(self):
self.queue = queue.Queue()
self.pop = collections.OrderedDict()
self.exp_dir = Options()['exp']['dir']
self.path_ckpt = os.path.join(self.exp_dir,
'ckpt_population_last.pth.tar')
self.n_pop_max = Options()['pbt']['n_pop_max']
self.n_workers = Options()['pbt']['n_workers']
self.workers = []
def populate(self):
# TODO: improve populate
path_mutant_opts = Options()['pbt']['path_opts']
for i in range(Options()['pbt']['n_workers']):
exp_mutant_dir = os.path.join(
self.exp_dir, '{:%Y-%m-%d-%H-%M-%S-%f}'.format(datetime.now()))
new_mutant = Mutant(path_mutant_opts, exp_mutant_dir)
self.add_mutant_to_train(new_mutant)
time.sleep(1)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.metric_list = ['_all', '_vq', '_cfvqa', '_q']
if Options()['dataset.eval_split'] == 'test': # 0430
self.accuracy = None
else:
self.accuracy = VQAAccuracy()
self.rm_dir_rslt = 1 if Options(
)['dataset.train_split'] is not None else 0
def factory(engine=None):
opt = Options()['dataset']
dataset = {}
if opt.get('train_split', None):
dataset['train'] = factory_split(opt['train_split'], mode='train')
if opt.get('eval_split', None):
dataset['eval'] = factory_split(opt['eval_split'], mode="eval")
return dataset
