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
