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