def test(model, loader, attacker, criterion, device):
model.eval()
N = len(loader.dataset)
pred_success, attack_success, loss = 0, 0, 0.
with torch.no_grad():
for itr, data in enumerate(loader):
input, target = data[0], data[1]
noise = torch.randn_like(input) * 0.05
input = input + noise
input = torch.clamp(input, 0., 1.)
input = input.to(device)
target = target.to(device)
logit = model(input)
Loss = criterion(logit, target)
loss += Loss.item() * input.shape[0]
pred = torch.argmax(logit, dim=1)
pred_success += pred.eq(target).sum().item()
with torch.enable_grad():
input_attack = attacker.attack(inputs=input,
model=model,
labels=target,
targeted=None)
logit_attack = model(input_attack)
pred_attack = torch.argmax(logit_attack, dim=1)
attack_success += (~pred_attack.eq(target)).sum().item()
# pred_succes should > 0
return pred_success / N, attack_success / N, loss / N
def on_button_click1(self,df):
dataset_location=self.entry1.get()
loc = dataset_location.split("/")
filename= loc[-1]
dest_loc = "./"+filename
shutil.copyfile(dataset_location,dest_loc)
preprocessing.missing_value_filling(filename)
df = feature_engineering.feature_engineering(df)
todo = 'classfication' #nlp module will be sending this
models.model(df, todo)
def predict_1batch(model, inputs, tta):
inputs = inputs.cuda()
outputs = model(inputs)
if isinstance(outputs, tuple):
outputs, logits_fc = outputs
B, C, H, W = outputs.shape
else:
B, C, H, W = outputs.shape
logits_fc = outputs.view(B, C, -1)
logits_fc = torch.max(logits_fc, -1)[0]
logits_fc = logits_fc.view(B, C)
cls_pred = F.sigmoid(logits_fc).view(-1).data.cpu().numpy()
mask_pred = F.sigmoid(outputs).view(-1, H, W).data.cpu().numpy()
if tta >= 2: # h flip
# mask
outputs = model(inputs.flip(3))
if isinstance(outputs, tuple):
outputs, logits_fc = outputs
else:
logits_fc = outputs.view(B, C, -1)
logits_fc = torch.max(logits_fc, -1)[0]
logits_fc = logits_fc.view(B, C)
outputs = outputs.flip(3)
mask_pred += F.sigmoid(outputs).view(-1, H, W).data.cpu().numpy()
# cls
cls_pred += F.sigmoid(logits_fc).view(-1).data.cpu().numpy()
if tta == 3: # v flip
# mask
outputs = model(inputs.flip(2))
if isinstance(outputs, tuple):
outputs, logits_fc = outputs
else:
logits_fc = outputs.view(B, C, -1)
logits_fc = torch.max(logits_fc, -1)[0]
logits_fc = logits_fc.view(B, C)
outputs = outputs.flip(2)
mask_pred += F.sigmoid(outputs).view(-1, H, W).data.cpu().numpy()
# cls
logits_fc = outputs.view(B, C, -1)
logits_fc = torch.max(logits_fc, -1)[0]
cls_pred += F.sigmoid(logits_fc).view(-1).data.cpu().numpy()
if tta != 0:
cls_pred /= tta
mask_pred /= tta
return mask_pred, cls_pred
def test(test_loader, model, folds, all_train_loader=None):
# sample_submission_df = pd.read_csv("./dataset/test_visit.csv")
#3.1 confirm the model converted to cuda
filenames, labels_te, labels_tr, submissions = [], [], [], []
labels_true = []
model.cuda()
model.eval()
submit_results = []
try:
with tqdm(test_loader, ascii=True) as t:
for img_data, visit_data, filepath in t:
#3.2 change everything to cuda and get only basename
filepath = [x for x in filepath]
with torch.no_grad():
image_var = img_data.cuda(non_blocking=True)
visit_var = visit_data.cuda(non_blocking=True)
y_pred = model(image_var, visit_var)
label = y_pred.sigmoid().cpu().data.numpy()
#print(label > 0.5)
submit_results.append(np.argmax(label, 1))
labels_te.append(np.squeeze(label))
filenames.append(np.squeeze(filepath))
if not isinstance(all_train_loader, type(None)):
with tqdm(all_train_loader, ascii=True) as t:
for img_data, visit_data, target in t:
#3.2 change everything to cuda and get only basename
target = np.squeeze(target).cpu().data.numpy()
with torch.no_grad():
image_var = img_data.cuda(non_blocking=True)
visit_var = visit_data.cuda(non_blocking=True)
y_pred = model(image_var, visit_var)
label = y_pred.sigmoid().cpu().data.numpy()
labels_tr.append(
np.hstack(
[np.squeeze(label),
target.reshape(-1, 1)]))
return np.concatenate(labels_te), np.concatenate(labels_tr)
except:
t.close()
raise
t.close()
# sample_submission_df['Predicted'] = np.concatenate(submit_results)
# sample_submission_df['IterId'] = np.concatenate(filenames)
# sample_submission_df.to_csv('./submit/%s_bestloss_submission%s.csv'%(config.model_name, folds), index=None)
return np.concatenate(labels_te), None
def evaluate(split, verbose=False, n_batches=None):
"""
Compute loss on val or test data.
"""
model.eval()
loss = 0
acc = 0
correct = 0
n_examples = 0
if split == "val":
loader = val_loader
elif split == "test":
loader = test_loader
for batch_i, batch in enumerate(loader):
data, target = batch
data, target = (
Variable(data).to(device=device),
Variable(target).to(device=device),
)
output = model(data)
loss += criterion(output, target).item()
acc += (np.sum(
output.cpu().data.numpy()[target.cpu().data.numpy() != 0] > 0.5) +
np.sum(output.cpu().data.numpy()[target.cpu().data.numpy(
) == 0] < 0.5)) / float(args.im_size[1] * args.im_size[2])
n_examples += output.size(0)
if n_batches and (batch_i == n_batches - 1):
break
loss /= n_examples
acc /= n_examples
return loss, acc
def evaluate(val_loader, model, optimizer, criterion, epoch):
# 2.1 为损失和准确率创建“标尺”（拥有计数、求和、求平均功能）
losses = AverageMeter()
top1 = AverageMeter()
# 2.2 创建进度条
val_progressor = ProgressBar(mode="Val ", epoch=epoch, total_epoch=config.epochs, model_name=config.model_name,
total=len(val_loader)*config.batch_size)
# 2.3 验证过程
model.cuda()
model.eval()
with torch.no_grad():
for i, (input, target) in enumerate(val_loader):
val_progressor.current = i*config.batch_size
input = input.cuda()
target = torch.from_numpy(np.array(target)).long().cuda() # 范式
output = model(input) # 将input输入模型得到预测输出
loss = criterion(output, target) # 根据预测和真实标签求损失
# 2.3.2 计算准确率并实时更新进度条的显示内容
precision = accuracy(output, target)
losses.update(loss.item(), input.size(0))
top1.update(precision[0], input.size(0))
val_progressor.current_loss = losses.avg
val_progressor.current_top1 = top1.avg
val_progressor.current_lr = get_learning_rate(optimizer)
val_progressor()
val_progressor.done()
return [losses.avg, top1.avg]
def evaluate(data_loader):
model.eval()
total_loss = 0
accBF = 0.0
accBC = 0.0
with torch.no_grad():
for idx, (cpu_images, cpu_texts) in enumerate(data_loader):
batch_size = cpu_images.size(0)
util.loadData(image, cpu_images)
t, l = converter.encode(cpu_texts)
util.loadData(text, t)
util.loadData(length, l)
output = model(image)
output_size = Variable(
torch.LongTensor([output.size(0)] * batch_size))
loss = criterion(output, text, output_size, length) / batch_size
total_loss += loss
_, output = output.max(2)
output = output.transpose(1, 0).contiguous().view(-1)
sim_preds = converter.decode(output.data,
output_size.data,
raw=False)
accBF += metric.by_field(sim_preds, cpu_texts)
accBC += metric.by_char(sim_preds, cpu_texts)
total_loss /= len(data_loader)
return total_loss, accBF / len(data_loader), accBC / len(data_loader)
def train(data_loader):
total_loss = 0
model.train()
data_loader = tqdm(data_loader)
for idx, (cpu_images, cpu_texts) in enumerate(data_loader):
batch_size = cpu_images.size(0)
util.loadData(image, cpu_images)
t, l = converter.encode(cpu_texts)
util.loadData(text, t)
util.loadData(length, l)
output = model(image)
output_size = Variable(torch.LongTensor([output.size(0)] * batch_size))
loss = criterion(output, text, output_size, length) / batch_size
optimizer.zero_grad()
loss.backward()
clipping_value = 1.0
torch.nn.utils.clip_grad_norm_(model.parameters(), clipping_value)
if not (torch.isnan(loss) or torch.isinf(loss)):
optimizer.step()
total_loss += loss.item()
if idx % 1000 == 0 and idx != 0:
print('{} index: {}/{}(~{}%) loss: {}'.format(
datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), idx,
len(data_loader), round(idx * 100 / len(data_loader)),
total_loss / idx))
return total_loss / len(data_loader)
def search_thresholds(all_loader, model):
model.cuda()
model.eval()
all_target = []
all_pred = []
with torch.no_grad():
for i, (images, target) in enumerate(tqdm(all_loader)):
images_var = images.cuda(non_blocking=True)
output = model(images_var)
pred = output.sigmoid().cpu().data.numpy()
all_target.extend(np.array(target).tolist())
all_pred.extend(pred.tolist())
print(np.array(all_target).shape)
print(np.array(all_pred).shape)
thresholds = np.linspace(0, 1, 100)
test_threshold = 0.5 * np.ones(28)
best_threshold = np.zeros(28)
best_val = np.zeros(28)
for i in range(28):
for threshold in thresholds:
test_threshold[i] = threshold
score = f1_score(np.array(all_target),
np.array(all_pred) > test_threshold,
average='macro')
if score > best_val[i]:
best_threshold[i] = threshold
best_val[i] = score
print("Threshold[%d] %0.6f, F1: %0.6f" %
(i, best_threshold[i], best_val[i]))
test_threshold[i] = best_threshold[i]
print("Best threshold: ")
print(best_threshold)
print("Best f1:")
print(best_val)
def test(test_loader, model, folds):
correct = 0
total = 0
# confirm the model converted to cuda
model.cuda()
model.eval()
for i, (inputs, labels) in enumerate(test_loader):
# change everything to cuda
with torch.no_grad():
inputs = Variable(inputs).cuda()
labels = Variable(labels).cuda()
# print(inputs, inputs.shape)
outputs = model(inputs)
# Mapping outputs to (0,1), The sum of each row is 1
smax = nn.Softmax(1)
smax_out = smax(outputs)
# Return the element with the largest value in each row and it's index
_, pred_labels = torch.max(smax_out, 1)
# print("pred_label:", pred_labels, "pred:", pred)
total += labels.size(0)
correct += (pred_labels == labels.long()).sum().item()
accuracy = 100.0 * float(correct) / float(total)
print("correct:", correct)
print("total:", total)
print('Accuracy of the network on the test set: %.3f%%' % (
accuracy))
def call_classifier(img):
image = transforms.ToPILImage()(img)
image=transforms.Resize((224,224))(image)
# initialize the computation device
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
image=transforms.ToTensor()(image).unsqueeze(0).to(device)
#intialize the model
model = models.model(pretrained=False, requires_grad=False).to(device)
# load the model checkpoint
checkpoint = torch.load('./output/model.pth')
# load model weights state_dict
model.load_state_dict(checkpoint['model_state_dict'])
model.eval()
outputs=model(image)
outputs = torch.sigmoid(outputs)
outputs = outputs.detach().cpu()
if np.array(outputs[0][0])>0.5 and np.array(outputs[0][1])<0.5:
print("DANGER cat")
elif np.array(outputs[0][0])<0.5 and np.array(outputs[0][1])>0.5:
print("bird")
elif np.array(outputs[0][0])>0.5 and np.array(outputs[0][1])>0.5:
print("DANGER cat and bird")
def make_model(img, results, mask):
confs = results[:, :, :, :n_pos]
pafs = results[:, :, :, n_pos:]
m1 = tf_repeat(mask, [1, 1, 1, n_pos])
m2 = tf_repeat(mask, [1, 1, 1, n_pos * 2])
cnn, b1_list, b2_list, net = model(img, n_pos, m1, m2, True, False)
# define loss
losses = []
last_losses_l1 = []
last_losses_l2 = []
stage_losses = []
for idx, (l1, l2) in enumerate(zip(b1_list, b2_list)):
loss_l1 = tf.nn.l2_loss((l1.outputs - confs) * m1)
loss_l2 = tf.nn.l2_loss((l2.outputs - pafs) * m2)
losses.append(tf.reduce_mean([loss_l1, loss_l2]))
stage_losses.append(loss_l1 / batch_size)
stage_losses.append(loss_l2 / batch_size)
last_conf = b1_list[-1].outputs
last_paf = b2_list[-1].outputs
last_losses_l1.append(loss_l1)
last_losses_l2.append(loss_l2)
L2 = 0.0
for p in tl.layers.get_variables_with_name('kernel', True, True):
L2 += tf.contrib.layers.l2_regularizer(0.0005)(p)
total_loss = tf.reduce_sum(losses) / batch_size + L2
return total_loss, last_conf, stage_losses, L2, cnn, last_paf, img, confs, pafs, m1, net
def evaluate(val_loader, model, criterion, epoch):
# 2.1 define meters
losses = AverageMeter()
top1 = AverageMeter()
# progress bar
val_progressor = ProgressBar(mode="Val ",
epoch=epoch,
total_epoch=config.epochs,
model_name=config.model_name,
total=len(val_loader))
# 2.2 switch to evaluate mode and confirm model has been transfered to cuda
model.cuda()
# model.eval()
with torch.no_grad():
for i, (input, target) in enumerate(val_loader):
val_progressor.current = i
input = Variable(input).cuda()
target = Variable(torch.from_numpy(np.array(target)).long()).cuda()
# target = Variable(target).cuda()
# 2.2.1 compute output
output = model(input)
loss = criterion(output, target)
# 2.2.2 measure accuracy and record loss
precision1, precision2 = accuracy(output, target, topk=(1, 2))
losses.update(loss.item(), input.size(0))
top1.update(precision1[0], input.size(0))
val_progressor.current_loss = losses.avg
val_progressor.current_top1 = top1.avg
val_progressor()
val_progressor.done()
return [losses.avg, top1.avg]
def train():
for epoch in range(0, num_epochs):
batch_num = 0
for i, batch in enumerate(train_dataloader):
if batch_num > max_batches_per_epoch:
break
# split batch into input, target and covariates. Target is simply the input shifted forward by one time step
input, target, covariates = utils.split_batch(batch)
# input in the conditioning window. For the prediction window, model output will be conditioned on the
# model output for the previous step
input_cond = input[:, 0:cond_win_len, :]
# Scale the input and oovariates so they are 0 mean and range = 1. Note we apply scaling per batch, not for the
# entire dataset. Contrast this with training imagenet models, where the scaling params are calculated over
# the entire training dataset
input_cond, covariates = utils.scale(input_cond, covariates)
optimizer.zero_grad()
# Run the forward pass
out = model(input_cond, covariates, future=pred_win_len)
# scale model output and target to the original data scale.
out = utils.invert_scale(out)
# calculate MSE loss, run backward pass, update parameters.
loss = criterion(out[:], target[:])
loss.backward()
scheduler.step()
optimizer.step()
loss = np.sqrt(loss.item())
losses.append(loss)
print('epoch:{0}/{1}, step:{2}, loss:{3}'.format(
epoch, num_epochs, batch_num, loss))
batch_num = batch_num + 1
return model, losses
def train(train_loader, model, criterion, optimizer, epoch, valid_loss,
best_results, start):
losses = AverageMeter()
f1 = AverageMeter()
model.train()
for i, (images, target) in enumerate(train_loader):
images = images.cuda(non_blocking=True)
target = torch.from_numpy(
np.array(target)).float().cuda(non_blocking=True)
# compute output
output = model(images)
loss = criterion(output, target)
losses.update(loss.item(), images.size(0))
f1_batch = f1_score(target,
output.sigmoid().cpu() > 0.15,
average='macro')
f1.update(f1_batch, images.size(0))
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('\r', end='', flush=True)
message = '%s %5.1f %6.1f | %0.3f %0.3f | %0.3f %0.4f | %s %s | %s' % (\
"train", i/len(train_loader) + epoch, epoch,
losses.avg, f1.avg,
valid_loss[0], valid_loss[1],
str(best_results[0])[:8],str(best_results[1])[:8],
time_to_str((timer() - start),'min'))
print(message, end='', flush=True)
log.write("\n")
#log.write(message)
#log.write("\n")
return [losses.avg, f1.avg]
def test(model: nn.Module, test_loader: DataLoader, criterion, last_layer=None, device=torch.device('cpu')):
model.eval()
# model.to(device)
# device = model.device
N = len(test_loader.dataset)
loss = 0.
acc = 0.
n = 0
with torch.no_grad():
for itr, data in enumerate(test_loader):
input, target = data[0].to(device), data[1].to(device)
output = model(input)
if last_layer is not None:
if isinstance(output, list) or isinstance(output, tuple):
for i in range(len(output)):
output[i] = last_layer(output[i])
Loss = criterion(output, target)
loss += Loss.item() * input.shape[0]
n += input.shape[0]
pred = torch.argmax(output, dim=1)
acc += pred.eq(target).sum().item()
return loss / n, acc / n
def test(test_loader, model, folds):
sample_submission_df = pd.read_csv("/mfs/human/sample_submission.csv")
#3.1 confirm the model converted to cuda
filenames, labels, submissions = [], [], []
model.cuda()
model.eval()
submit_results = []
for i, (input, filepath) in enumerate(tqdm(test_loader)):
#3.2 change everything to cuda and get only basename
filepath = [os.path.basename(x) for x in filepath]
with torch.no_grad():
image_var = input.cuda(non_blocking=True)
y_pred = model(image_var)
label = y_pred.sigmoid().cpu().data.numpy()
#print(label > 0.5)
labels.append(label > 0.15)
filenames.append(filepath)
for row in np.concatenate(labels):
subrow = ' '.join(list([str(i) for i in np.nonzero(row)[0]]))
submissions.append(subrow)
sample_submission_df['Predicted'] = submissions
sample_submission_df.to_csv('./submit/%s_bestloss_submission.csv' %
config.model_name,
index=None)
def val(args, model, criterion, dataloader, epoch, k_fold):
with torch.no_grad():
model.eval()
top1_m = u.AverageMeter()
loss_m = u.AverageMeter()
# precision_m = u.AverageMeter()
# recall_m = u.AverageMeter()
# f1_m = u.AverageMeter()
eval_progressor = pb.Val_ProgressBar(mode='val',
fold=k_fold,
model_name=args.model_name,
epoch=epoch + 1,
total=len(dataloader))
for i, (data, label) in enumerate(dataloader):
eval_progressor.current = i
if torch.cuda.is_available() and args.use_gpu:
data = data.cuda()
label = label.cuda()
predict = model(data)
loss = criterion(predict, label)
top1 = u.accuracy(predict, label)
top1_m.update(top1[0].item(), data.size(0))
acc = top1_m.avg
loss_m.update(loss.item())
loss = loss_m.avg
eval_progressor.val = [acc, loss, 0, 0]
eval_progressor()
eval_progressor.done()
return acc, 0, 0, 0
def test(test_loader, model, folds):
sample_submission_df = pd.read_csv(config.sample_submission)
#1.1 confirm the model converted to cuda
filenames, labels, submissions = [], [], []
model.cuda()
model.eval()
submit_results = []
for i, (input, filepath) in enumerate(tqdm(test_loader)):
#1.2 change everything to cuda and get only basename
filepath = [os.path.basename(x) for x in filepath]
probs = []
for k in range(config.n_tta):
with torch.no_grad():
image_var = input.cuda(non_blocking=True)
y_pred = model(image_var)
prob = y_pred.sigmoid().cpu().data.numpy()
probs.append(prob)
probs_agg = np.vstack(probs).mean(axis=0)
preds = probs_agg > config.thresold
if len(preds) == 0: preds = [np.argmax(probs_agg)]
subrow = ' '.join(list([str(i) for i in np.nonzero(preds)[0]]))
if len(subrow) == 0:
subrow = np.argmax(probs_agg)
submissions.append(subrow)
sample_submission_df['Predicted'] = submissions
sample_submission_df.to_csv('./submit/{}_bestloss_submission.csv'.format(
config.model_name),
index=None)
def evaluate(data, mode):
if mode == 'val_mode':
bsz = val_batch_size
elif mode == 'test_mode':
bsz = test_batch_size
global loss_least
global num_tokens
model.eval()
total_loss = 0
hidden = model.init_hidden(bsz)
for i in range(0, data.size(0) - 1, BPTT):
X, Y = batching.get_batch(data, i, evaluation=True)
output, hidden = model(X, hidden)
predictions = output.view(-1, num_tokens)
total_loss += len(X) * criterion(predictions, Y).data
hidden = repackage_hidden(hidden)
final_loss = total_loss[0] / len(data)
print("Epoch: " + str(epoch) + " Val Loss: " + str(final_loss) +
" Val Perplexity: " + str(math.exp(final_loss)))
'''
if final_loss < loss_least:
with open(MODEL_SAVE_PATH, 'wb') as f:
torch.save(model, f)
loss_least = final_loss
'''
return final_loss
def evaluate(val_loader,model,criterion,epoch,train_loss,best_results,start):
# only meter loss and f1 score
losses = AverageMeter()
f1 = AverageMeter()
# switch mode for evaluation
model.cuda()
model.eval()
with torch.no_grad():
for i, (images,target) in enumerate(val_loader):
images_var = images.cuda(non_blocking=True)
target = torch.from_numpy(np.array(target)).float().cuda(non_blocking=True)
#image_var = Variable(images).cuda()
#target = Variable(torch.from_numpy(np.array(target)).long()).cuda()
output = model(images_var)
loss = criterion(output,target)
losses.update(loss.item(),images_var.size(0))
f1_batch = f1_score(target,output.sigmoid().cpu().data.numpy() > 0.15,average='macro')
f1.update(f1_batch,images_var.size(0))
print('\r',end='',flush=True)
message = '%s %5.1f %6.1f | %0.3f %0.3f | %0.3f %0.4f | %s %s | %s' % (\
"val", i/len(val_loader) + epoch, epoch,
train_loss[0], train_loss[1],
losses.avg, f1.avg,
str(best_results[0])[:8],str(best_results[1])[:8],
time_to_str((timer() - start),'min'))
print(message, end='',flush=True)
log.write("\n")
#log.write(message)
#log.write("\n")
return [losses.avg,f1.avg]
def evaluate(split, verbose=False, n_batches=None):
'''
Compute loss on val or test data.
'''
model.eval()
loss = 0
acc = 0
correct = 0
n_examples = 0
if split == 'val':
loader = val_loader
elif split == 'test':
loader = test_loader
for batch_i, batch in enumerate(loader):
data, target = batch
if args.cuda:
data, target = data.cuda(), target.cuda()
data, target = Variable(data, volatile=True), Variable(target)
output = model(data)
loss += criterion(output, target).item()
acc += (np.sum(output.cpu().data.numpy()[target.cpu().data.numpy()!=0] > 0.5) \
+ np.sum(output.cpu().data.numpy()[target.cpu().data.numpy()==0] < 0.5)) / float(args.im_size[1]*args.im_size[2])
n_examples += output.size(0)
if n_batches and (batch_i == n_batches-1):
break
loss /= n_examples
acc /= n_examples
return loss, acc
def test(test_loader, model, folds):
# 3.1 confirm the model converted to cuda
csv_map = OrderedDict({"filename": [], "probability": []})
model.cuda()
model.eval()
for i, (input, filepath) in enumerate(tqdm(test_loader)):
# 3.2 change everything to cuda and get only basename
filepath = [os.path.basename(x) for x in filepath]
with torch.no_grad():
image_var = Variable(input).cuda()
# 3.3.output
# print(filepath)
# print(input,input.shape)
y_pred = model(image_var)
print(y_pred.shape)
smax = nn.Softmax(1)
smax_out = smax(y_pred)
# 3.4 save probability to csv files
csv_map["filename"].extend(filepath)
for output in smax_out:
prob = ";".join([str(i) for i in output.data.tolist()])
csv_map["probability"].append(prob)
result = pd.DataFrame(csv_map)
result["probability"] = result["probability"].map(
lambda x: [float(i) for i in x.split(";")])
result.to_csv("./submit/{}_submission.csv".format(config.model_name + "_" +
str(folds)),
index=False,
header=None)
def eval(model, dataLoader_valid):
with torch.no_grad():
model.eval()
model.mode = 'valid'
valid_loss, index_valid= 0, 0
top1, top3, map3 = 0,0,0
for valid_data in dataLoader_valid:
images, labels = valid_data
images = images.cuda()
labels = labels.cuda()
results = model(images)
top1_, top3_ = accuracy(results, labels, topk=(1,3))
map3_ = mapk(labels, results, k=3)
model.getLoss(results,labels)
valid_loss += model.loss.data.cpu().numpy()
top1 += top1_
top3 += top3_
map3 += map3_
index_valid += 1
valid_loss /= index_valid
top1 /= index_valid
top3 /= index_valid
map3 /= index_valid
return valid_loss, top1, top3, map3
def valid(model, criterion,converter, device, datasets, dataset_names):
print('start evaluate')
accs = {}
losses = {}
dataloaders = {}
batch_dict = {'print_word': 48, 'hand_num': 52, 'print_num': 48, 'symbol': 88, 'hand_word': 64, 'seal': 64, 'catword': 48}
for dataset_name in dataset_names:
dataset = datasets.get(dataset_name)
dataloader = DataLoader(dataset, batch_size=batch_dict.get(dataset_name),
shuffle=True, num_workers=0, drop_last=False)
dataloaders[dataset_name] = dataloader
model.eval()
with torch.no_grad():
for dataset_name in dataset_names:
all_cnt = 0
n_correct = 0
total_loss = 0
total_cnt = 0
dataloader = dataloaders.get(dataset_name)
for img, label, img_names in dataloader:
total_cnt += 1
img = img.to(device)
batch_size = img.size(0)
all_cnt += batch_size
text, length = converter.encode(label)
preds = model(img)
preds_size = torch.IntTensor([preds.size(0)]*batch_size)
preds = preds.to('cpu')
text, length = text.to('cpu'), length.to('cpu')
loss = criterion(preds, text, preds_size, length)
total_loss += loss.item()
_, preds = preds.max(2)
preds = preds.transpose(1, 0).contiguous().view(-1)
sim_preds = converter.decode(preds.data, preds_size.data, raw=False)
list1 = [x for x in label]
for pred, target, img_name in zip(sim_preds, list1, img_names):
if pred == target:
n_correct += 1
#else:
#print(img_name + ' label:' + target + ' pred:' + pred)
#img_path = os.path.join('/home/chen-ubuntu/Desktop/checks_dataset/merge2/Image/', img_name)
#image = Image.open(img_path)
#image.save('test/' + img_name + "_" + target + "_" + pred + ".jpg")
acc = n_correct/all_cnt
loss = total_loss/total_cnt
accs[dataset_name] = acc
losses[dataset_name] = loss
print("dataset: {}, acc: {}, loss: {}".format(dataset_name, acc, loss))
print('imgs count: {}, correct: {}'.format(all_cnt, n_correct))
return accs, losses
def evaluate(split, verbose=False, n_batches=None):
'''
Compute loss on val or test data.
'''
model.eval()
loss = 0
acc = 0
correct = 0
n_examples = 0
if split == 'val':
loader = val_loader
#loader = train_loader
elif split == 'test':
loader = test_loader
for batch_i, batch in enumerate(loader):
data, target = batch
if args.cuda:
data, target = data.cuda(), target.cuda()
data, target = Variable(data, volatile=True), Variable(target)
output = model(data)
loss += criterion(output, target).item()
acc += (np.sum(output.cpu().data.numpy()[target.cpu().data.numpy()!=0] > 0.5) \
+ np.sum(output.cpu().data.numpy()[target.cpu().data.numpy()==0] < 0.5)) / float(args.im_size[1]*args.im_size[2])
n_examples += output.size(0)
if n_batches and (batch_i == n_batches - 1):
break
loss /= n_examples
acc /= n_examples
return loss, acc
def predict_tf(img, nb_filters, nb_conv, batch_size, wpath, spath):
"""
the cnn model for image transformation
Parameters
----------
img : array
The image need to be calculated
Returns
-------
y_img
Description.
"""
img = nor_data(img)
pn, iy, ix = img.shape
mdl = model(iy, ix, nb_filters, nb_conv)
mdl.load_weights(wpath)
for i in range(pn):
print('Processing the %s th projection' % i)
tstart = time.time()
x_img = img[i]
x_img = np.reshape(x_img, (1, iy, ix, 1))
y_img = mdl.predict(x_img, batch_size=batch_size)
y_img = np.reshape(y_img, (iy, ix))
fname = spath + 'prj-' + str(i)
dxchange.write_tiff(y_img, fname, dtype='float32')
print('The prediction runs for %s seconds' % (time.time() - tstart))
def test(model, dataset=None, compute_metric=True):
model.eval()
if dataset:
test_loader = dataset
else:
time.sleep(0.5)
print("Loading test data...")
time.sleep(0.5)
test_loader = TwitterDataset(test_file,
cache_size=20000000,
use_user_info=use_user_info)
time.sleep(0.5)
print("Testing...")
time.sleep(0.5)
pred = []
gt = []
with torch.no_grad():
for x, y in test_loader:
if compute_metric:
gt.extend(y.numpy())
pred.extend(model(x).squeeze().cpu().numpy())
if make_average:
pred = [sum(pred) / len(pred)] * len(pred)
if not compute_metric:
return pred
pred = np.array(pred, dtype=np.float64)
ce = log_loss(gt, pred)
prauc = compute_prauc(pred, gt)
rce = compute_rce(pred, gt)
return ce, prauc, rce
def train_running():
with tf.name_scope('input'):
train_batch, train_label_batch, _ = input_data.get_batch(train_txt, IMG_W, IMG_H, BATCH_SIZE, CAPACITY)
val_batch, val_label_batch, _ = input_data.get_batch(val_txt, IMG_W, IMG_H, BATCH_SIZE, CAPACITY)
x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3])
y_ = tf.placeholder(tf.int32, shape=[BATCH_SIZE])
model = models.model(x, N_CLASSES)
model.AlexNet()
logits = model.fc3
loss = tools.loss(logits, y_)
acc = tools.accuracy(logits, y_)
train_op = tools.optimize(loss, LEARNING_RATE)
with tf.Session() as sess:
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
summary_op = tf.summary.merge_all()
train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph)
val_writer = tf.summary.FileWriter(logs_val_dir, sess.graph)
try:
for step in np.arange(MAX_STEP):
if coord.should_stop():
break
tra_images, tra_labels = sess.run([train_batch, train_label_batch])
_, tra_loss, tra_acc = sess.run([train_op, loss, acc],
feed_dict={x: tra_images, y_: tra_labels})
if step % 50 == 0:
print('Step %d, train loss = %.4f, train accuracy = %.2f%%' % (step, tra_loss, tra_acc))
summary_str = sess.run(summary_op, feed_dict={x: tra_images, y_: tra_labels})
train_writer.add_summary(summary_str, step)
#
if step % 200 == 0 or (step + 1) == MAX_STEP:
val_images, val_labels = sess.run([val_batch, val_label_batch])
val_loss, val_acc = sess.run([loss, acc],
feed_dict={x: val_images, y_: val_labels})
print('** Step %d, val loss = %.4f, val accuracy = %.2f%% **' % (step, val_loss, val_acc))
summary_str = sess.run(summary_op, feed_dict={x: val_images, y_: val_labels})
val_writer.add_summary(summary_str, step)
#
if step % 2000 == 0 or (step + 1) == MAX_STEP:
checkpoint_path = os.path.join(model_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
except tf.errors.OutOfRangeError:
print('Done training -- epoch limit reached')
finally:
coord.request_stop()
coord.join(threads)
def train():
# Turn on training mode which enables dropout.
total_loss = 0
begin_t = time.time()
#ntokens = len(corpus.dictionary)
hidden = model.init_hidden(BATCH_SIZE)
batch, i = 0, 0
while i < train_data.size(0) - 1 - 1:
bptt = BPTT if np.random.random() < 0.95 else BPTT / 2.
# Prevent excessively small or negative sequence lengths
seq_len = max(5, int(np.random.normal(bptt, 5)))
# There's a very small chance that it could select a very long sequence length resulting in OOM
# seq_len = min(seq_len, args.bptt + 10)
lr2 = optimizer.param_groups[0]['lr']
optimizer.param_groups[0]['lr'] = lr2 * seq_len / BPTT
model.train()
data, targets = batching.get_batch(train_data, i, seq_len=seq_len)
# Starting each batch, we detach the hidden state from how it was previously produced.
# If we didn't, the model would try backpropagating all the way to start of the dataset.
hidden = repackage_hidden(hidden)
optimizer.zero_grad()
output, hidden, rnn_hs, dropped_rnn_hs = model(data,
hidden,
return_h=True)
raw_loss = criterion(output.view(-1, num_tokens), targets)
loss = raw_loss
# Activiation Regularization
loss = loss + sum(ALPHA * dropped_rnn_h.pow(2).mean()
for dropped_rnn_h in dropped_rnn_hs[-1:])
# Temporal Activation Regularization (slowness)
loss = loss + sum(BETA * (rnn_h[1:] - rnn_h[:-1]).pow(2).mean()
for rnn_h in rnn_hs[-1:])
loss.backward()
# `clip_grad_norm` helps prevent the exploding gradient problem in RNNs / LSTMs.
torch.nn.utils.clip_grad_norm(model.parameters(), CLIP_GRADIENTS)
optimizer.step()
total_loss += raw_loss.data
optimizer.param_groups[0]['lr'] = lr2
if batch % DEUBG_LOG_INTERVAL == 0 and batch > 0:
cur_loss = total_loss[0] / DEUBG_LOG_INTERVAL
elapsed = time.time() - start_time
print(
'| epoch {:3d} | {:5d}/{:5d} batches | lr {:02.2f} | ms/batch {:5.2f} | '
'loss {:5.2f} | ppl {:8.2f}'.format(
epoch, batch,
len(train_data) // BPTT, optimizer.param_groups[0]['lr'],
elapsed * 1000 / DEUBG_LOG_INTERVAL, cur_loss,
math.exp(cur_loss)))
total_loss = 0
start_time = time.time()
###
batch += 1
i += seq_len
def evaluate(model, dev_set):
model.eval()
total_loss = 0
batch_x, batch_t, batch_y1, batch_y2 = [], [], [], []
y1_true, y2_true = [], []
label_predictions, gender_predictions = [], []
with torch.no_grad():
for i in range(len(dev_set)):
batch_x.append(dev_set[i]['tokenized'])
batch_t.append(dev_set[i]['DM'])
batch_y1.append(dev_set[i]['y1'])
batch_y2.append(dev_set[i]['y2'])
y1_true.append(C.label2idx[dev_set[i]['label']])
y2_true.append(C.gen2idx[dev_set[i]['gen']])
if len(batch_x) == batch_size or i == len(dev_set) - 1:
mask = masking(batch_x)
padded = pad_features(batch_x)
batch_emoj = np.array(batch_t, dtype='uint16')
batch_emoj = torch.from_numpy(
batch_emoj.astype('int64')).long()
# out = model(torch.tensor(padded).cuda(), batch_emoj.cuda(), torch.tensor(mask).cuda())
out = model(
torch.tensor(padded).cuda(),
torch.tensor(mask).cuda())
y_pred1 = out['y_pred1'].cpu()
y_pred2 = out['y_pred2'].cpu()
label_predictions.extend(
list(torch.argmax(y_pred1, -1).numpy()))
gender_predictions.extend(
list(torch.argmax(y_pred2, -1).numpy()))
loss = F.binary_cross_entropy(y_pred1, torch.Tensor(batch_y1), weight=class_weights1) + \
F.binary_cross_entropy(y_pred2, torch.Tensor(batch_y2), weight=class_weights2)
total_loss += loss.item()
batch_x, batch_t, batch_y1, batch_y2 = [], [], [], []
macro_f1_1 = f1_score(y1_true, label_predictions, average='macro')
macro_f1_2 = f1_score(y2_true, gender_predictions, average='macro')
return label_predictions, \
gender_predictions, \
total_loss/len(dev_set), \
macro_f1_1,\
macro_f1_2
def __init__(self, options=None):
self.ID = -1
self.options = options
if self.options is None:
self.options = KTreeOptions()
# self.model provides all metric related functions:
self.model = models.model(self.options)
# root node of tree:
self.root = self.new_root()
def __init__(self, options=None, model=None, parent=None):
global ID
ID += 1
self.ID = ID
# TODO: look up options in parent node?
self.options = options
if self.options is None:
self.options = KTreeOptions()
self.model = model
if self.model is None:
self.model = models.model(self.options)
self.parent = parent
def train(epoch):
iters = []
lrs = []
train_losses = []
val_losses = []
val_accuracies = []
model.train()
# train loop
for batch_idx, batch in enumerate(train_loader):
# prepare data
images = Variable(batch[0])
targets = Variable(batch[1])
if args.cuda:
images, targets = images.cuda(), targets.cuda()
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, targets)
loss.backward()
optimizer.step()
if args.vis and batch_idx % args.log_interval == 0 and images.shape[0] == 1:
cv2.imshow('output: ', outputs.cpu().data.numpy()[0][0])
cv2.imshow('target: ', targets.cpu().data.numpy()[0][0])
cv2.waitKey(10)
# Learning rate decay.
if epoch % args.step_interval == 0 and epoch != 1 and batch_idx == 0:
if args.lr_decay != 1:
global lr, optimizer
lr *= args.lr_decay
for param_group in optimizer.param_groups:
param_group['lr'] = lr
print('Learning rate decayed to %f.' % lr)
if batch_idx % args.log_interval == 0:
val_loss, val_acc = evaluate('val', n_batches=80)
train_loss = loss.item()
iters.append(len(train_loader.dataset)*(epoch-1)+batch_idx)
lrs.append(lr)
train_losses.append(train_loss)
val_losses.append(val_loss)
val_accuracies.append(val_acc)
examples_this_epoch = batch_idx * len(images)
epoch_progress = 100. * batch_idx / len(train_loader)
print('Train Epoch: {} [{}/{} ({:.0f}%)]\t'
'Train Loss: {:.6f}\tVal Loss: {:.6f}\tVal Acc: {}'.format(
epoch, examples_this_epoch, len(train_loader.dataset),
epoch_progress, train_loss, val_loss, val_acc))
return iters, train_losses, val_losses, val_accuracies
from models import gaussian as model
import numpy as np
import matplotlib.pyplot as plt
from palettable import colorbrewer
#plt.rcParams['image.cmap'] = colorbrewer.sequential.Blues_9.mpl_colormap
cmap = colorbrewer.sequential.Blues_9.mpl_colormap
if __name__ == "__main__":
nx,dx = 32, 2.
flux = 3.
fwhm = 37.
p = 0.052
m = model(flux,fwhm,p,nx,dx)
# plot model
psi = np.arctan(m.U/m.Q)/2.
plt.imshow(m.I,cmap=cmap)
plt.quiver(np.cos(psi)*m.I,np.sin(m.I),headwidth=0)
#plt.ion()
plt.show()
image_shape = (X_train.shape[2], X_train.shape[3], 1)
X = None
Y = None
## TODO: when finished, train with all dataset!!
sinkhorn_on = False
weight_decay = 0.005
dropout = 0.3
initial_lr = 0.0001
epochs = 30
batch_size = 64
model = model(tiles_per_dim, image_shape, sinkhorn_on, weight_decay, dropout)
sgd = keras.optimizers.SGD(lr=initial_lr, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy',
optimizer=keras.optimizers.Adam(lr=initial_lr),
metrics=['accuracy'])
print(model.summary())
datagen = data_generator(X_train, y_train, batch_size=batch_size)
vdatagen = data_generator(X_test, y_test, batch_size=batch_size)
history = model.fit_generator(generator=datagen,
steps_per_epoch=X_train.shape[0] // batch_size,
validation_data=vdatagen,
validation_steps=X_test.shape[0] // batch_size,
epochs=epochs,
callbacks=[LearningRateScheduler(schedule)])
