def main():
# Load the parameters from json file
args = parser.parse_args()
json_path = os.path.join(args.model_dir, 'params.json')
params = Params(json_path)
# Set the logger
set_logger(os.path.join(args.model_dir, 'train.log'))
# Create the input data pipeline
logging.info('Creating the dataset...')
data_dir = args.data_dir
valid_data_dir = os.path.join(data_dir, 'valid')
# Get the filenames and labels from the test set
valid_filenames, valid_labels = get_filenames_and_labels(
valid_data_dir, params)
params.valid_size = len(valid_filenames)
params.num_labels = len(set(valid_labels))
# Create the two iterators over the two datasets
valid_inputs = input_fn(False, valid_filenames,
valid_labels, params)
# Define the model
logging.info("Creating the model...")
model_spec = model_fn('eval', valid_inputs, params,
reuse=False)
logging.info("Starting evaluation")
evaluate(model_spec, args.model_dir, params,
args.restore_from)
def main(path):
train, test, valid = read_data(path)
model = build_model().fit(train)
model[-1].set_params(batch_size=32)
evaluate(model, train.sample(frac=0.015), "train")
evaluate(model, valid.sample(frac=0.1), "valid")
def main(path):
train, test, valid = read_data(path)
with timer("Fit the data"):
model = build_model().fit(train)
evaluate(model, valid, "validatoin")
evaluate(model, test, "test")
def test(model, data_iter, data_tag):
model.eval()
output_with_label = []
test_loss, sample_cnt = 0.0, 0
for batch_index, batch in enumerate(data_iter):
samples = batch.text.to(DEVICE)
task_dict = {
"cpu": batch.cpu.to(DEVICE),
"ram": batch.ram.to(DEVICE),
"screen": batch.screen.to(DEVICE),
"hdisk": batch.hdisk.to(DEVICE),
"gcard": batch.gcard.to(DEVICE)
}
outputs = model(samples, task_dict)
output_with_label.append((outputs, task_dict))
task_loss = [
criterion(outputs[index], task_dict[device])
for index, device in enumerate(DEVICE_ORDER)
]
loss = sum(task_loss)
test_loss += loss
sample_cnt += outputs[0].shape[0]
result = evaluate(output_with_label, data_tag)
model.train()
return test_loss / sample_cnt, result
def test(model, data_iter, data_tag):
model.eval()
output_with_label = []
test_loss, sample_cnt = 0.0, 0
for batch_index, batch in enumerate(data_iter):
samples = batch.text.to(DEVICE)
task_dict = {
"cpu": batch.cpu.to(DEVICE),
"ram": batch.ram.to(DEVICE),
"screen": batch.screen.to(DEVICE),
"hdisk": batch.hdisk.to(DEVICE),
"gcard": batch.gcard.to(DEVICE)
}
forward_outputs, backward_outputs = model(samples, task_dict)
output_with_label.append((forward_outputs, task_dict))
# task_loss = [criterion_dict[data_tag][device](outputs[index], target_dict[device]) for index, device in enumerate(DEVICE_ORDER)]
task_loss_backward = sum([
criterion(backward_outputs[index], task_dict[device])
for index, device in enumerate(REVERSED_DEVICE_ORDER)
])
task_loss_forward = sum([
criterion(forward_outputs[index], task_dict[device])
for index, device in enumerate(DEVICE_ORDER)
])
loss = task_loss_forward + task_loss_backward
test_loss += loss
sample_cnt += forward_outputs[0].shape[0]
result = evaluate(output_with_label, data_tag)
model.train()
return test_loss / sample_cnt, result
def funct(x):
# Set the random seed for the whole graph
tf.set_random_seed(230)
# Load the parameters
args = parser.parse_args()
json_path = os.path.join(args.model_dir, 'params.json')
assert os.path.isfile(json_path), "No json configuration file found at {}".format(json_path)
params = Params(json_path)
# Set the logger
set_logger(os.path.join(args.data_dir, 'predict.log'))
# Create the input data pipeline
data_dir = args.data_dir
test_data_dir = os.path.join(data_dir)
# Get the filenames from the test set
test_filenames = [os.path.join(test_data_dir, 'predict.jpg') ]
test_labels = [x]
# print(test_labels)
# specify the size of the evaluation set
params.eval_size = len(test_filenames)
# create the iterator over the dataset
test_inputs = input_fn(False, test_filenames, test_labels, params)
# Define the model
model_spec = model_fn('eval', test_inputs, params, reuse=tf.AUTO_REUSE)
evaluate(model_spec, args.model_dir, params, args.restore_from)
def main():
# Load parameters from json file
args = parser.parse_args()
json_path = os.path.join(args.model_dir, 'params.json')
assert os.path.isfile(
json_path), "No json configuration file found at {}".format(json_path)
params = Params(json_path)
# use GPU if found
params.cuda = torch.cuda.is_available()
if params.cuda:
params.device = torch.device('cuda:0')
else:
params.device = torch.device('cpu')
# Set a seed for reproducible experiments
torch.manual_seed(141)
if params.cuda:
torch.cuda.manual_seed(141)
# Set the testing logger for updates
set_logger(os.path.join(args.model_dir, 'inference.log'))
logging.info("Creating input pipelines...")
data_pipelines = fetch_pipeline(['test'], args.data_dir, params)
test_pipeline = data_pipelines['test']
logging.info("Completed (Testing Dataset)!")
logging.info("Building network model...")
model_spec = model_fn(params)
logging.info("Building completed!")
logging.info("Initiate inference procedure!")
evaluate(model_spec, test_pipeline, args.model_dir, params,
args.restore_from)
logging.info("Inference completed!")
def main(path):
train, test, valid = read_data(path)
data = ev_data(train["text"])
print(data)
model = build_model(ev_data(valid["text"])).fit(data)
evaluate(model, test.sample(frac=0.1), "test")
evaluate(model, valid, "valid")
evaluate(model, train, "train")
def main(path):
train, test, valid = read_data(path)
data = ev_data(train["text"])
print(data)
model = build_model(ev_data(valid["text"])).fit(data)
model[-1].set_params(batch_size=32)
evaluate(model, test, "test")
evaluate(model, valid, "valid")
evaluate(model, train, "train")
# Get paths for vocabularies and dataset
path_vocab = os.path.join(args.data_dir, 'vocab{}'.format(params.min_freq))
params.vocab_path = path_vocab
path_test_queries = os.path.join(args.data_dir, 'dev/queries.txt')
path_test_articles = os.path.join(args.data_dir, 'dev/articles.txt')
# Load Vocabularies
vocab = tf.contrib.lookup.index_table_from_file(
path_vocab, num_oov_buckets=num_oov_buckets, key_column_index=0)
# Create the input data pipeline
logging.info("Creating the dataset...")
test_queries = load_dataset_from_text(path_test_queries, vocab, params)
test_articles = load_dataset_from_text(path_test_articles, vocab, params)
# Specify other parameters for the dataset and the model
params.eval_size = params.test_size
params.id_pad_word = vocab.lookup(tf.constant(params.pad_word))
# Create iterator over the test set
inputs = input_fn('eval', test_queries, test_articles, params)
logging.info("- done.")
# Define the model
logging.info("Creating the model...")
model_spec = model_fn('eval', inputs, params, reuse=False)
logging.info("- done.")
logging.info("Starting evaluation")
evaluate(model_spec, args.model_dir, params, args.restore_from)
tf.set_random_seed(230)
# TODO: Load the parameters
config_args = parse_args()
# Create the inputs data pipeline
data_dir = 'dataset/cone/'
model_dir = 'experiments/basic_model'
restore_from = 'best_weights'
image_dir = os.path.join(data_dir, 'Images')
label_dir = os.path.join(data_dir, 'Labels')
test_filenames, test_labels = get_filenames_and_labels(
image_dir, label_dir, 'test')
# create ssd labels
test_size = len(test_filenames)
preset = get_preset_by_name('ssdmobilenet160')
test_labels = create_labels(preset, test_size, 2, test_labels)
print("[INFO] Test labels Shape:", test_labels.shape)
# Create the two iterators over the two datasets
test_inputs = input_fn(False, test_filenames, test_labels, config_args)
# Define the model
model_specs = model_fn('eval', test_inputs, preset, config_args)
evaluate(model_specs, model_dir, config_args, restore_from)
def model(params):
start = time.time()
accuracies_normal = {}
accuracies_max = {}
max_h_accs = []
early_stopping = {}
print('\n## PARAMS:')
for key, value in flatten_dict(params).items():
print('{}: {}'.format(key, value))
print()
for dataset in params['config']['datasets']:
print('Dataset: {}'.format(dataset))
resnet_features, attributes, labels = get_data(
dataset=dataset,
split=params['config']['split'],
data_path=data_dir)
"""
Model
"""
model, (eval_q_mu_img, eval_q_mu_att), (
eval_z_img, eval_z_att) = build_cada_vae(
latent_size=params['vae']['latent_size'],
hidden_size_enc_img=params['vae']['hidden_size']['img_enc'],
hidden_size_enc_att=params['vae']['hidden_size']['att_enc'],
hidden_size_dec_img=params['vae']['hidden_size']['att_dec'],
hidden_size_dec_att=params['vae']['hidden_size']['img_dec'],
img_shape=resnet_features['train_seen'].shape[1:],
semantic_shape=attributes['train_seen'].shape[1:],
lr=params['vae']['lr'],
sample_like_cada_vae=params['vae']['sample_like_cada_vae'],
)
cb = CadaVaeCallback(
resnet_features=resnet_features,
attributes=attributes,
labels=labels,
beta_factor=params['beta']['factor'],
beta_start=params['beta']['start'],
beta_end=params['beta']['end'],
r_factor=params['reconstruction']['factor'],
cr_factor=params['cross-reconstruction']['factor'],
cr_start=params['cross-reconstruction']['start'],
cr_end=params['cross-reconstruction']['end'],
alignment_factor=params['alignment']['factor'],
alignment_start=params['alignment']['start'],
alignment_end=params['alignment']['end'],
tfcallback=tfcallback)
print('## Training model')
model.fit(
x=[
resnet_features['train_seen'], attributes['train_seen'],
resnet_features['train_seen'], attributes['train_seen']
],
y=[resnet_features['train_seen']],
callbacks=[cb],
epochs=params['vae']['epochs'],
verbose=2,
batch_size=params['vae']['batch_size'],
)
"""
Evaluate
"""
print('## Start evaluation:')
(s, u, h), (max_s, max_u, max_h, max_epoch), classifier = evaluate(
resnet_features=resnet_features,
attributes=attributes,
labels=labels,
eval_z_img=eval_z_img,
eval_z_att=eval_z_att,
eval_q_mu_img=eval_q_mu_img,
samples_per_class_seen=params['samples_per_class']['seen'],
samples_per_class_unseen=params['samples_per_class']['unseen'],
cls_train_steps=params['cls']['epochs'][dataset],
cls_batch_size=params['cls']['batch_size'],
lr_cls=params['cls']['lr'],
latent_size=params['vae']['latent_size'],
num_shots=params['config']['num_shots'],
verbose=False,
tb_dir=tb_dir,
)
accuracies_normal[dataset] = (s, u, h)
accuracies_max[dataset] = (max_s, max_u, max_h, max_epoch)
print('Accuracies normal: {}'.format(accuracies_normal[dataset]))
print('Accuracies max: {}:'.format(accuracies_max[dataset]))
max_h_accs.append(max_h)
early_stopping[dataset] = max_epoch
if not os.path.isdir(output_dir):
os.makedirs(output_dir)
model.save_weights(output_dir + '{}_vae_rm_{}_{:.2f}.pkl'.format(
dataset, params['config']['split'], max_h))
model.save_weights(output_dir +
'{}_vae_rm_softmax_{}_{:.2f}.pkl'.format(
dataset, params['config']['split'], max_h))
print('Saved weights')
K.clear_session()
end = time.time()
print('Minutes for past run: {:.1f}'.format((end - start) / 60))
data['loss'] = -np.mean(max_h_accs)
data['accuracies_normal'] = accuracies_normal
data['accuracies_max'] = accuracies_max
data['params'] = params
data['early_stopping_epoch_softmax'] = early_stopping
data['time_for_one_run_in_s'] = end - start
now = datetime.datetime.now()
data['date'] = '{}_{}_{}_{}_{}'.format(now.year, now.month, now.day,
now.hour, now.minute)
with open(output_dir + 'results.pkl', 'wb') as handle:
pickle.dump(data, handle, protocol=pickle.HIGHEST_PROTOCOL)
return {
'loss': -np.mean(max_h_accs),
'status': STATUS_OK,
'output_dir': output_dir
} # for hyperopt optimization library
