def __init__(self, root, frames_per_clip, fps=4, video_width=171, video_height=128, crop_size=112, transform=None): super(UCF101, self).__init__(root) extensions = ('avi', ) classes = list(sorted(os.listdir(root))) class_to_idx = {classes[i]: i for i in range(len(classes))} self.samples = make_dataset(self.root, class_to_idx, extensions, is_valid_file=None) video_list = [x[0] for x in self.samples] print('Number of videos: {:d}'.format(len(self.samples))) clip_root = root.split('/')[-1].lower() self.video_clips = VideoClips( clip_root, video_list, frames_per_clip, fps=fps, video_width=video_width, video_height=video_height, crop_size=crop_size, ) self.transform = transform
def get_ucf_class_filenames(ucf_folder_path, category='Rowing'): list_of_ucf101_categories = os.listdir(ucf_folder_path) if category in list_of_ucf101_categories: ucf_category_filenames = make_dataset(os.path.join( ucf_folder_path, category), ext='avi') return ucf_category_filenames
def get_ucf_all_but_class_filenames(ucf_folder_path, category='Rowing'): list_of_ucf101_categories = os.listdir(ucf_folder_path) all_but_category_ucf_classification_names = [] for ucf_category in list_of_ucf101_categories: if ucf_category != category: all_but_category_ucf_classification_names.extend( make_dataset(os.path.join(ucf_folder_path, ucf_category), ext='avi')) return all_but_category_ucf_classification_names
def __init__(self, type0_pathname=None, type1_pathname=None, input_transform=None): # load file names: if type0_pathname is not None: self.type0_examples = make_dataset(type0_pathname) else: self.type0_examples = [] # if type1_pathname is not None: self.type1_examples = make_dataset(type1_pathname) else: self.type1_examples = [] # self.image_filenames = self.type0_examples + self.type1_examples self.labels = [0] * len(self.type0_examples) + [1] * len( self.type1_examples) # pos/neg inds: self.inds_type0_examples = list( np.where(np.array(self.labels) == 0)[0]) self.inds_type1_examples = list( np.where(np.array(self.labels) == 1)[0]) # pos/neg ratio: if type0_pathname is not None and type1_pathname is not None: self.class_ratio = [ len(self.type0_examples) / len(self.image_filenames), len(self.type1_examples) / len(self.image_filenames) ] else: self.class_ratio = None # num frames: self.num_of_frames = 8 # 16 # basic transform: self.input_transform = transforms.Compose([ transforms.Resize(size=(116, 116)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ])
def main(): # seed np.random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) torch.backends.cudnn.deterministic = True # dataset dataset = make_dataset() # statistical_ml(dataset) deep_learning(dataset)
def main(): # parsing arguments parser = argparse.ArgumentParser(description='antispoofing training') parser.add_argument('--draw_graph', default=False, type=bool, required=False, help='whether or not to draw graphics') parser.add_argument('--GPU', default=0, type=int, required=False, help='specify which GPU to use') parser.add_argument('--config', type=str, default=None, required=True, help='path to configuration file') parser.add_argument('--device', type=str, default='cuda', help='if you want to eval model on cpu, pass "cpu" param') args = parser.parse_args() # reading config and manage device path_to_config = args.config config = read_py_config(path_to_config) device = args.device + f':{args.GPU}' if args.device == 'cuda' else 'cpu' # building model model = build_model(config, device, strict=True, mode='eval') model.to(device) if config.data_parallel.use_parallel: model = nn.DataParallel(model, **config.data_parallel.parallel_params) # load snapshot path_to_experiment = os.path.join(config.checkpoint.experiment_path, config.checkpoint.snapshot_name) epoch_of_checkpoint = load_checkpoint(path_to_experiment, model, map_location=device, optimizer=None) # preprocessing, making dataset and loader normalize = A.Normalize(**config.img_norm_cfg) test_transform = A.Compose([ A.Resize(**config.resize, interpolation=cv.INTER_CUBIC), normalize ]) test_transform = Transform(val=test_transform) test_dataset = make_dataset(config, val_transform=test_transform, mode='eval') test_loader = DataLoader(dataset=test_dataset, batch_size=100, shuffle=True, num_workers=2) # computing metrics auc_, eer, accur, apcer, bpcer, acer, fpr, tpr = evaluate(model, test_loader, config, device, compute_accuracy=True) print((f'eer = {round(eer*100,2)}\n' + f'accuracy on test data = {round(np.mean(accur),3)}\n' + f'auc = {round(auc_,3)}\n' + f'apcer = {round(apcer*100,2)}\n' + f'bpcer = {round(bpcer*100,2)}\n' + f'acer = {round(acer*100,2)}\n' + f'checkpoint made on {epoch_of_checkpoint} epoch')) # draw graphics if needed if args.draw_graph: fnr = 1 - tpr plot_roc_curve(fpr, tpr, config) det_curve(fpr, fnr, eer, config)
def initialize(self, opt): self.opt = opt self.root = opt.dataroot self.dir_A = os.path.join(opt.dataroot, opt.phase + 'A') self.dir_B = os.path.join(opt.dataroot, opt.phase + 'B') self.A_paths = make_dataset(self.dir_A) self.B_paths = make_dataset(self.dir_B) self.A_paths = sorted(self.A_paths) self.B_paths = sorted(self.B_paths) self.A_size = len(self.A_paths) self.B_size = len(self.B_paths) transform_list = [] transform_list += [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))] # transform_list = [transforms.ToTensor()] self.transform = transforms.Compose(transform_list)
def correction_for_api(self, sentence): """チェッカー用の訂正結果を返す""" sentence = clean_text(sentence) # 全角→半角,数字→# org_words, parts = self.mecab.tagger(sentence) # 形態素解析 if self.to_kana: words = convert_to_kana(' '.join(org_words)).split(' ') # カナ変換 if len(org_words) != len(words): return "error" else: words = org_words[::] fix_flags = [0] * len(words) score_list = [{}] * len(words) target_idx = self._get_target_positions(words, parts) # 訂正対象の位置リスト target_idx = target_idx[::-1] # 後ろから訂正 for idx in target_idx: marked_sentence = '{} <{}> {}'.format( ' '.join(words[:idx]), words[idx], ' '.join(words[idx + 1:])) # 格助詞を<>で囲む test_data, _ = make_dataset([marked_sentence], self.w2id, self.class2id, n_encoder=self.n_encoder, to_kana=self.to_kana, is_train=False) predict, scores = self._predict(test_data) if words[idx] != predict: words[idx] = predict # 予測に置換 org_words[idx] = predict fix_flags[idx] = 1 # 置換フラグ else: fix_flags[idx] = 2 # 無修正フラグ score_dic = dict(zip(self.class2id.keys(), scores)) if ' ' in score_dic.keys(): del score_dic[' '] # 謎の空白クラスを削除 sorted_score_dic = dict( sorted(score_dic.items(), key=lambda x: x[1], reverse=True)) d = { 'keys': list(sorted_score_dic.keys()), 'scores': [f'{score*100:.1f}' for score in sorted_score_dic.values()] } score_list[idx] = d return [[ word, fix_flag, score ] for word, fix_flag, score in zip(org_words, fix_flags, score_list)]
def bokeh(): quandl.ApiConfig.api_key = "xMwhitoyQ___b7Mb9pAt" data_dict ={} stock_list= ['ATVI','AAPL','GOOG','CSCO'] for i in stock_list: data_dict[i] = quandl.get("WIKI/%s" %i) useful_cols = ['Open','High','Low','Close'] for i in data_dict.keys(): data_dict[i] = data_dict[i][useful_cols].reset_index() current_stock = 'AAPL' select_stock = Select(title="stock selection", value=current_stock, options=stock_list) source = make_dataset(data_dict,current_stock) plot = make_plot(source) select_stock.on_change('value', update_plot) controls = column(select_stock) full = row(plot,controls) curdoc().add_root(full) curdoc().title = 'Stock demo' # grab the static resources js_resources = INLINE.render_js() css_resources = INLINE.render_css() # render template script, div = components(full) html = render_template( 'index.html', plot_script=script, plot_div=div, js_resources=js_resources, css_resources=css_resources, ) return encode_utf8(html)
def correction(self, sentence): """訂正文を返す""" org_words, words, parts = self._preprocess(sentence) if org_words is None: return "error" target_idx = self._get_target_positions(words, parts) # 訂正対象の位置リスト target_idx = target_idx[::-1] # 後ろから訂正 for idx in target_idx: marked_sentence = '{} <{}> {}'.format( ' '.join(words[:idx]), words[idx], ' '.join(words[idx + 1:])) # 格助詞を<>で囲む test_data, _ = make_dataset([marked_sentence], self.w2id, self.class2id, n_encoder=self.n_encoder, to_kana=self.to_kana, is_train=False) predict, _ = self._predict(test_data) words[idx] = predict # 予測に置換 org_words[idx] = predict corrected = ''.join(org_words) return corrected
def train(config, device='cuda:0', save_chkpt=True): ''' procedure launching all main functions of training, validation and testing pipelines''' # for pipeline testing purposes save_chkpt = False if config.test_steps else True # preprocessing data normalize = A.Normalize(**config.img_norm_cfg) train_transform_real = A.Compose([ A.Resize(**config.resize, interpolation=cv.INTER_CUBIC), A.HorizontalFlip(p=0.5), A.augmentations.transforms.ISONoise(color_shift=(0.15, 0.35), intensity=(0.2, 0.5), p=0.2), A.augmentations.transforms.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, brightness_by_max=True, always_apply=False, p=0.3), A.augmentations.transforms.MotionBlur(blur_limit=5, p=0.2), normalize ]) train_transform_spoof = A.Compose([ A.Resize(**config.resize, interpolation=cv.INTER_CUBIC), A.HorizontalFlip(p=0.5), A.augmentations.transforms.ISONoise(color_shift=(0.15, 0.35), intensity=(0.2, 0.5), p=0.2), A.augmentations.transforms.RandomBrightnessContrast( brightness_limit=0.2, contrast_limit=0.2, brightness_by_max=True, always_apply=False, p=0.3), A.augmentations.transforms.MotionBlur(blur_limit=5, p=0.2), normalize ]) val_transform = A.Compose( [A.Resize(**config.resize, interpolation=cv.INTER_CUBIC), normalize]) # load data sampler = config.data.sampler if sampler: num_instances, weights = make_weights(config) sampler = torch.utils.data.WeightedRandomSampler(weights, num_instances, replacement=True) train_transform = Transform(train_spoof=train_transform_spoof, train_real=train_transform_real, val=None) val_transform = Transform(train_spoof=None, train_real=None, val=val_transform) train_dataset, val_dataset, test_dataset = make_dataset( config, train_transform, val_transform) train_loader, val_loader, test_loader = make_loader(train_dataset, val_dataset, test_dataset, config, sampler=sampler) # build model and put it to cuda and if it needed then wrap model to data parallel model = build_model(config, device=device, strict=False, mode='train') model.to(device) if config.data_parallel.use_parallel: model = torch.nn.DataParallel(model, **config.data_parallel.parallel_params) # build a criterion softmax = build_criterion(config, device, task='main').to(device) cross_entropy = build_criterion(config, device, task='rest').to(device) bce = nn.BCELoss().to(device) criterion = (softmax, cross_entropy, bce) if config.multi_task_learning else softmax # build optimizer and scheduler for it optimizer = torch.optim.SGD(model.parameters(), **config.optimizer) scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, **config.scheduler) # create Trainer object and get experiment information trainer = Trainer(model, criterion, optimizer, device, config, train_loader, val_loader, test_loader) trainer.get_exp_info() # learning epochs for epoch in range(config.epochs.start_epoch, config.epochs.max_epoch): if epoch != config.epochs.start_epoch: scheduler.step() # train model for one epoch train_loss, train_accuracy = trainer.train(epoch) print( f'epoch: {epoch} train loss: {train_loss} train accuracy: {train_accuracy}' ) # validate your model accuracy = trainer.validate() # eval metrics such as AUC, APCER, BPCER, ACER on val and test dataset according to rule trainer.eval(epoch, accuracy, save_chkpt=save_chkpt) # for testing purposes if config.test_steps: exit() # evaluate in the end of training if config.evaluation: file_name = 'tests.txt' trainer.test(file_name=file_name)
def __init__(self, fold_path): super(FolderLoader, self).__init__() self.fold_path = fold_path self.img_paths = utils.make_dataset(self.fold_path) self.img_names = [os.path.basename(x) for x in self.img_paths]
build_model_lambda = partial(build_model, image_size=IMAGE_SIZE, n_classes=N_CLASSES, name=BACKBONE_NAME) paths_and_labels = read_paths_and_labels(RAW_DATA_PATH, DOMAINS, 3) target_paths = paths_and_labels['target']['train']['paths'] + paths_and_labels[ 'target']['test']['paths'] target_labels = paths_and_labels['target']['train'][ 'labels'] + paths_and_labels['target']['test']['labels'] train_dataset = iter( make_dataset(source_paths=paths_and_labels['source']['train']['paths'], source_labels=paths_and_labels['source']['train']['labels'], source_config=CONFIG, target_paths=target_paths, target_labels=target_labels, target_config=CONFIG, batch_size=BATCH_SIZE)) validate_dataset = iter( make_dataset(source_paths=paths_and_labels['source']['test']['paths'], source_labels=paths_and_labels['source']['test']['labels'], source_config=CONFIG, target_paths=target_paths, target_labels=target_labels, target_config=CONFIG, batch_size=BATCH_SIZE)) train_step = SourceTrainStep(build_model_lambda=build_model_lambda, domains=DOMAINS, n_frozen_layers=230,
def main(argv): config = Config() config.load_user_config() config.log.info("finish loading user config") train_file = config.args["train_file"] dev_file = config.args["dev_file"] old_glove_file = config.args["glove_file"] new_glove_file = config.args["glove_file"] + ".subset" # TODO(demi): switch "overwrite" to False train_data_raw, dev_data_raw, i2w, w2i, i2c, c2i, new_glove_file, glove_dim, vocab_size, char_vocab_size\ = squad_read_data(config, train_file, dev_file, old_glove_file, new_glove_file, overwrite=True) config.log.info("finish reading squad data in raw formats") config.update_batch([("glove_file", new_glove_file), ("glove_dim", glove_dim), ("vocab_size", vocab_size), ("char_vocab_size", char_vocab_size)]) config.log.warning("reminder: now we only support train/fake mode") assert config.args["mode"] in ["train", "fake"], "mode (%s) not found" % config.args["mode"] train_id_conversion, train_data = make_dataset(config, train_data_raw, w2i, c2i) dev_id_conversion, dev_data = make_dataset(config, dev_data_raw, w2i, c2i) config.log.info("finish making datasets: reformatting raw data") train_data = QnADataset(train_data, config) dev_data = QnADataset(dev_data, config) config.log.info("finish generating datasets") train_loader = torch.utils.data.DataLoader(train_data, batch_size=1, shuffle=True, **config.kwargs) dev_loader = torch.utils.data.DataLoader(dev_data, batch_size=1, **config.kwargs) config.log.info("finish generating data loader") model = BiDAF(config, i2w) config.log.info("finish creating model") if config.args["use_cuda"]: model.cuda() # log config and model config.log.info(config.format_string()) config.log.info("model:{}".format(model)) if config.args['optimizer'] == "Adam": optimizer = optim.Adam(model.get_train_parameters(), lr=config.args['lr'], weight_decay=config.args['weight_decay']) if config.args['optimizer'] == "Adamax": optimizer = optim.Adamax(model.get_train_parameters(), lr=config.args['lr'], weight_decay=config.args['weight_decay']) if config.args['optimizer'] == "SGD": optimizer = torch.optim.SGD(model.get_train_parameters(), lr=config.args['lr'], momentum=0.9, weight_decay=config.args['weight_decay']) if config.args['optimizer'] == "Adadelta": optimizer = torch.optim.Adadelta(model.get_train_parameters(), lr=config.args["lr"]) #if config.args['optimizer'] == "Adagrad": config.log.info("model = %s" % model) config.log.info("config = %s" % config.format_string()) trainer = Trainer(config) evaluator = Evaluator(config) """ save model checkpoint """ def save_checkpoint(epoch): checkpoint = {"model_state_dict": model.state_dict(), "config_args" : config.args} if config.args["optimizer"] != "YF": # YF can't save state dict right now checkpoint["optimizer_state_dict"] = optimizer.state_dict() checkpoint_file = config.args["model_dir"] + config.args["model_name"] + "-EPOCH%d" % epoch torch.save(checkpoint, checkpoint_file) config.log.info("saving checkpoint: {}".format(checkpoint_file)) for epoch in range(1, config.args["max_epoch"] + 1): config.log.info("training: epoch %d" % epoch) # QS(demi): do i need to return model & optimizer? model, optimizer, train_avg_loss, train_answer_dict = trainer.run(model, train_id_conversion[0], train_loader, optimizer, mode="train") model, optimizer, dev_avg_loss, dev_answer_dict = trainer.run(model, dev_id_conversion[0], dev_loader, optimizer, mode="dev") # loss is a float tensor with size 1 config.log.info("[EPOCH %d] LOSS = (train)%.5lf | (dev)%.5lf" % (epoch, train_avg_loss[0], dev_avg_loss[0])) answer_filename = "{}/{}-EPOCH{}".format(config.args["model_dir"], config.args["model_name"], epoch) config.log.info("[EVAUATION] TRAIN EVAL") evaluator.eval("official", train_file, train_answer_dict, "{}/answer.train".format(config.args["model_dir"], answer_filename)) config.log.info("[EVAUATION] DEV EVAL") evaluator.eval("official", dev_file, dev_answer_dict, "{}/answer.dev".format(config.args["model_dir"], answer_filename)) save_checkpoint(epoch)
def train(args): torch.manual_seed(args.seed) train_loader_LR, train_loader_HR, dataset_len = utils.make_dataset(args) transformer = utils.make_model(args) if args.updata: transformer.load_state_dict(torch.load(args.modeldir)) vgg = utils.make_vggmodel(args) optimizer = Adam(transformer.parameters(), lr=args.lr) mse_loss = torch.nn.MSELoss() if args.cuda: mse_loss.cuda() for e in range(args.epochs): log_msg = "pix_weight = "+str(args.pix_weight)+" content_weight = "+str(args.content_weight) print(log_msg) transformer.train() agg_content_loss = 0 agg_pix_loss = 0 count = 0 for batch_id, ((x, x_),(style,y_)) in enumerate(zip(train_loader_LR,train_loader_HR)): n_batch = len(x) count += n_batch optimizer.zero_grad() pix_x_v = Variable(x) pix_s_v = Variable(style,requires_grad=False) pix_loss = 0 content_loss = 0 if args.cuda: x=x.cuda() style=style.cuda() pix_x_v=pix_x_v.cuda() pix_s_v=pix_s_v.cuda() output = transformer(pix_x_v) pix_loss = args.pix_weight * mse_loss(output, pix_s_v) vgg_s = Variable(style.clone(),requires_grad=False) vgg_x = utils.init_vgg_input(output) vgg_s = utils.init_vgg_input(vgg_s) feature_x = vgg(vgg_x) feature_s = vgg(vgg_s) f_s_v = Variable(feature_s[1].data, requires_grad=False) content_loss = args.content_weight * mse_loss(feature_x[1], f_s_v) total_loss = 0 if args.pix_weight>0: total_loss+=pix_loss if args.content_weight>0: total_loss+=content_loss total_loss.backward() optimizer.step() agg_content_loss += content_loss.data[0] agg_pix_loss += pix_loss.data[0] up = 10000 if(batch_id + 1) % args.log_interval == 0: mesg = "{}\tEpoch {}:\t[{}/{}]\tcontent: {:.6f}\tpix: {:.6f}\ttotal: {:.6f}".format(\ time.ctime(), e + 1, count, dataset_len,\ agg_content_loss*up / (batch_id + 1),\ agg_pix_loss *up/ (batch_id + 1),\ (agg_content_loss + agg_pix_loss)*up / (batch_id + 1)) print(mesg) if e%2 == 0: transformer.eval() transformer.cpu() save_model_filename = "epoch_" + str(args.epochs) + "_" + str(time.ctime()).replace(' ', '_') + "_" + str( args.content_weight) + "_SRCNN_" + str(args.srcnn) + ".model" save_model_path = os.path.join(args.save_model_dir, save_model_filename) torch.save(transformer.state_dict(), save_model_path) transformer.eval() transformer.cpu() save_model_filename = "epoch_" + str(args.epochs) + "_" + str(time.ctime()).replace(' ', '_') + "_" + str( args.content_weight) + "_SRCNN_" + str(args.srcnn) + ".model" save_model_path = os.path.join(args.save_model_dir, save_model_filename) torch.save(transformer.state_dict(), save_model_path) print("\nDone, trained model saved at", save_model_path)
# {(model_name,dataset_name),...,...} # 模型文件(.weight)前缀 ds_prefix = 'yolo-voc-800_' # 本次实验的名称(同一个模型可以用来做不同类型的实验) ds_test = 'missfresh-yolo-voc-800-0517' # perform object detection on these dataSets sets = ['test'] # checkpoints of models checkpoints = [12000, 20000, 24000] DataSets = us.make_dataset(prefix=ds_prefix, test_info=ds_test, sets=sets, iterations=checkpoints) aaaa = [] num_class = 26 # get predict results for ds in DataSets: model_name = ds[0] dataset_name = ds[1] test_info = ds[3] if dataset_name == 'test': aaaa.append( find_thres(dataset_name, model_name, test_info, num_class)) #main_plot_bb_on_mix(dataset_name, model_name) #pass else:
def correction(self, text): """訂正文を返す""" org_words, words, parts = self._preprocess(text) target_idx = get_target_positions(words, parts) comp_idx = get_complement_positions(words, parts) # 重複がないことを保証 assert set(target_idx) & set(comp_idx) == set() all_idx = sorted(target_idx + comp_idx) add_count = 0 if self.reverse: all_idx = all_idx[::-1] # 文末から訂正 for idx in all_idx: idx += add_count # 挿入した数だけ右にずらす # 置換 or 削除 if idx in target_idx: left_text, right_text = ' '.join(words[:idx]), ' '.join( words[idx + 1:]) labeled_sentence = f'{left_text} <DEL> {right_text}' # <DEL>に意味はない test_data, _ = make_dataset([labeled_sentence], self.w2id, self.class2id, n_encoder=self.n_encoder, to_kana=self.to_kana, is_train=False) if self.lm: predict, score = self._predict_lm(test_data) else: predict, score = self._predict(test_data) predict = words[ idx] if score < self.threshold else predict # 予測確率が閾値より下なら変えない if predict == 'DEL': # 左にシフト words = words[:idx] + words[idx + 1:] org_words = org_words[:idx] + org_words[idx + 1:] add_count -= 1 target_idx = [idx - 1 for idx in target_idx] else: words[idx] = predict org_words[idx] = predict # 挿入 or キープ else: left_text, right_text = ' '.join(words[:idx]), ' '.join( words[idx:]) labeled_sentence = f'{left_text} <DEL> {right_text}' test_data, _ = make_dataset([labeled_sentence], self.w2id, self.class2id, n_encoder=self.n_encoder, to_kana=self.to_kana, is_train=False) if self.lm: predict, score = self._predict_lm(test_data) # 言語モデルで予測 else: predict, score = self._predict(test_data) predict = 'DEL' if score < self.threshold else predict # 予測確率が閾値より下なら変えない if predict == 'DEL': pass # キープ else: # 挿入 # 右にシフト words = words[:idx] + [predict] + words[idx:] org_words = org_words[:idx] + [predict] + org_words[idx:] add_count += 1 target_idx = [idx + 1 for idx in target_idx] corrected_sentence = ''.join(org_words) corrected_sentence = corrected_sentence.replace('DEL', '') return corrected_sentence
def correction_test(self, err, ans): """訂正して正解率を求める""" # 前処理 err_org_words, err_words, err_parts = self._preprocess(err) ans_org_words, ans_words, _ = self._preprocess(ans) if err_org_words is None or ans_org_words is None: return "error" err_word_lens = [len(t) for t in err_words] ans_word_lens = [len(t) for t in ans_words] # もし誤り文と正解文で単語分割の対応が異なったらエラーとする if err_word_lens != ans_word_lens: # print('error\n' + ' '.join(err_words) + '\n' + ' '.join(ans_words) + '\n') self.error += 1 return ''.join(err_org_words) self.num_sentence += 1 target_idx = self._get_target_positions(err_words, err_parts) # 訂正対象の位置を取得 error_idx = [ idx for idx in range(len(err_words) - 1) if err_words[idx] != ans_words[idx] ] # 誤り箇所の位置を取得 self.total_error_num += len(error_idx) # 間違い箇所数 self.total_predict_num += len(target_idx) # 予測する箇所数 # 誤り箇所が訂正対象に全て含まれていることを保証 assert len(set(error_idx) - set(target_idx)) == 0 # 後ろから訂正 if self.reverse is True: target_idx = target_idx[::-1] predict_list = [] for idx in target_idx: target = err_words[idx] # target: 対象単語 marked_sentence = '{} <{}> {}'.format( ' '.join(err_words[:idx]), err_words[idx], ' '.join(err_words[idx + 1:])) # 格助詞を<>で囲む test_data, _ = make_dataset([marked_sentence], self.w2id, self.class2id, n_encoder=self.n_encoder, to_kana=self.to_kana, is_train=False) predict, _ = self._predict(test_data) # predict: 予測単語 predict_list.append(predict) # 予測に置換 err_words[idx] = predict err_org_words[idx] = predict answer = ans_words[idx] # answer: 正解単語 if predict == answer: self.accurate += 1 # 予測して,かつ正解 if idx in error_idx: self.accurate_of_error += 1 # 間違い箇所であり,かつ正解 # 誤り箇所である条件の上で if idx in error_idx: # confusion matrix (target -> answer) を作成 cell = f'{target}->{answer}' if cell in self.confusion_target_to_answer.keys(): self.confusion_target_to_answer[cell] += 1 else: self.confusion_target_to_answer[cell] = 1 # confusion matrix (target -> predict) を作成 cell = f'{target}->{predict}' if cell in self.confusion_target_to_predict.keys(): self.confusion_target_to_predict[cell] += 1 else: self.confusion_target_to_predict[cell] = 1 # confusion matrix (predict -> answer) を作成 cell = f'{predict}->{answer}' if cell in self.confusion_predict_to_answer.keys(): self.confusion_predict_to_answer[cell] += 1 else: self.confusion_predict_to_answer[cell] = 1 # [1文中の対象格助詞の数,格助詞誤りの数] self.target_statistic.append([len(target_idx), len(error_idx)]) corrected = ''.join(err_org_words) if self.show: print(f'{self.num_sentence}') print(f'err: {err}') print(f'ans: {ans}') print(f'out: {corrected}') print(f'Result: {ans == corrected}\n') return corrected
data_type = args.data_type model_name = args.model_name experiment_name = args.experiment_name AE_type = args.AE_type pylib.mkdir('./output/%s' % experiment_name) with open('./output/%s/setting.txt' % experiment_name, 'w') as f: f.write(json.dumps(vars(args), indent=4, separators=(',', ':'))) # ============================================================================== # = datasets and models = # ============================================================================== source_train_data, target_train_data, source_test_data, target_test_data, \ min_n, preprocessor = utils.get_data(data_path, data_type, use_test) source_train_dataset = utils.make_dataset(source_train_data, batch_size = batch_size) target_train_dataset = utils.make_dataset(target_train_data, batch_size = batch_size) s_iterator = source_train_dataset.make_one_shot_iterator() s_next_element = s_iterator.get_next() t_iterator = target_train_dataset.make_one_shot_iterator() t_next_element = t_iterator.get_next() input_dim = source_train_data.shape[1] Enc, Dec_a, Dec_b, Disc = utils.get_models(model_name) Enc = partial(Enc, code_dim=code_dim) Dec_a = partial(Dec_a, output_dim=input_dim) Dec_b = partial(Dec_b, output_dim=input_dim) # ============================================================================== # = graph = # ==============================================================================
def main(opts): opts['cuda'] = torch.cuda.is_available() opts['device'] = torch.device('cuda' if opts['cuda'] else 'cpu') print("OPTS:\n", opts) if opts['num_compbot_samples_train'] == 0: opts['init_supervised_iters'] = 0 opts['num_supervised_iters'] = 0 random.seed(opts['seed']) np.random.seed(opts['seed']) torch.manual_seed(opts['seed']) comp_bot = CompositionalBot(opts, seed=opts['seed']) train_data, val_data, test_data = U.make_dataset( num_properties=opts['num_properties'], types_per_property=opts['types_per_property'], val_pct=opts['val_pct'], test_pct=opts['test_pct']) n_samples_train = train_data[:opts['num_compbot_samples_train']] n_samples_val = val_data[:opts['num_compbot_samples_val']] n_samples_test = test_data[:opts['num_compbot_samples_test']] train_data = train_data[opts['num_compbot_samples_train']:] val_data = val_data[opts['num_compbot_samples_val']:] test_data = test_data[opts['num_compbot_samples_test']:] train_inds = U.get_batch_indices(train_data, opts['num_properties'], opts['types_per_property'], opts['device']).permute(1, 0) val_inds = U.get_batch_indices(val_data, opts['num_properties'], opts['types_per_property'], opts['device']).permute(1, 0) test_inds = U.get_batch_indices(test_data, opts['num_properties'], opts['types_per_property'], opts['device']).permute(1, 0) n_samples_train_inds = U.get_batch_indices(n_samples_train, opts['num_properties'], opts['types_per_property'], opts['device']) n_samples_val_inds = U.get_batch_indices(n_samples_val, opts['num_properties'], opts['types_per_property'], opts['device']) n_samples_test_inds = U.get_batch_indices(n_samples_test, opts['num_properties'], opts['types_per_property'], opts['device']) train_data = torch.tensor(train_data, device=opts['device'], dtype=torch.float) val_data = torch.tensor(val_data, device=opts['device'], dtype=torch.float) test_data = torch.tensor(test_data, device=opts['device'], dtype=torch.float) n_samples_train = torch.tensor(n_samples_train, device=opts['device'], dtype=torch.float) n_samples_val = torch.tensor(n_samples_val, device=opts['device'], dtype=torch.float) n_samples_test = torch.tensor(n_samples_test, device=opts['device'], dtype=torch.float) n_samples_train_words = comp_bot.encoder(n_samples_train) n_samples_val_words = comp_bot.encoder(n_samples_val) n_samples_test_words = comp_bot.encoder(n_samples_test) n_samples_train_target = torch.argmax(n_samples_train_words.permute( 1, 0, 2), dim=-1) n_samples_val_target = torch.argmax(n_samples_val_words.permute(1, 0, 2), dim=-1) n_samples_test_target = torch.argmax(n_samples_test_words.permute(1, 0, 2), dim=-1) encdec_list = [] for i in range(opts['num_encoders_train']): encdec_list.append(CompEncoderDecoder(opts).to(device=opts['device'])) enc_acc = 0 dec_acc = 0 enc_acc_val = 0 dec_acc_val = 0 for it in range(opts['init_supervised_iters']): enc_acc_list = [] dec_acc_list = [] enc_acc_list_val = [] dec_acc_list_val = [] for j in range(opts['num_encoders_train']): enc_words = encdec_list[j].enc.encode(n_samples_train) encdec_list[j].enc.update(enc_words, n_samples_train_target) dec_out = encdec_list[j].dec.decode(n_samples_train_words) encdec_list[j].dec.update(dec_out, n_samples_train_inds) eacc_val = encdec_list[j].enc.test(n_samples_val, n_samples_val_target) eacc = encdec_list[j].enc.test(n_samples_train, n_samples_train_target) dacc_val = encdec_list[j].dec.test(n_samples_val_words, n_samples_val_inds) dacc = encdec_list[j].dec.test(n_samples_train_words, n_samples_train_inds) enc_acc_list_val.append(eacc_val) dec_acc_list_val.append(dacc_val) enc_acc_list.append(eacc) dec_acc_list.append(dacc) enc_acc = np.mean(enc_acc_list) dec_acc = np.mean(dec_acc_list) enc_acc_val = np.mean(enc_acc_list_val) dec_acc_val = np.mean(dec_acc_list_val) if (enc_acc > opts['max_val_acc']) and (dec_acc > opts['max_val_acc']): break encdec_acc_list = [] for j in range(opts['num_encoders_train']): val_sample = random.sample(list(range(len(val_data))), opts['batch_size']) val_batch = val_data[val_sample] val_batch_inds = val_inds[val_sample].permute(1, 0) ed_acc = encdec_list[j].test(val_batch, val_batch_inds) encdec_acc_list.append(ed_acc) encdec_acc = np.mean(encdec_acc_list) print("\nInitial supervised stats:") print("Encoder Accuracy Train:", enc_acc, "Val:", enc_acc_val, "at", it, "iters") print("Decoder Accuracy Train:", dec_acc, "Val:", dec_acc_val, "at", it, "iters") print("EncDec Accuracy:", encdec_acc, "before self-play") print("\n Starting joint training") im_val_encdec_acc = encdec_acc enc_acc = 0 dec_acc = 0 encdec_acc = 0 for it in range(opts['num_iters']): print("\nCombined iters", it) sp_encdec_acc = 0 sp_val_encdec_acc = 0 for fi in range(opts['num_selfplay_iters']): sp_encdec_acc_list = [] val_encdec_acc_list = [] for j in range(opts['num_encoders_train']): train_sample = random.sample(list(range(len(train_data))), opts['batch_size']) train_batch = train_data[train_sample] train_batch_inds = train_inds[train_sample].permute(1, 0) encdec_list[j].update(train_batch, train_batch_inds) sp_ed_acc = encdec_list[j].test(train_batch, train_batch_inds) sp_encdec_acc_list.append(sp_ed_acc) val_sample = random.sample(list(range(len(val_data))), opts['batch_size']) val_batch = val_data[val_sample] val_batch_inds = val_inds[val_sample].permute(1, 0) ed_acc = encdec_list[j].test(val_batch, val_batch_inds) val_encdec_acc_list.append(ed_acc) sp_encdec_acc = np.mean(sp_encdec_acc_list) sp_val_encdec_acc = np.mean(val_encdec_acc_list) if sp_val_encdec_acc > opts['max_val_acc']: break enc_acc_list = [] dec_acc_list = [] enc_acc_list_val = [] dec_acc_list_val = [] for j in range(opts['num_encoders_train']): eacc_val = encdec_list[j].enc.test(n_samples_val, n_samples_val_target) eacc = encdec_list[j].enc.test(n_samples_train, n_samples_train_target) dacc_val = encdec_list[j].dec.test(n_samples_val_words, n_samples_val_inds) dacc = encdec_list[j].dec.test(n_samples_train_words, n_samples_train_inds) enc_acc_list_val.append(eacc_val) dec_acc_list_val.append(dacc_val) enc_acc_list.append(eacc) dec_acc_list.append(dacc) sp_enc_acc = np.mean(enc_acc_list) sp_dec_acc = np.mean(dec_acc_list) sp_enc_acc_val = np.mean(enc_acc_list_val) sp_dec_acc_val = np.mean(dec_acc_list_val) print("\n After Self-Play stats:") print("Encoder Accuracy Train:", sp_enc_acc, "Val:", sp_enc_acc_val, "at", fi, "self-play iters") print("Decoder Accuracy Train:", sp_dec_acc, "Val:", sp_dec_acc_val, "at", fi, "self-play iters") print("EncDec Accuracy:", sp_val_encdec_acc, "at", fi, "self-play iters") im_enc_acc = 0 im_dec_acc = 0 im_enc_acc_val = 0 im_dec_acc_val = 0 for ii in range(opts['num_supervised_iters']): enc_acc_list = [] dec_acc_list = [] enc_acc_list_val = [] dec_acc_list_val = [] for j in range(opts['num_encoders_train']): enc_words = encdec_list[j].enc.encode(n_samples_train) encdec_list[j].enc.update(enc_words, n_samples_train_target) dec_out = encdec_list[j].dec.decode(n_samples_train_words) encdec_list[j].dec.update(dec_out, n_samples_train_inds) eacc_val = encdec_list[j].enc.test(n_samples_val, n_samples_val_target) eacc = encdec_list[j].enc.test(n_samples_train, n_samples_train_target) dacc_val = encdec_list[j].dec.test(n_samples_val_words, n_samples_val_inds) dacc = encdec_list[j].dec.test(n_samples_train_words, n_samples_train_inds) enc_acc_list_val.append(eacc_val) dec_acc_list_val.append(dacc_val) enc_acc_list.append(eacc) dec_acc_list.append(dacc) im_enc_acc = np.mean(enc_acc_list) im_dec_acc = np.mean(dec_acc_list) im_enc_acc_val = np.mean(enc_acc_list_val) im_dec_acc_val = np.mean(dec_acc_list_val) if (im_enc_acc > opts['max_val_acc']) and (im_dec_acc > opts['max_val_acc']): break val_encdec_acc_list = [] for j in range(opts['num_encoders_train']): val_sample = random.sample(list(range(len(val_data))), opts['batch_size']) val_batch = val_data[val_sample] val_batch_inds = val_inds[val_sample].permute(1, 0) ed_acc = encdec_list[j].test(val_batch, val_batch_inds) val_encdec_acc_list.append(ed_acc) im_val_encdec_acc = np.mean(val_encdec_acc_list) print("\n After Supervised stats:") print("Encoder Accuracy Train:", im_enc_acc, "Val:", im_enc_acc_val, "at", ii, "supervised iters") print("Decoder Accuracy Train:", im_dec_acc, "Val:", im_dec_acc_val, "at", ii, "supervised iters") print("EncDec Accuracy:", im_val_encdec_acc, "at", ii, "supervised iters") if it % opts['test_interval'] == 0: enc_acc_list = [] dec_acc_list = [] encdec_acc_list = [] for j in range(opts['num_encoders_train']): eacc = encdec_list[j].enc.test(n_samples_test, n_samples_test_target) dacc = encdec_list[j].dec.test(n_samples_test_words, n_samples_test_inds) test_sample = random.sample(list(range(len(test_data))), opts['batch_size']) test_batch = test_data[test_sample] test_batch_inds = test_inds[test_sample].permute(1, 0) ed_acc = encdec_list[j].test(test_batch, test_batch_inds) enc_acc_list.append(eacc) dec_acc_list.append(dacc) encdec_acc_list.append(ed_acc) enc_acc = np.mean(enc_acc_list) dec_acc = np.mean(dec_acc_list) encdec_acc = np.mean(encdec_acc_list) print(f'\n\n ###### At global iteration {it} Test stats: #######') print( f'Encoder accuracy on {opts["num_compbot_samples_test"]} samples is {enc_acc}' ) print( f'Decoder accuracy on {opts["num_compbot_samples_test"]} samples is {dec_acc}' ) print(f'Joint accuracy on test set is {encdec_acc}') if (sp_enc_acc > opts['max_val_acc']) and ( sp_dec_acc > opts['max_val_acc']) and (im_val_encdec_acc > opts['max_val_acc']): break if opts['save_dir'] != '': for jk in range(opts['num_encoders_train']): U.torch_save_to_file(encdec_list[jk].enc.state_dict(), folder=os.path.join(opts['save_dir'], 'params', 'enc_params'), file=f"_pop{jk}_params.pt") U.torch_save_to_file(encdec_list[jk].dec.state_dict(), folder=os.path.join(opts['save_dir'], 'params', 'dec_params'), file=f"_pop{jk}_params.pt")
parser.add_argument('--network', default='FSAM') parser.add_argument('--task', default='dehaze', help='dehaze') parser.add_argument('--gpu_id', type=int, default=0) parser.add_argument('--indir', default='examples/') parser.add_argument('--outdir', default='output') parser.add_argument('--model', default='') opt = parser.parse_args() ## forget to regress the residue for deraining by mistake, ## which should be able to produce better results opt.only_residual = opt.task == 'dehaze' #opt.model = 'models/wacv_gcanet_%s.pth' % opt.task opt.use_cuda = opt.gpu_id >= 0 if not os.path.exists(opt.outdir): os.makedirs(opt.outdir) test_img_paths = make_dataset(opt.indir) if opt.network == 'FSAM': from FSAM import FSAM_Net net = FSAM_Net(4) else: print('network structure %s not supported' % opt.network) raise ValueError if opt.use_cuda: print("use cuda") torch.cuda.set_device(opt.gpu_id) net.cuda() else: net.float()
if not params.LOAD_MODEL: model = train(tcnn, trainloader) save_model(model) else: model = load_model().to(device) testloader = DataLoader(dataset=test_set, batch_size=params.BATCH_SIZE, shuffle=True) iters = 0 loss = 0.0 cr_loss = nn.BCELoss() for i, data in enumerate(testloader, 0): tcnn.eval() mels, labels = data[0].to(device), data[1].to(device) pred = model(mels.unsqueeze(-1).permute(0, 3, 1, 2)).to('cpu').detach() res = accuracy(pred, labels) print(res) loss += cr_loss(pred.float(), labels.float().to('cpu').detach()).item() iters += 1 print(loss / iters) if __name__ == '__main__': make_dataset(params.OSU_TRACKS_DIR, params.DATA_PATH + '/audio_normal', +params.DATA_PATH + '/text_normal', params.ENUMERATE_FROM) parse_data()
print(options) categories = [ 'comp.os.ms-windows.misc', 'rec.motorcycles', 'sci.space', 'talk.politics.misc', ] #raw_train = fetch_20newsgroups(subset='train', categories=categories, data_home='../../..') #raw_test = fetch_20newsgroups(subset='test', categories=categories, data_home='../../..') raw_train = fetch_20newsgroups(subset='train', data_home="./") raw_test = fetch_20newsgroups(subset='test', data_home="./") #print(len(raw_train.data),len(raw_test.data),Const.OUTPUT) train_set = utils.make_dataset(raw_train) test_data = utils.make_dataset(raw_test) vocab = Vocabulary(min_freq=10).from_dataset(train_set, field_name='words') vocab.index_dataset(train_set, field_name='words', new_field_name='words') vocab.index_dataset(test_data, field_name='words', new_field_name='words') train_data, dev_data = train_set.split(0.1) print(len(train_data), len(dev_data), len(test_data), len(vocab)) embed = models.Embedding(len(vocab), options.embed_dim) if options.model == "RNN": model = models.RNNText(embed, options.hidden_size, 20, dropout=options.dropout, layers=options.layers)
def main(): # args parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--vocabsize', type=int, default=40000, help='Max size of vocablary') parser.add_argument('--minfreq', type=int, default=1, help='Min token frequency') parser.add_argument('--epoch', type=int, default=30, help='Max epochs') parser.add_argument('--batchsize', type=int, default=300, help='Batch size') parser.add_argument('--gpuid', type=int, default=-1, help='GPU ID') parser.add_argument('--unit', type=int, default=300, help='Number of hidden layer units') parser.add_argument('--layer', type=int, default=1, help='Number of hidden layers') parser.add_argument('--dropout', type=float, default=0.1, help='Dropout rate') parser.add_argument('--attn', default='global', choices=['disuse', 'global'], help='Type of attention mechanism') parser.add_argument('--encoder', default='LSTM', choices=['LSTM', 'GRU', 'CNN'], help='Type of Decoder NN') parser.add_argument('--n_encoder', type=int, default=2, help='Number of Encoders') parser.add_argument('--score', default='dot', choices=['dot', 'general', 'concat'], help=' ') parser.add_argument('--kana', default=False, action='store_true', help='Whether to convert to kana') parser.add_argument('--emb', default=None, help='Pretrained word embedding file') parser.add_argument('--train', required=True, help='Train dataset file') parser.add_argument('--valid', required=True, help='Validation dataset file') parser.add_argument('--save_dir', required=True, help='Directory to save results') parser.add_argument('--njob', type=int, default=None, help='Num of job') args = parser.parse_args() print(json.dumps(args.__dict__, indent=2)) # prepare train, converters = make_dataset(args.train, vocab_size=args.vocabsize, min_freq=args.minfreq, n_encoder=args.n_encoder, to_kana=args.kana, emb=args.emb, job=args.njob) w2id, class2id, initialW = converters['w2id'], converters[ 'class2id'], converters['initialW'] valid, _ = make_dataset(args.valid, w2id, class2id, n_encoder=args.n_encoder, to_kana=args.kana, job=args.njob) n_vocab = len(w2id) n_class = len(class2id) n_emb = initialW.shape[1] if args.emb else args.unit unk_rate = unknown_rate(train) vocab = {'class2id': class2id, 'w2id': w2id} args.__dict__['train_size'] = len(train) args.__dict__['n_vocab'] = n_vocab args.__dict__['n_emb'] = n_emb args.__dict__['unknown_rate'] = unk_rate os.makedirs(args.save_dir, exist_ok=True) json.dump(vocab, open(args.save_dir + '/vocab.json', 'w', encoding='utf-8'), ensure_ascii=False) json.dump(args.__dict__, open(args.save_dir + '/opts.json', 'w', encoding='utf-8'), ensure_ascii=False) print('Train size:', len(train)) print('Vocab size:', n_vocab) print('Unknown rate: {:.2f}%'.format(unk_rate * 100)) train_iter = chainer.iterators.SerialIterator(train, batch_size=args.batchsize) valid_iter = chainer.iterators.SerialIterator(valid, batch_size=args.batchsize, repeat=False, shuffle=False) # model if args.encoder == 'CNN' and args.n_encoder == 1: model = nets.Classifier(n_vocab, n_emb, args.unit, n_class, args.layer, args.dropout, args.encoder, initialW) elif args.encoder == 'CNN': model = nets.ContextClassifier(n_vocab, n_emb, args.unit, n_class, args.layer, args.dropout, args.encoder, initialW) elif args.attn == 'disuse': model = nets.ContextClassifier(n_vocab, n_emb, args.unit, n_class, args.layer, args.dropout, args.encoder, initialW) elif args.attn == 'global': model = nets.AttnContextClassifier(n_vocab, n_emb, args.unit, n_class, args.layer, args.dropout, args.encoder, args.score, initialW) if args.gpuid >= 0: cuda.get_device_from_id(args.gpuid).use() model.to_gpu(args.gpuid) # trainer optimizer = chainer.optimizers.Adam() optimizer.setup(model) updater = chainer.training.StandardUpdater(train_iter, optimizer, converter=seq_convert, device=args.gpuid) trainer = chainer.training.Trainer(updater, (args.epoch, 'epoch'), out=args.save_dir) trainer.extend( extensions.Evaluator(valid_iter, model, converter=seq_convert, device=args.gpuid)) trainer.extend(SaveModel(model, args.save_dir)) trainer.extend(extensions.LogReport()) trainer.extend( extensions.PrintReport([ 'epoch', 'main/loss', 'main/accuracy', 'validation/main/loss', 'validation/main/accuracy', 'elapsed_time' ])) trainer.extend(extensions.ProgressBar()) # train trainer.run()
def correction_api(self, text): if not text: return '' org_words, words, parts = self._preprocess(text) input_words = copy.deepcopy(org_words) target_idx = get_target_positions(words, parts) comp_idx = get_complement_positions(words, parts) assert set(target_idx) & set(comp_idx) == set() all_idx = sorted(target_idx + comp_idx) add_count = 0 replaces = [] adds = [] dels = [] if self.reverse: all_idx = all_idx[::-1] # 文末から訂正 for idx in all_idx: idx += add_count # 挿入した数だけ右にずらす # 置換 or 削除 if idx in target_idx: left_text, right_text = ' '.join(words[:idx]), ' '.join( words[idx + 1:]) # <DEL>に意味はない labeled_sentence = f'{left_text} <DEL> {right_text}' test_data, _ = make_dataset([labeled_sentence], self.w2id, self.class2id, n_encoder=self.n_encoder, to_kana=self.to_kana, is_train=False) if self.lm: predict, score = self._predict_lm(test_data) else: predict, score = self._predict(test_data) predict = words[idx] if score < self.threshold else predict if predict == 'DEL': # 左にシフト words = words[:idx] + words[idx + 1:] org_words = org_words[:idx] + org_words[idx + 1:] dels.append(idx - add_count) add_count -= 1 target_idx = [idx - 1 for idx in target_idx] else: if org_words[idx] != predict: words[idx] = predict org_words[idx] = predict replaces.append(idx) # 挿入 or キープ else: left_text, right_text = ' '.join(words[:idx]), ' '.join( words[idx:]) labeled_sentence = f'{left_text} <DEL> {right_text}' test_data, _ = make_dataset([labeled_sentence], self.w2id, self.class2id, n_encoder=self.n_encoder, to_kana=self.to_kana, is_train=False) if self.lm: predict, score = self._predict_lm(test_data) # 言語モデルで予測 else: predict, score = self._predict(test_data) predict = 'DEL' if score < self.threshold else predict # 予測確率が閾値より下なら変えない if predict == 'DEL': pass # キープ else: # 挿入 # 右にシフト words = words[:idx] + [predict] + words[idx:] org_words = org_words[:idx] + [predict] + org_words[idx:] add_count += 1 target_idx = [idx + 1 for idx in target_idx] adds.append(idx) return { 'input_words': input_words, 'corrected_words': org_words, 'replaces': replaces, 'adds': adds, 'dels': dels }
# Augmentation affine_transforms = transforms.RandomAffine(rotation_range=None, translation_range=0.1, zoom_range=(0.95, 1.05)) rand_flip = transforms.RandomFlip(h=True, v=False) std_normalize = transforms.StdNormalize() my_transforms = transforms.Compose([rand_flip, std_normalize]) # scalar encoder for incident angles encoder = ScalarEncoder(100, 30, 45) # using folding to create 5 train-validation sets to train 5 networks kf = KFold(n_splits=5, shuffle=True, random_state=100) kfold_datasets = [] networks = [] optimizers = [] for train_index, val_index in kf.split(data): train_dataset = make_dataset(data.iloc[train_index], encoder, my_transforms) val_dataset = make_dataset(data.iloc[val_index], encoder, my_transforms) kfold_datasets.append({"train": train_dataset, "val": val_dataset}) # A new net for each train-validation dataset networks.append(Net().cuda()) optimizers.append(Adam(networks[-1].parameters(), lr=0.0005, weight_decay=0.0002)) # Train criterion = torch.nn.BCEWithLogitsLoss() val_criterion = torch.nn.BCELoss() logger = Logger("./logs") logger.text_log((str(networks), str(optimizers), str(criterion)), "model_description.txt") def fit(train, val, batch_size, net, optimizer): """
def load_model(): # args parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--model_dir', required=True, help='Directory of trained models') parser.add_argument('--epoch', type=int, required=True, help='Epoch of model to use') parser.add_argument('--err', required=True, help='Segmented error text file') parser.add_argument('--ans', required=True, help='Segmented answer text file') parser.add_argument('--show', default=False, action='store_true', help='Whether to show results') args = parser.parse_args() # prepare vocab = json.load(open(args.model_dir + '/vocab.json')) w2id = vocab['w2id'] class2id = vocab['class2id'] id2w = {v: k for k, v in w2id.items()} id2class = {v: k for k, v in class2id.items()} n_vocab = len(w2id) n_class = len(class2id) opts = json.load(open(args.model_dir + '/opts.json')) n_emb = opts['n_emb'] n_units = opts['unit'] n_layer = opts['layer'] dropout = opts['dropout'] score = opts.get('score', 'dot') encoder = opts['encoder'] n_encoder = int(opts.get('n_encoder', 2)) attn = opts['attn'] to_kana = opts.get('kana', False) model_file = args.model_dir + '/model-e{}.npz'.format(args.epoch) # model if encoder == 'CNN' and n_encoder == 1: model = nets.Classifier(n_vocab, n_emb, n_units, n_class, n_layer, dropout, encoder) elif encoder == 'CNN': model = nets.ContextClassifier(n_vocab, n_emb, n_units, n_class, n_layer, dropout, encoder) elif attn == 'disuse': model = nets.ContextClassifier(n_vocab, n_emb, n_units, n_class, n_layer, dropout, encoder) elif attn == 'global': model = nets.AttnContextClassifier(n_vocab, n_emb, n_units, n_class, n_layer, dropout, encoder, score) chainer.serializers.load_npz(model_file, model) # test err_data = open(args.err).readlines() ans_data = open(args.ans).readlines() testdata = [ tagging(err, ans) for err, ans in zip(err_data, ans_data) if len(err) == len(ans) and err != ans ] test_data, _ = make_dataset(testdata, w2id, class2id, n_encoder=n_encoder, to_kana=to_kana) return model, test_data, id2w, id2class, n_encoder, args.show
all_subdirs = all_subdirs_of("./logs") latest_subdir = max(all_subdirs, key=os.path.getmtime) print("loading model from: " + latest_subdir) networks = load_model(os.path.join(latest_subdir, "models")) # networks = load_model(os.path.join("logs/2017-11-09-15-56-29", "models")) # scalar encoder for incident angles encoder = ScalarEncoder(100, 30, 45) print("Loading testset") test_df = pd.read_json("data/test.json") test_df["band_1"] = test_df["band_1"].apply( lambda x: np.array(x).reshape(75, 75)) test_df["band_2"] = test_df["band_2"].apply( lambda x: np.array(x).reshape(75, 75)) test_df["inc_angle"] = pd.to_numeric(test_df["inc_angle"], errors="coerce") test_dataset = make_dataset(test_df, encoder, transforms=None, test=True) print("Running test data") test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False) test_pred_mean = torch.FloatTensor() test_pred_std = torch.FloatTensor() for data_target in tqdm(test_loader, total=len(test_loader)): out_mean, out_std = infer_ensemble(data_target, networks, trial_per_sample=10) test_pred_mean = torch.cat((test_pred_mean, torch.FloatTensor([out_mean])), 0) test_pred_std = torch.cat((test_pred_std, torch.FloatTensor([out_std])), 0) test_pred_mean.squeeze_()
def main(): tf.set_random_seed(731) Epoch = 200 Batch_Size = 8 Lr = 1e-4 Epoch_Step = int(imgnum / Batch_Size) Beta1 = 3 Beta2 = 0.1 Val_Per = 0.2 Patience = 5 adj_attr = np.repeat(adj_attrsim[np.newaxis, :, :], Batch_Size, axis=0) adj_emb = np.repeat(adj_embsim[np.newaxis, :, :], Batch_Size, axis=0) dataset = utils.make_dataset(files, labels, attrs, Epoch, Batch_Size, is_training=True) iterator = dataset.make_one_shot_iterator() next_example, next_label, next_attr = iterator.get_next() with slim.arg_scope(resnet_v1.resnet_arg_scope()): net, end_points = resnet_v1.resnet_v1_50(next_example, 1000, is_training=True) ###end_points['resnet_v1_50/logits'] (?, 1, 1, 1000) class_conv = slim.conv2d(tf.nn.relu(end_points['resnet_v1_50/logits']), num_classes, kernel_size=[1, 1], activation_fn=None, scope='class_conv') attr_conv = slim.conv2d(tf.nn.relu(end_points['resnet_v1_50/logits']), attrnum, kernel_size=[1, 1], activation_fn=tf.nn.sigmoid, scope='attr_conv') class_logits = tf.squeeze(class_conv, axis=[1, 2]) attr_logits = tf.squeeze(attr_conv, axis=[1, 2]) class_loss = tf.reduce_mean( tf.nn.sparse_softmax_cross_entropy_with_logits(labels=next_label, logits=class_logits)) attr_loss = tf.reduce_mean( tf.reduce_sum(tf.pow(tf.subtract(next_attr, attr_logits), 2), axis=1)) class_actv = tf.squeeze(class_conv, axis=[1]) attrsim_loss = tf.reduce_mean( tf.multiply(tf.multiply(class_actv, adj_attr), tf.transpose(class_actv, perm=[0, 2, 1]))) embsim_loss = tf.reduce_mean( tf.multiply(tf.multiply(class_actv, adj_emb), tf.transpose(class_actv, perm=[0, 2, 1]))) sim_loss = attrsim_loss + embsim_loss loss = class_loss + Beta1 * attr_loss + Beta2 * sim_loss # finetune_names = ['block3', 'block4', 'class_conv', 'attr_conv'] # unrestore_names = ['class_conv', 'attr_conv'] # finetune_vars = [var for var in tf.trainable_variables() if max([1 if name in var.name else 0 for name in finetune_names])>0] # restore_vars = [var for var in tf.trainable_variables() if max([1 if name in var.name else 0 for name in unrestore_names])<=0] # training_op = tf.train.AdamOptimizer(learning_rate=Lr).minimize(loss, var_list=finetune_vars) training_op = tf.train.AdamOptimizer(learning_rate=Lr).minimize(loss) sess = tf.Session() sess.run(tf.global_variables_initializer()) # print('load weights') # restorer = tf.train.Saver(var_list=restore_vars) # restorer.restore(sess, '../ckpt/resnet_v1_50.ckpt') saver = tf.train.Saver() print('start training') best_loss = 999.0 loss_tracer = {} coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) for epoch in range(Epoch): print('epoch:{}'.format(epoch)) epoch_loss = {'train': [], 'val': []} for step in range(Epoch_Step): if (step + 1) / Epoch_Step <= (1 - Val_Per): loss_, sim_loss_ = sess.run([loss, sim_loss]) epoch_loss['train'].append(loss_) if step and not step % 1: print('step:{}, loss:{}, sim_loss:{}'.format( step, loss_, sim_loss_)) sess.run(training_op) else: loss_ = sess.run(loss) epoch_loss['val'].append(loss_) train_loss, val_loss = np.asarray( epoch_loss['train']).mean(), np.asarray(epoch_loss['val']).mean() print('epoch:{}, train loss:{}, val loss:{}'.format( epoch, train_loss, val_loss)) if val_loss < best_loss: best_loss = val_loss saver.save( sess, '../ckpt/model_{}_{}'.format(epoch + 1, '%03f' % (best_loss))) if (epoch + 1) > Patience and np.asarray( loss_tracer[-Patience:]).mean() < val_loss: print('early stoping at epoch:{}'.format(epoch + 1)) break loss_tracer.append(val_loss) coord.request_stop() coord.join(threads)
# get all rowing ucf files: input_filenames = get_ucf_class_filenames( ucf_folder_path=CONSTS.UCF_DIR, category='Rowing') elif input_path == 'ucf_but_rowing': # get all nonrowing ucf files: input_filenames = get_ucf_all_but_class_filenames( ucf_folder_path=CONSTS.UCF_DIR, category='Rowing') elif input_path == 'ucf_tennis': input_filenames = get_ucf_class_filenames( ucf_folder_path=CONSTS.UCF_DIR, category='TennisSwing') elif input_path == 'ucf_hammer': input_filenames = get_ucf_class_filenames( ucf_folder_path=CONSTS.UCF_DIR, category='HammerThrow') else: input_filenames = make_dataset(dir=input_path) gen_data(mode=args.mode, input_filenames=input_filenames, output_path=output_path, num_sets=args.num_sets, minimalImage_size=args.minimalImage_size, gen_frame_rate=2, frame_intervals=args.frame_intervals, limit=args.limit) # # Filter box proposals # # Feel free to change parameters # boxes_filter = selective_search.box_filter(boxes, min_size=20, topN=80) # # # draw rectangles on the original image