def main(exp_const, data_const, model_const): io.mkdir_if_not_exists(exp_const.exp_dir, recursive=True) io.mkdir_if_not_exists(exp_const.log_dir) io.mkdir_if_not_exists(exp_const.model_dir) io.mkdir_if_not_exists(exp_const.vis_dir) configure(exp_const.log_dir) save_constants({ 'exp': exp_const, 'data': data_const, 'model': model_const }, exp_const.exp_dir) print('Creating network ...') model = Model() model.const = model_const model.net = NET(model.const.net) if model.const.model_num is not None: model.net.load_state_dict(torch.load(model.const.net_path)) model.net.cuda() model.img_mean = np.array([0.485, 0.456, 0.406]) model.img_std = np.array([0.229, 0.224, 0.225]) model.to_file(os.path.join(exp_const.exp_dir, 'model.txt')) print('Creating dataloader ...') dataloaders = {} for mode, subset in exp_const.subset.items(): data_const = copy.deepcopy(data_const) data_const.subset = subset dataset = DATASET(data_const) dataloaders[mode] = DataLoader(dataset, batch_size=exp_const.batch_size, shuffle=True, num_workers=exp_const.num_workers) train_model(model, dataloaders, exp_const)
def main(exp_const,data_const,model_const): io.mkdir_if_not_exists(exp_const.exp_dir,recursive=True) io.mkdir_if_not_exists(exp_const.log_dir) io.mkdir_if_not_exists(exp_const.model_dir) configure(exp_const.log_dir) save_constants({ 'exp': exp_const, 'data': data_const, 'model': model_const}, exp_const.exp_dir) print('Creating network ...') model = Model() model.const = model_const model.encoder = Encoder(model.const.encoder).cuda() model.decoder = Decoder(model.const.decoder).cuda() encoder_path = os.path.join( exp_const.model_dir, f'encoder_{-1}') torch.save(model.encoder.state_dict(),encoder_path) decoder_path = os.path.join( exp_const.model_dir, f'decoder_{-1}') torch.save(model.decoder.state_dict(),decoder_path) print('Creating dataloader ...') dataset = VisualFeaturesDataset(data_const) dataloader = DataLoader( dataset, batch_size=exp_const.batch_size, shuffle=True) train_model(model,dataloader,exp_const)
def main(exp_const, data_const_train, data_const_val, model_const, data_sign='hico'): io.mkdir_if_not_exists(exp_const.exp_dir, recursive=True) io.mkdir_if_not_exists(exp_const.log_dir) io.mkdir_if_not_exists(exp_const.model_dir) configure(exp_const.log_dir) save_constants( { 'exp': exp_const, 'data_train': data_const_train, 'data_val': data_const_val, 'model': model_const }, exp_const.exp_dir) print('Creating model ...') model = Model() model.const = model_const model.hoi_classifier = HoiClassifier(model.const.hoi_classifier, data_sign).cuda() model.to_txt(exp_const.exp_dir, single_file=True) print('Creating data loaders ...') dataset_train = Features(data_const_train) dataset_val = Features(data_const_val) train_model(model, dataset_train, dataset_val, exp_const)
def main(exp_const, data_const, model_const): io.mkdir_if_not_exists(exp_const.exp_dir, recursive=True) io.mkdir_if_not_exists(exp_const.log_dir) io.mkdir_if_not_exists(exp_const.model_dir) configure(exp_const.log_dir) save_constants({ 'exp': exp_const, 'data': data_const, 'model': model_const }, exp_const.exp_dir) print('Creating model ...') model = Model() model.const = model_const model.concat_svm = ConcatSVM(model_const.concat_svm).cuda() model.to_txt(exp_const.exp_dir, single_file=True) print('Creating train data loader ...') train_data_const = copy.deepcopy(data_const) train_data_const.subset = 'train' train_data_loader = DataLoader(SemEval201810Dataset(train_data_const), batch_size=exp_const.batch_size, shuffle=True) print('Creating val data loader ...') val_data_const = copy.deepcopy(data_const) val_data_const.subset = 'val' val_data_loader = DataLoader(SemEval201810Dataset(val_data_const), batch_size=exp_const.batch_size, shuffle=False) print('Begin training ...') train_model(model, train_data_loader, val_data_loader, exp_const)
def main(exp_const, data_const, model_const): print('Creating network ...') model = Model() model.const = model_const model.encoder = Encoder(model.const.encoder).cuda() encoder_path = os.path.join(exp_const.model_dir, 'encoder_' + str(model.const.model_num)) model.encoder.load_state_dict(torch.load(encoder_path)) print('Creating dataloader ...') dataset = VisualFeaturesDataset(data_const) dataloader = DataLoader(dataset, batch_size=exp_const.batch_size, shuffle=True) print('Get features ...') features = get_visual_features(model, dataloader, exp_const) print('Save features h5py ...') word_features_h5py = h5py.File( os.path.join(exp_const.exp_dir, 'word_features.h5py'), 'w') word_features_h5py.create_dataset('features', data=features, chunks=(1, features.shape[1])) word_features_h5py.create_dataset('mean', data=np.mean(features, axis=0)) word_features_h5py.close() print('Save features word idx json ...') word_to_idx_json = os.path.join(exp_const.exp_dir, 'word_to_idx.json') io.dump_json_object(dataloader.dataset.word_to_idx, word_to_idx_json)
def main(exp_const, data_const, model_const): io.mkdir_if_not_exists(exp_const.vis_dir) print('Creating network ...') model = Model() model.const = model_const model.net = ResnetModel(model.const.net) if model.const.model_num is not None: model.net.load_state_dict(torch.load(model.const.net_path)) model.net.cuda() if exp_const.feedforward == False: model.AttributeEmbeddings = AttributeEmbeddings( model.const.AttributeEmbeddings) if model.const.model_num is not None: model.AttributeEmbeddings.load_state_dict( torch.load(model.const.AttributeEmbeddings_path)) model.AttributeEmbeddings.cuda() model.img_mean = np.array([0.485, 0.456, 0.406]) model.img_std = np.array([0.229, 0.224, 0.225]) print('Creating dataloader ...') dataset = Cifar100Dataset(data_const) dataloader = DataLoader(dataset, batch_size=exp_const.batch_size, shuffle=True, num_workers=exp_const.num_workers) eval_results = eval_model(model, dataloader, exp_const) confmat_npy = os.path.join(exp_const.exp_dir, 'confmat.npy') np.save(confmat_npy, eval_results['Conf Mat']) results = { 'Avg Loss': eval_results['Avg Loss'], 'Acc': eval_results['Acc'] } print(results) results_json = os.path.join(exp_const.exp_dir, 'results.json') io.dump_json_object(results, results_json) embeddings_npy = os.path.join(exp_const.exp_dir, 'embeddings.npy') if exp_const.feedforward == True: np.save(embeddings_npy, model.net.resnet_layers.fc.weight.data.cpu().numpy()) else: np.save(embeddings_npy, model.AttributeEmbeddings.embed.weight.data.cpu().numpy()) labels_npy = os.path.join(exp_const.exp_dir, 'labels.npy') np.save(labels_npy, dataset.labels)
def main(exp_const, data_const, model_const): io.mkdir_if_not_exists(exp_const.exp_dir, recursive=True) io.mkdir_if_not_exists(exp_const.log_dir) io.mkdir_if_not_exists(exp_const.model_dir) io.mkdir_if_not_exists(exp_const.vis_dir) configure(exp_const.log_dir) if model_const.model_num is None: const_dict = { 'exp': exp_const, 'data': data_const, 'model': model_const } else: const_dict = { f'exp_finetune_{model_const.model_num}': exp_const, f'data_finetune_{model_const.model_num}': data_const, f'model_finetune_{model_const.model_num}': model_const } save_constants(const_dict, exp_const.exp_dir) print('Creating network ...') model = Model() model.const = model_const model.net = LogBilinear(model.const.net) if model.const.model_num is not None: model.net.load_state_dict(torch.load(model.const.net_path)) model.net.cuda() model.to_file(os.path.join(exp_const.exp_dir, 'model.txt')) print('Creating positive dataloader ...') dataset = MultiSenseCooccurDataset(data_const) collate_fn = dataset.create_collate_fn() dataloader = DataLoader(dataset, batch_size=exp_const.batch_size, shuffle=True, num_workers=exp_const.num_workers, collate_fn=collate_fn) print('Creating negative dataloader ...') neg_dataset = NegMultiSenseCooccurDataset(data_const) collate_fn = neg_dataset.create_collate_fn() neg_dataloader = DataLoader(neg_dataset, batch_size=exp_const.batch_size, shuffle=True, num_workers=exp_const.num_workers, collate_fn=collate_fn) err_msg = f'Num words mismatch (try {len(dataset.words)})' assert (len(dataset.words) == model.const.net.num_words), err_msg train_model(model, dataloader, neg_dataloader, exp_const)
def main(exp_const, data_const, model_const): print('Loading model ...') model = Model() model.const = model_const model.hoi_classifier = HoiClassifier(model.const.hoi_classifier).cuda() if model.const.model_num == -1: print( 'No pretrained model will be loaded since model_num is set to -1') else: model.hoi_classifier.load_state_dict( torch.load(model.const.hoi_classifier.model_pth)) print('Creating data loader ...') dataset = Features(data_const) eval_model(model, dataset, exp_const)
def main(exp_const,data_const,model_const): print('Creating network ...') model = Model() model.const = model_const model.net = LogBilinear(model.const.net) if model.const.model_num is not None: model.net.load_state_dict(torch.load(model.const.net_path)) embeddings = 0.5*(model.net.embed1.W.weight + model.net.embed2.W.weight) embeddings = embeddings.data.numpy() embeddings_json = os.path.join(exp_const.exp_dir,'visual_embeddings.npy') np.save(embeddings_json,embeddings) print('Saving word_to_idx.json ...') dataset = MultiSenseCooccurDataset(data_const) word_to_idx = dataset.word_to_idx word_to_idx_json = os.path.join(exp_const.exp_dir,'word_to_idx.json') io.dump_json_object(word_to_idx,word_to_idx_json)
def main(exp_const, data_const, model_const): io.mkdir_if_not_exists(exp_const.exp_dir, recursive=True) io.mkdir_if_not_exists(exp_const.log_dir) io.mkdir_if_not_exists(exp_const.model_dir) io.mkdir_if_not_exists(exp_const.vis_dir) configure(exp_const.log_dir) save_constants({ 'exp': exp_const, 'data': data_const, 'model': model_const }, exp_const.exp_dir) print('Creating network ...') model = Model() model.const = model_const model.net = ResnetModel(model.const.net) model.embed2class = Embed2Class(model.const.embed2class) if model.const.model_num is not None: model.net.load_state_dict(torch.load(model.const.net_path)) model.embed2class.load_state_dict( torch.load(model.const.embed2class_path)) model.net.cuda() model.embed2class.cuda() model.img_mean = np.array([0.485, 0.456, 0.406]) model.img_std = np.array([0.229, 0.224, 0.225]) model.to_file(os.path.join(exp_const.exp_dir, 'model.txt')) print('Creating dataloader ...') dataloaders = {} for mode, subset in exp_const.subset.items(): data_const = copy.deepcopy(data_const) if subset == 'train': data_const.train = True else: data_const.train = False dataset = Cifar100Dataset(data_const) collate_fn = dataset.get_collate_fn() dataloaders[mode] = DataLoader(dataset, batch_size=exp_const.batch_size, shuffle=True, num_workers=exp_const.num_workers, collate_fn=collate_fn) train_model(model, dataloaders, exp_const)
def main(exp_const, data_const, model_const): print('Creating model ...') model = Model() model.const = model_const model.concat_svm = ConcatSVM(model_const.concat_svm).cuda() print('Select best model ...') step_to_val_best_scores_tuple_json = os.path.join( exp_const.exp_dir, 'step_to_val_best_scores_tuple.json') step_to_val_best_scores_tuple = io.load_json_object( step_to_val_best_scores_tuple_json) best_step, best_scores_tuple = select_best_concat_svm( step_to_val_best_scores_tuple) model.concat_svm.const.thresh = best_scores_tuple[4] model_pth = os.path.join(exp_const.model_dir, f'{best_step}') model.concat_svm.load_state_dict(torch.load(model_pth)) print(f'Selcted model at step: {best_step}') print(f'Selected thresh: {model.concat_svm.const.thresh}') print('Creating data loader ...') data_const = copy.deepcopy(data_const) data_loader = DataLoader(SemEval201810Dataset(data_const), batch_size=exp_const.batch_size, shuffle=False) print('Begin evaluation ...') result, correct_preds, incorrect_preds = eval_model( model, data_loader, exp_const) result_json = os.path.join(exp_const.exp_dir, f'results_{data_const.subset}.json') io.dump_json_object(result, result_json) print(io.dumps_json_object(result)) correct_preds_json = os.path.join( exp_const.exp_dir, f'correct_preds_{data_const.subset}.json') io.dump_json_object(correct_preds, correct_preds_json) incorrect_preds_json = os.path.join( exp_const.exp_dir, f'incorrect_preds_{data_const.subset}.json') io.dump_json_object(incorrect_preds, incorrect_preds_json)
def main(exp_const, data_const, model_const): print('Creating network ...') model = Model() model.const = model_const model.net = LogBilinear(model.const.net) if model.const.model_num is not None: model.net.load_state_dict(torch.load(model.const.net_path)) embeddings = 0.5 * (model.net.embed1.W.weight + model.net.embed2.W.weight) print('Computing transformed embeddings ...') xformed_embeddings = [] for cooccur_type in exp_const.cooccur_types: xform = getattr(model.net, f'xform_{cooccur_type}') xformed_embeddings.append(xform(embeddings).cpu().data.numpy()) print(cooccur_type, xformed_embeddings[-1].shape) xformed_embeddings = np.concatenate(xformed_embeddings, 1) print('Concatenated xformed embedding shape', xformed_embeddings.shape) xformed_embeddings_json = os.path.join(exp_const.exp_dir, 'visual_embeddings_xformed.npy') np.save(xformed_embeddings_json, xformed_embeddings)
def main(exp_const, data_const, model_const): print('Loading model ...') model = Model() model.const = model_const model.hoi_classifier = HoiClassifier(model.const.hoi_classifier).cuda() if model.const.model_num == -1: print( 'No pretrained model will be loaded since model_num is set to -1') else: state = torch.load(model.const.hoi_classifier.model_pth ) #---------------------------!!!!!!!!!!!!!!!!!!! state = { kk: state[kk] for kk in state.keys() if not 'mlp.embedding' in kk } #pdb.set_trace() model.hoi_classifier.load_state_dict(state) #model.hoi_classifier.load_state_dict( # torch.load(model.const.hoi_classifier.model_pth)) print('Creating data loader ...') dataset = Features(data_const) eval_model(model, dataset, exp_const)