def run(args=None):
usage = "usage : %prog [options]"
parser = optparse.OptionParser(usage=usage)
parser.add_option("--test", action="store_true", dest="test", default=False)
parser.add_option("--output_dim", dest="output_dim", type="int", default=0)
parser.add_option("--out_file", dest="out_file", type="string",
default="models/baseline.bin")
parser.add_option("--in_file", dest="in_file", type="string",
default="models/baseline.bin")
parser.add_option("--data", dest="data", type="string", default="train")
(opts, args) = parser.parse_args(args)
# Testing
if opts.test:
test(opts.in_file, opts.data)
return
print("Loading data...")
# load training data
trees = load_trees()
if opts.output_dim == 0:
opts.output_dim = len(load_label_map())
baseline = Baseline(opts.output_dim)
baseline.train(trees)
with open(opts.out_file, 'wb') as fid:
pickle.dump(opts, fid)
baseline.to_file(fid)
def execute(language):
language = language
data = Dataset(language)
print("{}: {} training - {} dev".format(language, len(data.trainset),
len(data.devset)))
baseline = Baseline(language)
estimator = SVC(gamma=300)
title = 'Spanish Learning Curves (SVM, γ=300)'
X, y = baseline.train(data.trainset)
plot_learning_curve(estimator,
title,
X,
y,
ylim=None,
n_jobs=1,
train_sizes=np.linspace(.1, 1.0, 5))
predictions = baseline.test(data.devset)
gold_labels = [sent['gold_label'] for sent in data.devset]
target_words = [sent['target_word'] for sent in data.devset]
prediction = []
for i in predictions:
prediction.append(i)
df = pd.DataFrame(columns=['target_word', 'prediction'])
df["target_word"] = target_words
df['gold_label'] = gold_labels
df['prediction'] = prediction
df.to_csv('out_s2.csv')
report_score(gold_labels, predictions)
def run(args=None):
usage = "usage : %prog [options]"
parser = optparse.OptionParser(usage=usage)
parser.add_option("--test",
action="store_true",
dest="test",
default=False)
parser.add_option("--output_dim", dest="output_dim", type="int", default=0)
parser.add_option("--out_file",
dest="out_file",
type="string",
default="models/baseline.bin")
parser.add_option("--in_file",
dest="in_file",
type="string",
default="models/baseline.bin")
parser.add_option("--data", dest="data", type="string", default="train")
(opts, args) = parser.parse_args(args)
# Testing
if opts.test:
test(opts.in_file, opts.data)
return
print("Loading data...")
# load training data
trees = load_trees()
if opts.output_dim == 0:
opts.output_dim = len(load_label_map())
baseline = Baseline(opts.output_dim)
baseline.train(trees)
with open(opts.out_file, 'wb') as fid:
pickle.dump(opts, fid)
baseline.to_file(fid)
utils.set_use_half(args.half)
utils.show_args(args)
data_loader = load_dataset(args)
model = utils.enable_cuda(resnet.resnet18())
if args.half:
model = network_to_half(model)
criterion = utils.enable_cuda(nn.CrossEntropyLoss())
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
optimizer = OptimizerAdapter(optimizer,
half=args.half,
static_loss_scale=args.static_loss_scale,
dynamic_loss_scale=args.dynamic_loss_scale)
model.train()
trainer = Baseline(model=model,
loader=data_loader,
criterion=criterion,
optimizer=optimizer)
trainer.train()
trainer.report_gpu()
trainer.report_train()
import os import sys from baseline import Baseline db_path = str(sys.argv[1]) storage_folder = str(sys.argv[2]) BATCH_SIZE = 10 CHUNK_SIZE = 50 model = Baseline(db_path, storage_folder, BATCH_SIZE) model.train() model.db_file.close()
class FACERecognition(object):
def __init__(self, cfg, inference=False, threshold=0.5):
self.device = torch.device(
"cuda") if cfg.MODEL.DEVICE == 'cuda' else torch.device("cpu")
if not inference:
print('load training data')
self.dataloader, class_num = get_train_loader(cfg)
print('load testing data')
if cfg.TEST.MODE == 'face':
self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data(
self.dataloader.dataset.root.parent)
else:
pairs = read_pairs(
os.path.join(cfg.DATASETS.FOLDER, 'pairs.txt'))
self.data, self.data_issame = get_paths(
os.path.join(cfg.DATASETS.FOLDER, 'test'), pairs)
print('load model')
self.model = Baseline(cfg)
self.model = self.model.to(self.device)
self.load_state(cfg)
if cfg.SOLVER.OPT == 'SGD':
self.optimizer = optim.SGD(
[{
'params': self.model.parameters()
}],
lr=cfg.SOLVER.BASE_LR,
momentum=cfg.SOLVER.MOMENTUM,
weight_decay=cfg.SOLVER.WEIGHT_DECAY)
else:
self.optimizer = optim.Adam(
[{
'params': self.model.parameters()
}],
lr=cfg.SOLVER.BASE_LR,
weight_decay=cfg.SOLVER.WEIGHT_DECAY)
self.scheduler = optim.lr_scheduler.CosineAnnealingLR(
self.optimizer,
T_max=cfg.SOLVER.MAX_EPOCH,
eta_min=cfg.SOLVER.ETA_MIN_LR)
checkpoints = cfg.CHECKPOINT.SAVE_DIR
os.makedirs(checkpoints, exist_ok=True)
self.best_score = 0.
self.best_threshold = 0.
else:
self.device = torch.device(
"cuda") if cfg.TEST.DEVICE == 'cuda' else torch.device("cpu")
print('load model')
self.model = Baseline(cfg)
self.model = self.model.to(self.device)
self.load_state(cfg)
self.threshold = threshold
self.test_transform = trans.Compose([
trans.ToTensor(),
trans.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
def load_state(self, cfg):
if cfg.CHECKPOINT.RESTORE:
os.makedirs(cfg.CHECKPOINT.SAVE_DIR, exist_ok=True)
weights_path = osp.join(cfg.CHECKPOINT.SAVE_DIR,
cfg.CHECKPOINT.RESTORE_MODEL)
self.model.load_state_dict(torch.load(weights_path,
map_location=self.device),
strict=False)
print('loaded model {}'.format(weights_path))
def save_state(self, cfg, save_name):
save_path = Path(cfg.CHECKPOINT.SAVE_DIR)
torch.save(self.model.state_dict(), save_path / save_name)
def evaluate(self, cfg, carray, issame, nrof_folds=5, tta=False):
self.model.eval()
idx = 0
embeddings = np.zeros([len(carray), cfg.MODEL.HEADS.EMBEDDING_DIM])
batch_size = cfg.SOLVER.IMS_PER_BATCH
with torch.no_grad():
while idx + batch_size <= len(carray):
batch = torch.tensor(carray[idx:idx + batch_size])
if tta:
fliped = hflip_batch(batch)
emb_batch = self.model(batch.to(self.device)) + self.model(
fliped.to(self.device))
embeddings[idx:idx + batch_size] = l2_norm(emb_batch)
else:
embeddings[idx:idx + batch_size] = self.model(
batch.to(self.device)).cpu()
idx += batch_size
if idx < len(carray):
batch = torch.tensor(carray[idx:])
if tta:
fliped = hflip_batch(batch)
emb_batch = self.model(batch.to(self.device)) + self.model(
fliped.to(self.device))
embeddings[idx:] = l2_norm(emb_batch)
else:
embeddings[idx:] = self.model(batch.to(self.device)).cpu()
tpr, fpr, accuracy, best_thresholds = scores(embeddings, issame,
nrof_folds)
buf = gen_plot(fpr, tpr)
roc_curve = Image.open(buf)
roc_curve_tensor = trans.ToTensor()(roc_curve)
return accuracy.mean(), best_thresholds.mean(), roc_curve_tensor
def train(self, cfg):
self.model.train()
step = 0
for e in range(cfg.SOLVER.MAX_EPOCH):
for data, labels in tqdm(self.dataloader,
desc=f"Epoch {e}/{cfg.SOLVER.MAX_EPOCH}",
ascii=True,
total=len(self.dataloader)):
data = data.to(self.device)
labels = labels.to(self.device)
self.optimizer.zero_grad()
loss_dict = self.model(data, labels)
losses = sum(loss_dict.values())
losses.backward()
self.optimizer.step()
accuracy = 0.0
if step % cfg.TEST.SHOW_PERIOD == 0:
print(
f"Epoch {e}/{cfg.SOLVER.MAX_EPOCH}, Step {step}, CE Loss: {loss_dict.get('loss_cls')}, Triplet Loss: {loss_dict.get('loss_triplet')}, Circle Loss: {loss_dict.get('loss_circle')}, Cos Loss: {loss_dict.get('loss_cosface')}"
)
if step % cfg.TEST.EVAL_PERIOD == 0:
if cfg.TEST.MODE == 'face':
accuracy, best_threshold, roc_curve_tensor = self.evaluate(
cfg, self.agedb_30, self.agedb_30_issame)
print("dataset {}, acc {}, best_threshold {}".format(
'agedb_30',
accuracy,
best_threshold,
))
accuracy, best_threshold, roc_curve_tensor = self.evaluate(
cfg, self.lfw, self.lfw_issame)
print("dataset {}, acc {}, best_threshold {}".format(
'lfw', accuracy, best_threshold))
if accuracy > self.best_score:
self.best_score = accuracy
self.best_threshold = best_threshold
self.save_state(
cfg,
'model_{}_best_accuracy:{:.3f}_step:{}.pth'.
format(get_time(), accuracy, step))
accuracy, best_threshold, roc_curve_tensor = self.evaluate(
cfg, self.cfp_fp, self.cfp_fp_issame)
print("dataset {}, acc {}, best_threshold {}".format(
'cfp_fp', accuracy, best_threshold))
else:
accuracy, best_threshold, roc_curve_tensor = self.evaluate(
cfg, self.data, self.data_issame)
print("dataset {}, acc {}, best_threshold {}".format(
'test', accuracy, best_threshold))
if accuracy > self.best_score:
self.best_score = accuracy
self.best_threshold = best_threshold
self.save_state(
cfg,
'model_{}_best_accuracy:{:.3f}_step:{}.pth'.
format(get_time(), accuracy, step))
self.model.train()
if step % cfg.TEST.SAVE_PERIOD == 0:
self.save_state(
cfg, 'model_{}_accuracy:{:.3f}_step:{}.pth'.format(
get_time(), accuracy, step))
step += 1
self.save_state(cfg,
'model_{}_step:{}.pth'.format(get_time(), step))
self.scheduler.step()
def infer(self, faces, target_embs, tta=False):
'''
faces : list of PIL Image
target_embs : [n, 512] computed embeddings of faces in facebank
names : recorded names of faces in facebank
tta : test time augmentation (hfilp, that's all)
'''
embs = []
for img in faces:
if tta:
mirror = trans.functional.hflip(img)
emb = self.model(
self.test_transform(img).to(self.device).unsqueeze(0))
emb_mirror = self.model(
self.test_transform(mirror).to(self.device).unsqueeze(0))
embs.append(l2_norm(emb + emb_mirror))
else:
embs.append(
self.model(
self.test_transform(img).to(self.device).unsqueeze(0)))
source_embs = torch.cat(embs)
if isinstance(target_embs, list):
tmp = []
for img in target_embs:
if tta:
mirror = trans.functional.hflip(img)
tmp = self.model(
self.test_transform(img).to(self.device).unsqueeze(0))
tmp_mirror = self.model(
self.test_transform(mirror).to(
self.device).unsqueeze(0))
tmp.append(l2_norm(tmp + tmp_mirror))
else:
tmp.append(
self.model(
self.test_transform(img).to(
self.device).unsqueeze(0)))
target_embs = torch.cat(tmp)
diff = source_embs.unsqueeze(-1) - target_embs.transpose(
1, 0).unsqueeze(0)
dist = torch.sum(torch.pow(diff, 2), dim=1)
minimum, min_idx = torch.min(dist, dim=1)
min_idx[minimum > self.threshold] = -1 # if no match, set idx to -1
return min_idx, minimum
print(ex)
print("------------------------Failed To Load Dataset------------------------")
exit()
else:
print("----------------------------Datasets Loaded----------------------------")
print("-----------------------Baseline Predictor Testing----------------------")
space = (numpy.linspace(1, 300, 100)).astype(int)
scores = []
model = Baseline()
model.train(X, Y)
for k in space:
print("Epoch: ", k)
model.set_beta_u(k)
model.set_beta_i(k)
score = model.RMSE(X_test, Y_test)
print("RMSE: ", score)
scores.append(score)
matplotlib.pyplot.plot(space, scores, 'ro')
matplotlib.pyplot.xlabel('Beta')
matplotlib.pyplot.ylabel('RMSE')
matplotlib.pyplot.title('Baseline Predictor')
matplotlib.pyplot.savefig('../plots/baseline_predictor.png')
matplotlib.pyplot.gcf().clear()
def train():
if args.model is 'baseline':
net = Baseline(in_channels=7,
out_channels_1=7,
out_channels_2=7,
KT_1=4,
KT_2=3,
num_nodes=39,
batch_size=args.batch_size,
frames=33,
frames_0=12,
num_generator=10)
elif args.model is 'GAT':
net = GAT()
elif args.model is 'GAT_edge':
net = GAT_edge()
else:
print('must choose a model in the choices')
raise
if args.init_type is not None:
try:
init_weights(net, init_type=args.init_type)
except:
sys.exit('Load Network <==> Init_weights error!')
# net = nn.DataParallel(net)
net = net.cuda()
accuracy = 0
train_file = 4
train_amount = 6400 # 8144
eval_amount = 3200
num_epoch = train_amount // args.batch_size * train_file
train_data = trainSet(39, train_amount, [0, 1, 2, 3])
trainloader = DataLoader(train_data,
batch_size=args.batch_size,
shuffle=True)
batch_loader = iter(trainloader)
eval_data = trainSet(39, eval_amount, 4)
evalloader = DataLoader(eval_data,
batch_size=args.batch_size,
shuffle=True)
eval_iter = iter(evalloader)
optimizer = optim.Adam(net.parameters(), lr=args.lr)
net.train()
# train ------------------------------------------------
print('---- epoch start ----')
start_time = time.time()
for epoch in range(num_epoch):
# load train data
try:
Y, infos, labels = next(batch_loader)
Y, infos, labels = Y.float().cuda(), infos.float().cuda(
), labels.float().cuda()
except StopIteration:
batch_iterator = iter(trainloader)
Y, infos, labels = next(batch_iterator)
Y, infos, labels = Y.float().cuda(), infos.float().cuda(
), labels.float().cuda()
label_predicted = net(Y, infos)
# loss = MSE_loss(label_predicted, labels.long())
# criteria = nn.BCELoss()
loss = MSE_loss(label_predicted, labels.long())
optimizer.zero_grad()
loss.backward()
nn.utils.clip_grad_norm_(net.parameters(), max_norm=20, norm_type=2)
optimizer.step()
print('epoch:{}/{} | loss:{:.4f}'.format(epoch + 1, num_epoch,
loss.item()))
with open(args.log_folder + 'loss.log', mode='a') as f:
f.writelines('\n epoch:{}/{} | loss:{:.4f}'.format(
epoch + 1, num_epoch, loss.item()))
# eval ------------------------------------------------
if epoch % 20 == 0:
net.eval()
accu, _ = evaluate(model=net,
data_iter=eval_iter,
data_loader=evalloader,
num_epoch=10)
print('accuracy:{}'.format(accu))
with open(args.log_folder + 'accu.log', mode='a') as f:
f.writelines('\n eval epoch:{} | loss:{:.4f}'.format(
epoch // 20 + 1, loss.item()))
if accu > accuracy:
torch.save(
net.state_dict(),
args.save_folder + '{}_{}.pth'.format(args.model, accu))
accuracy = accu
stop_time = time.time()
print("program run for {} s".format(stop_time - start_time))
