def main(args): print('\nPreparing {} data'.format(args.dataset)) if args.dataset == 'mnist': (X_train, y_train), (X_test, y_test), (X_valid, y_valid) = load_mnist() elif args.dataset == 'cifar10': (X_train, y_train), (X_test, y_test), (X_valid, y_valid) = load_cifar10() elif args.dataset == 'cifar100': (X_train, y_train), (X_test, y_test), (X_valid, y_valid) = load_cifar100() print('\nConstruction graph') if args.model == 'cnn_1': env = cnn_1(args) elif args.model == 'cnn_2': env = cnn_2(args) elif args.model == 'vgg16': env = vgg16(args) elif args.model == 'vgg19': env = vgg19(args) print('\nInitializing graph') sess = tf.InteractiveSession() sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) print('\nTraining') name = '{0}_{1}'.format(args.model, args.dataset) train(sess, env, X_train, y_train, X_valid, y_valid, batch_size=args.batch_size, epochs=args.epochs, name=name) print('\nEvaluating on clean data') evaluate(sess, env, X_test, y_test)
def main(): os.environ['CUDA_VISIBLE_DEVICES'] = '7' # init() # acc_original = evaluate(model_checkpoint_path='log/model_dump/model.ckpt', has_bn=True, # qweight=False, qactivation=False, image_norm=True) # fix_input_params() # acc_fix_input = evaluate(model_checkpoint_path='log/model_dump/model_fix_input.ckpt', has_bn=True, # qweight=False, qactivation=False, image_norm=False) # find_quantize_scale('log/model_dump/model_fix_input.ckpt') # acc_int = evaluate(model_checkpoint_path='log/model_dump/model_fix_input.ckpt', has_bn=True, # qweight=True, qactivation=True, image_norm=False) bn_ema('log/model_dump/model_fix_input.ckpt', qweight=True, qactivation=True) acc_int_bn_ema = evaluate( model_checkpoint_path='log/model_dump/model_fix_input_bn_ema.ckpt', has_bn=True, qweight=True, qactivation=True, image_norm=False) # print('float acc = %.3f%%' % acc_original) # print('float fix input = %.3f%%' % acc_fix_input) # print('int acc = %.3f%%' % acc_int) print('int acc after bn ema = %.3f%%' % acc_int_bn_ema)
def reward(encoder_input, encoder_label, dim_indices, vis_type, reward_type, with_label, evaluate_tool=None, label_num=0): """ Parameters ---------- encoder_input: torch.FloatTensor containing static (e.g. w, h) data (batch_size, sourceL, num_cities) dim_indices: torch.IntTensor of size (batch_size, num_cities) Returns ------- Total Euclidean distance between neighbor dimensions. of size (batch_size, num_cities) """ use_cuda = encoder_input.is_cuda data_num = encoder_input.shape[1] dim_num = encoder_input.shape[2] # batch_size x dim_num // dim_indices and expand as(static) idx = dim_indices.unsqueeze(1).repeat(1, data_num, 1) sample_input = torch.gather(encoder_input.data, 2, idx) sample_label = torch.gather(encoder_label.data, 2, idx) batch_size = sample_input.shape[0] scores = torch.zeros(batch_size).detach() if use_cuda: scores = scores.cuda() order = None if evaluate_tool is None: scores = tools.evaluate(sample_input, sample_label, order, vis_type, reward_type, with_label, label_num=label_num) else: scores = evaluate_tool.evaluate(sample_input, sample_label, order, vis_type, reward_type, with_label, label_num=label_num) # if reward_type == 'parg_pcc': # scores = abs(scores) # scores = -scores return scores
def __init__(self): self._classifier = AdaBoostClassifier(n_estimators=1000, learning_rate=0.5) # Best classifier self._database = tools.load_database() self._X, self._Y = tools.prepare_database(self._database) self._vocabulary, self._vocabulary_vectors = tools.create_bag_of_words(self._X) # Creates Bag of Words model self._features_train, self._features_test, self._labels_train, self._labels_test = tools.split_dataset(self._vocabulary_vectors, self._Y) self._classifier.fit(self._features_train, self._labels_train) self._scores = tools.evaluate(self._labels_test, self._classifier.predict(self._features_test))
def train(self, max_depth=3): for i in range(self.T): pred_y = np.array([]) # k*m # Train weak learner using distribution D_t for j in range(self.k): self.h_t = self.model(max_depth=max_depth, presort=True) self.h_t.fit(self.X, self.y[j * self.m:(j + 1) * self.m], sample_weight=self.D_t[j * self.m:(j + 1) * self.m]) # Get weak hypothesis h_t self.h.append(self.h_t) # Choose alpha_t pred_y = np.append(pred_y, self.h_t.predict(self.X)) r_t = np.dot(self.D_t, np.multiply(self.y, pred_y)) if abs(r_t - 1) < 0.00000001: self.alpha_t = 0.5 * log( (1 + r_t + 0.000001) / (1 - r_t + 0.000001)) else: self.alpha_t = 0.5 * log((1 + r_t) / (1 - r_t)) self.alphas = np.append(self.alphas, self.alpha_t) # Update self.D_t = np.multiply( self.D_t, list(map(exp, -self.alpha_t * np.multiply(self.y, pred_y)))) self.D_t /= np.sum(self.D_t) # self.D = np.append(self.D, self.D_t) ret_index = self.predict(self.test_X, i + 1) # for i in range(len(X_test)): # print(ret_index[i]) # print(y_test[i]) scores = one_error(ret_index, self.test_y) y_train = [] at_n = 3 for j in range(len(ret_index)): tmp = [0] * self.k for ll in ret_index[j]: if ret_index[j].index(ll) < self.k - at_n: continue tmp[self.class_list.index(ll)] = 1 ret_index[j] = tmp tmp = [0] * self.k for ll in self.test_y[j]: tmp[self.class_list.index(ll)] = 1 y_train.append(tmp) precision, recall, error = evaluate(np.array(ret_index), np.array(y_train)) print(i, precision, recall, error, scores)
def validate(beam_searcher, dataset, logger=None): # generating captions all_candidates = [] for i in xrange(dataset.n_image): data = dataset.iterate_batch() # data: id, img, scene... sent = beam_searcher.generate(data[1:]) cap = u' '.join([dataset.vocab[word] for word in sent]) # print data[0], cap all_candidates.append({u'image_id': data[0], 'caption': cap}) res_file = '{:d}_tmp.json'.format(np.random.randint(0, 10000, 1)[0]) json.dump(all_candidates, open(res_file, 'w')) gt_file = osp.join(dataset.data_dir, 'captions_'+dataset.data_split+'.json') scores = evaluate(gt_file, res_file, logger) os.system('rm -rf %s' % res_file) return scores
def validate(beam_searcher, dataset, logger=None, res_file=None): if logger is None: logger = Logger(None) # generating captions all_candidates = [] for i in xrange(dataset.n_image): data = dataset.iterate_batch() # data: id, img, scene... sent = beam_searcher.generate(data[1:]) cap = ' '.join([dataset.vocab[word] for word in sent]) print '[{}], id={}, \t\t {}'.format(i, data[0], cap) all_candidates.append({'image_id': data[0], 'caption': cap}) if res_file is None: res_file = 'tmp.json' json.dump(all_candidates, open(res_file, 'w')) gt_file = osp.join(dataset.data_dir, 'captions_'+dataset.data_split+'.json') scores = evaluate(gt_file, res_file, logger) if res_file == 'tmp.json': os.system('rm -rf %s' % res_file) return scores
def main(args): print('\nPreparing {} data'.format(args.dataset)) if args.dataset == 'mnist': (X_train, y_train), (X_test, y_test), (X_valid, y_valid) = load_mnist() elif args.dataset == 'cifar10': (X_train, y_train), (X_test, y_test), (X_valid, y_valid) = load_cifar10() elif args.dataset == 'cifar100': (X_train, y_train), (X_test, y_test), (X_valid, y_valid) = load_cifar100() print('\nConstruction graph') if args.model == 'cnn_1': env = cnn_1(args) elif args.model == 'cnn_2': env = cnn_2(args) elif args.model == 'vgg16': env = vgg16(args) elif args.model == 'vgg19': env = vgg19(args) print('\nInitializing graph') sess = tf.InteractiveSession() sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) print('\nLoading saved model') name = '{0}_{1}'.format(args.model, args.dataset) env.saver.restore(sess, 'models/{0}/{1}'.format(name, name)) print('\nEvaluating on clean data') evaluate(sess, env, X_test, y_test) print('\nExcluding misclassification samples') # mnist 1000 samples -> 0:1010 # cifar10 1000 samples -> 0: (X_test, y_test) = exclude_miss(sess, env, X_test, y_test, 0, 12) evaluate(sess, env, X_test, y_test) print('\nGenerating adversarial data') X_adv = make_adv(args, sess, env, X_test, y_test) print('\nEvaluating on adversarial data') evaluate(sess, env, X_adv, y_test) print('\nResults')
img_raw = cv2.imread(IMG_PATH, 1) img_noisy = Add_Guassian_Noise(img_raw,sigma) img_H,img_W = BM3D(img_noisy,color_mode, kHard = k_H , NHard = N_H,nHard = n_H , pHard = p_H,threshold_match_H = threshold_match_H,sigma_H = sigma, control_p_H = control_p_H , Hard_threshold = Hard_threshold , Is_weight_usesd_H = Is_weight_usesd, kEst = k_W,nEst = n_W,NEst = N_W , pEst = p_W,threshold_match_W = threshold_match_W,sigma_W = sigma, control_p_W = control_p_W , Is_weight_usesd_W = Is_weight_usesd , mode_H = mode_H , mode_W = mode_W , Is_kaiser = Is_kaiser) if color_mode > 0: img_raw = cv2.cvtColor(img_raw, cv2.COLOR_RGB2YUV) img_W = (np.clip(img_W, 0, 255)).astype(np.uint8) Psnr_W_Y = evaluate(img_raw[:, :, 0], img_W[:, :, 0]) img_W = cv2.cvtColor(img_W, cv2.COLOR_YUV2RGB) if Is_weight_usesd > 0: img_W_name = '.\\output\\usesd\\' + IMG_PATH[:-4] + '_' + \ str(sigma) + '_W_Y' + '%.4f' % Psnr_W_Y + '_useSD.jpg' cv2.imwrite(img_W_name, img_W) else: img_W_name = '.\\output\\unusesd\\' + IMG_PATH[:-4] + '_' + \ str(sigma) + '_W_Y' + '%.4f' % Psnr_W_Y + '.jpg' cv2.imwrite(img_W_name, img_W) else: img_raw = cv2.cvtColor(img_raw, cv2.COLOR_RGB2GRAY) img_H = (np.clip(img_H, 0, 255)).astype(np.uint8)
def train(self, max_depth=3): for i in range(self.T): pred_y = np.array([]) # k*m # Train weak learner using distribution D_t for j in range(self.k): self.h_t = self.model(max_depth=max_depth, presort=True) self.h_t.fit(self.X, self.y[j * self.m:(j + 1) * self.m], sample_weight=np.sum(self.D_t, axis=1)[:, j]) # Get weak hypothesis h_t self.h.append(self.h_t) # Choose alpha_t pred_y = np.append(pred_y, self.h_t.predict(self.X)) tmp_sum = 0 for (x_i, l0, l1) in self.pairs: tmp_sum += self.D_t[x_i][l0][l1] * (pred_y[l1 * self.m + x_i] - pred_y[l0 * self.m + x_i]) # for i in range(self.m): # for l0 in range(self.k): # for l1 in range(self.k): # if abs(self.D_t[i][l0][l1]) < 0.0000001: # continue # tmp_sum += self.D_t[i][l0][l1]*(pred_y[i*self.k+l1]-pred_y[i*self.k+l0]) r_t = tmp_sum * 0.5 if abs(r_t - 1) < 0.00000001: self.alpha_t = 0.5 * log( (1 + r_t + 0.000001) / (1 - r_t + 0.000001)) else: self.alpha_t = 0.5 * log((1 + r_t) / (1 - r_t)) self.alphas = np.append(self.alphas, self.alpha_t) # Update for (x_i, l0, l1) in self.pairs: self.D_t[x_i][l0][l1] = self.D_t[x_i][l0][l1] * exp( 0.5 * self.alpha_t * (pred_y[l0 * self.m + x_i] - pred_y[l1 * self.m + x_i])) self.D_t /= np.sum(self.D_t) # self.D = np.append(self.D, self.D_t) ret_index, pred = self.predict(self.test_X, i + 1) # for i in range(len(X_test)): # print(ret_index[i]) # print(y_test[i]) scores = one_error(ret_index, self.test_y) y_train = [] at_n = 3 for j in range(len(ret_index)): tmp = [0] * self.k for ll in ret_index[j]: if ret_index[j].index(ll) < self.k - at_n: continue tmp[self.class_list.index(ll)] = 1 ret_index[j] = tmp tmp = [0] * self.k for ll in self.test_y[j]: tmp[self.class_list.index(ll)] = 1 y_train.append(tmp) precision, recall, error = evaluate(np.array(ret_index), np.array(y_train)) print(i, precision, recall, error, scores)
def render(encoder_input, encoder_label, dim_indices, save_path, vis_type, reward_type, with_label, label_num): """Plots""" batch_size = encoder_input.shape[0] data_num = encoder_input.shape[1] dim_num = encoder_input.shape[2] # batch_size x dim_num idx = dim_indices.unsqueeze(1).repeat(1, data_num, 1) # batch_size x data_num x dim_num sample_input = torch.gather(encoder_input.data, 2, idx) sample_label = torch.gather(encoder_label.data, 2, idx) for batch_index in range(batch_size): dpi = 400 # if batch_index >= 10: # if batch_index not in [6, 56, 62, 77] or batch_index > 10: if batch_index not in [6]: continue data = sample_input[batch_index:batch_index + 1, :, :] label = sample_label[batch_index:batch_index + 1, :, :] order = dim_indices[batch_index] origin_data = encoder_input.data[batch_index:batch_index + 1, :, :] origin_label = encoder_label.data[batch_index:batch_index + 1, :, :] origin_order = [i for i in range(dim_num)] if True: scores = tools.evaluate(data, label, order, vis_type, reward_type, with_label, label_num=label_num) origin_scores = tools.evaluate(origin_data, origin_label, origin_order, vis_type, reward_type, with_label, label_num=label_num) data = data.cpu().numpy()[0] label = label.cpu().numpy()[0, :, 0] order = order.cpu().numpy() origin_data = origin_data.cpu().numpy()[0] origin_label = origin_label.cpu().numpy()[0, :, 0] with_category = False if vis_type == 'star' or vis_type == 'radviz': data = np.column_stack((label, data)) origin_data = np.column_stack((origin_label, origin_data)) with_category = True scores = abs(scores) origin_scores = abs(origin_scores) if vis_type == 'star': # TODO draw image tools.draw( data, order, vis_type, reward_type, save_title="%.3f" % (scores), # save_title="CLASS DIST: %.3f\nSIL: %.3f" % (mer, sil), # save_name=save_path[:-8] + '-%d' % (batch_index), with_category=with_category, save_name=save_path[:-8] + '-%d_%.3f' % (batch_index, scores), with_category=with_category, dpi=dpi, label_num=label_num) tools.draw( origin_data, origin_order, vis_type, reward_type, save_title="%.3f" % (origin_scores), # save_title="CLASS DIST: %.3f\nSIL: %.3f" % (mer_o, sil_o), # save_name=save_path[:-8] + '-%d-o' % (batch_index), with_category=with_category, save_name=save_path[:-8] + '-%d-%.3f-o' % (batch_index, origin_scores), with_category=with_category, dpi=dpi, label_num=label_num) # print(origin_scores) # print(scores) # np.savetxt(save_path[:-8] + '-%.3f_%.3f.txt' % (origin_scores, scores), data[0] ) else: # TODO draw image tools.draw( data, order, vis_type, reward_type, # save_title="Score: %.3f\n" % (scores), save_title='', save_name=save_path[:-8] + '-%d_%.3f' % (batch_index, scores), with_category=with_category, dpi=dpi, label_num=label_num) tools.draw( origin_data, origin_order, vis_type, reward_type, # save_title="Score: %.3f\n" % (origin_scores), save_title='', save_name=save_path[:-8] + '-%d-o-_%.3f' % (batch_index, origin_scores), with_category=with_category, dpi=dpi, label_num=label_num) # print(origin_scores) # print(scores) # np.savetxt(save_path[:-8] + '-%.3f_%.3f.txt' % (origin_scores, scores), data[0] ) # if vis_type == 'star': # sim, mer, sil = tools.evaluate(sample_input, sample_label, order, vis_type, 'sc_all', with_label, label_num=label_num) # sim_o, mer_o, sil_o = tools.evaluate(encoder_input, encoder_label, origin_order, vis_type, 'sc_all', with_label, label_num=label_num) # sim = abs(sim) # mer = abs(mer) # sil = abs(sil) # sim_o = abs(sim_o) # mer_o = abs(mer_o) # sil_o = abs(sil_o) # if reward_type == 'sc_sim': # scores = sim # origin_scores = sim_o # elif reward_type == 'sc_mer': # scores = mer # origin_scores = mer_o # elif reward_type == 'sc_sil': # scores = sil # origin_scores = sil_o # else: # print('=======> Error in render') # else: if True: order = None origin_order = None scores = tools.evaluate(sample_input, sample_label, order, vis_type, reward_type, with_label, label_num=label_num) origin_scores = tools.evaluate(encoder_input, encoder_label, origin_order, vis_type, reward_type, with_label, label_num=label_num) # if vis_type == 'star': # np.savetxt(save_path[:-8] + '-sim.txt', sim.cpu().numpy()) # np.savetxt(save_path[:-8] + '-mer.txt', mer.cpu().numpy()) # np.savetxt(save_path[:-8] + '-sil.txt', sil.cpu().numpy()) # np.savetxt(save_path[:-8] + '-sim_o.txt', sim_o.cpu().numpy()) # np.savetxt(save_path[:-8] + '-mer_o.txt', mer_o.cpu().numpy()) # np.savetxt(save_path[:-8] + '-sil_o.txt', sil_o.cpu().numpy()) ids = dim_indices.cpu().numpy().astype('int') np.savetxt(save_path[:-8] + '-score.txt', scores.cpu().numpy()) np.savetxt(save_path[:-8] + '-score-o.txt', origin_scores.cpu().numpy()) np.savetxt(save_path[:-8] + '-ids.txt', ids)
def run(config): pl.seed_everything(config.seed) # overwrite path OmegaConf.set_struct(config, True) with open_dict(config): config.trainer.model.params.backbone.params.pretrained = False # build logger logger = build_logger(config) # logging for wandb or mlflow if hasattr(logger, "log_hyperparams"): for k, v in config.trainer.items(): if not k in ("metrics", "inference"): logger.log_hyperparams(params=v) logger.log_hyperparams(params=config.dataset) logger.log_hyperparams(params=config.augmentation) # build model model = build_model(config) # build hooks hooks = build_hooks(config) # build lightning module lightning_module = build_lightning_module( config, model=model, optimizer=None, scheduler=None, hooks=hooks, dataloaders=None, strong_transform=None, ) # load best checkpoint dir_path = config.trainer.callbacks.ModelCheckpoint.dirpath if isinstance(OmegaConf.to_container(config.dataset.dataset), list): idx_fold = config.dataset.dataset[0].params.idx_fold else: idx_fold = config.dataset.dataset.params.idx_fold filename = f"fold_{idx_fold}_best.ckpt" best_model_path = os.path.join(dir_path, filename) state_dict = torch.load(best_model_path)["state_dict"] # if using dp, it is necessary to fix state dict keys if ( hasattr(config.trainer.trainer, "sync_batchnorm") and config.trainer.trainer.sync_batchnorm ): state_dict = kvt.utils.fix_dp_model_state_dict(state_dict) lightning_module.model.load_state_dict(state_dict) # inference columns = [f"pred_{i:03}" for i in range(config.trainer.model.params.num_classes)] outputs = [] for i, (dataloaders, row_ids) in enumerate(build_test_dataloaders(config)): lightning_module.dataloaders = dataloaders _, output = evaluate( lightning_module, hooks, config, mode="test", return_predictions=True, tta=config.augmentation.tta, ) output = pd.DataFrame(output[0], columns=columns) output["row_id"] = row_ids outputs.append(output) outputs = pd.concat(outputs).reset_index(drop=True) # save predictions dataframe path = os.path.join( config.trainer.inference.dirpath, config.trainer.inference.filename, ) outputs.to_pickle(path) # merge labels labels = pd.read_csv(f"{config.input_dir}/train_soundscape_labels.csv") labels["birds"] = labels["birds"].apply(lambda x: x.split()) df = labels.merge(outputs) # target target = ( df["birds"] .apply(lambda x: preprocess_target(x, config.competition.target_unique_values)) .values ) # evaluate result = {} pred = df[columns].values[:, :NUM_CLASSES] > 0.5 for func in [f1_score, precision_score, recall_score]: result[f"train_soundscapes_{func.__name__}_50"] = func( target, pred, average="samples", zero_division=1 ) pred = df[columns].values[:, :NUM_CLASSES] > 0.25 for func in [f1_score, precision_score, recall_score]: result[f"train_soundscapes_{func.__name__}_25"] = func( target, pred, average="samples", zero_division=1 ) print("Result:") print(result) # log if logger is not None: logger.log_metrics(result)
bs = BeamSearch(models, beam_size=3, num_cadidates=500, max_length=20) scores = validate(bs, valid_set) if task == 'rass': from model.rass import Model model_list = ['mscoco-rass-nh512-nw512-na512-mb64-V8843/rass.h5.merge'] models = [Model(model_file=osp.join(SAVE_ROOT, m)) for m in model_list] valid_set = Reader(batch_size=1, data_split='test', vocab_freq='freq5', stage='val', data_dir=data_dir, feature_file='features_30res.h5', topic_type='pred', topic_file='lda_topics.h5', caption_switch='off', head=0, tail=1000) bs = BeamSearch(models, beam_size=3, num_cadidates=500, max_length=20) scores = validate(bs, valid_set) if task == 'evaluate': gt_file = osp.join(data_dir, 'captions_test.json') res_file = 'tmp.json' scores = evaluate(gt_file, res_file, None) for s in scores: print '{:.1f}'.format(100. * s)
net_datas[batch_index, data_index] = datas[batch_index, data_index][ids[batch_index]] net_labels[batch_index, data_index] = labels[batch_index, data_index][ids[batch_index]] net_datas = torch.from_numpy(net_datas) net_labels = torch.from_numpy(net_labels) datas = datas.cuda() labels = labels.cuda() net_datas = net_datas.cuda() net_labels = net_labels.cuda() init_scores = tools.evaluate(datas[:draw_num], labels[:draw_num], None, vis_type, 'sc_sil', False) net_scores = tools.evaluate(net_datas[:draw_num], net_labels[:draw_num], None, vis_type, 'sc_sil', False) datas = datas.cpu().numpy() labels = labels.cpu().numpy()[:, :, 0] net_datas = net_datas.cpu().numpy() net_labels = net_labels.cpu().numpy()[:, :, 0] # for batch_index in range(num_samples): save_dir = os.path.join( './img', vis_type, '%d' % dim_num, reward_type + '-' + data_type + '-' + str(dim_num) + 'd-' + str(data_num) + 'n-' + str(label_num) + 'c-note-' + note) print(save_dir)
def run(config): pl.seed_everything(config.seed) # overwrite path OmegaConf.set_struct(config, True) with open_dict(config): config.trainer.model.params.backbone.params.pretrained = False # build model model = build_model(config) # build hooks hooks = build_hooks(config) # build lightning module lightning_module = build_lightning_module( config, model=model, optimizer=None, scheduler=None, hooks=hooks, dataloaders=None, strong_transform=None, ) # load best checkpoint dir_path = config.trainer.callbacks.ModelCheckpoint.dirpath if isinstance(OmegaConf.to_container(config.dataset.dataset), list): idx_fold = config.dataset.dataset[0].params.idx_fold else: idx_fold = config.dataset.dataset.params.idx_fold filename = f"fold_{idx_fold}_best.ckpt" best_model_path = os.path.join(dir_path, filename) state_dict = torch.load(best_model_path)["state_dict"] # if using dp, it is necessary to fix state dict keys if (hasattr(config.trainer.trainer, "sync_batchnorm") and config.trainer.trainer.sync_batchnorm): state_dict = kvt.utils.fix_dp_model_state_dict(state_dict) lightning_module.model.load_state_dict(state_dict) # inference columns = [ f"pred_{i:03}" for i in range(config.trainer.model.params.num_classes) ] for i, (dataloaders, row_ids) in enumerate(build_test_dataloaders(config)): lightning_module.dataloaders = dataloaders _, output = evaluate( lightning_module, hooks, config, mode="test", return_predictions=True, ) output = pd.DataFrame(output[0], columns=columns) output["row_id"] = row_ids # save predictions dataframe path = os.path.join( config.trainer.inference.dirpath, f"{i:03d}_" + config.trainer.inference.filename, ) output.to_pickle(path)
model_list = ['mscoco-ra-nh512-nw512-na512-mb64-V8843/ra.h5.merge'] models = [Model(model_file=osp.join(SAVE_ROOT, m)) for m in model_list] valid_set = Reader(batch_size=1, data_split='test', vocab_freq='freq5', stage='test', data_dir=data_dir, feature_file='features_30res.h5', caption_switch='off', topic_switch='off', head=0, tail=1000) bs = BeamSearch(models, beam_size=3, num_cadidates=500, max_length=20) scores = validate(bs, valid_set) if task == 'rass': from model.rass import Model model_list = ['mscoco-rass-nh512-nw512-na512-mb64-V8843/rass.h5.merge'] models = [Model(model_file=osp.join(SAVE_ROOT, m)) for m in model_list] valid_set = Reader(batch_size=1, data_split='test', vocab_freq='freq5', stage='val', data_dir=data_dir, feature_file='features_30res.h5', topic_type='pred', topic_file='lda_topics.h5', caption_switch='off', head=0, tail=1000) bs = BeamSearch(models, beam_size=3, num_cadidates=500, max_length=20) scores = validate(bs, valid_set) if task == 'evaluate': gt_file = osp.join(data_dir, 'captions_test.json') res_file = 'tmp.json' scores = evaluate(gt_file, res_file, None) for s in scores: print '{:.1f}'.format(100.*s)
def train(epochs=120, init_lr=0.001, weight_decay=1e-8, model_num=1, batch_size=64, train_dir=train_dir, test_dir=test_dir, log_dir=log_dir, ): #divide data #data_divide(data_dir=data_dir, train_dir=train_dir, test_dir=test_dir) #load data print("data loading......\n") transform = enhance_transform() transform_std = transform_standard() trainset = DataClassify(train_dir, transforms=transform) testset = DataClassify(test_dir, transforms=transform_std) train_length = len(trainset) test_length = len(testset) data_loader_train = t.utils.data.DataLoader(trainset, batch_size, shuffle=True) data_loader_test = t.utils.data.DataLoader(testset, batch_size, shuffle=False) print("loading complete\n") if model_num==0: exit(0) elif model_num==1: net = resnet18() elif model_num==2: net = resnet34() elif model_num==3: net = resnet50() elif model_num==4: net = resnet101() elif model_num==5: net = resnet152() cost = t.nn.CrossEntropyLoss() train_loss_list = [] train_accurate_list = [] test_loss_list = [] test_accurate_list = [] for epoch in range(epochs): print("epoch " + str(epoch+1) + " start training...\n") net.train() learning_rate = dloss(train_loss_list, init_lr, lr_coefficient, init_lr) optimizer = t.optim.Adam(list(net.parameters()), lr=learning_rate, weight_decay=weight_decay) run_loss, corr = train_once(data_loader_train, net, optimizer, cost) train_loss_list.append(run_loss/train_length) train_accurate_list.append(corr/train_length) print('epoch %d, training loss %.6f, training accuracy %.4f ------\n' %(epoch+1, run_loss/train_length, corr/train_length)) print("epoch " + str(epoch+1) + " finish training\n") print("-----------------------------------------------\n") print("epoch " + str(epoch+1) + " start testing...\n") net.eval() test_corr = evaluate(net, data_loader_test) test_accurate_list.append(test_corr/test_length) print('epoch %d, testing accuracy %.4f ------\n' %(epoch+1, test_corr/test_length)) print("epoch " + str(epoch+1) + " finish testing\n") print("-----------------------------------------------\n") curve_draw(train_loss_list, train_accurate_list, test_accurate_list, log_dir)
import argparse import yaml import tools parser = argparse.ArgumentParser() parser.add_argument('-visualize', action='store_true') parser.add_argument('-predict', action='store_true') parser.add_argument('-slice', action='store_true') parser.add_argument('-evaluate', action='store_true') args = parser.parse_args() with open('./configs.yaml', 'r') as stream: try: configs = yaml.safe_load(stream) except yaml.YAMLError as exc: print(exc) if args.visualize: tools.visualize(configs) elif args.predict: tools.predict(configs) elif args.slice: tools.slice_vids(configs) elif args.evaluate: tools.evaluate(configs) else: raise ValueError( 'Did not set flag: -visualize, -predict, -slice, -evaluate')