def manual(strt):
testdata = strt.split('-')
i_ugy = int(testdata[0])
r_py = int(testdata[1])
r_r = int(testdata[2])
r_ds = int(testdata[3])
o_skill = int(testdata[4])
testdata2 = ['Unknown', r_py, r_r, r_ds, i_ugy, o_skill]
result, proba = m.final_model(testdata2)
if result == "Yes":
output = {
"Candidate_Info": {
"Python_rating": r_py,
"R_rating": r_r,
"Data_Science_Rating": r_ds,
"Passout_Year": i_ugy,
"Other_Skill_Scores": o_skill
},
"Selected": "Yes"
}
if result == "No":
output = {
"Candidate_Info": {
"Python_rating": r_py,
"R_rating": r_r,
"Data_Science_Rating": r_ds,
"Passout_Year": i_ugy,
"Other_Skill_Scores": o_skill
},
"Selected": "No"
}
return output
def get(self, i_ugy, rt, o_skill):
i_ugy = int(i_ugy)
rt = rt.split("-")
r_py = int(rt[0])
r_r = int(rt[1])
r_ds = int(rt[2])
o_skill = int(o_skill)
testdata2 = ['Unknown', r_py, r_r, r_ds, i_ugy, o_skill]
result, proba = m.final_model(testdata2)
if result == "Yes":
output = {
"Candidate_Info": {
"Python_rating": r_py,
"R_rating": r_r,
"Data_Science_Rating": r_ds,
"Passout_Year": i_ugy,
"Other_Skill_Scores": o_skill
},
"Selected": "Yes",
"Probability_Selection": 1 - proba[0]
}
if result == "No":
output = {
"Candidate_Info": {
"Python_rating": r_py,
"R_rating": r_r,
"Data_Science_Rating": r_ds,
"Passout_Year": i_ugy,
"Other_Skill_Scores": o_skill
},
"Selected": "No",
"Probability_Rejection": proba[0]
}
return output
def compare_methods(method):
# l1 norm: Bayesian optimization
print("Starting..")
start_time = time.time()
if method == "L1-BO":
paras = bo_parameter_serach(iters=15, norm="l1")
elif method == "L1-LP":
paras = l1_LP()
elif method == "L2-EX":
paras = l2_Exact()
elif method == "L2-BO":
paras = bo_parameter_serach(iters=15, norm="l1")
party_wise_result, seat_wise_result = final_model(paras[:12])
end_time = time.time()
print(end_time)
time_taken = end_time - start_time
acc_share = accuracy_share_wise(party_wise_result)
acc_seat = accuracy_seat_wise(seat_wise_result)
result = [method, acc_seat, acc_share, time_taken]
return result
def initialise():
# getting the first 10 models of the initial population
for i in range(model_pop):
models.append(final_model())
def main():
# initialise the models
net = model.final_model(c_out=classes, n_tiles=n_tiles, tile_size=resolution).double().to(device)
"""Dataset"""
train_loader_ = dataloader.Data_Loader(data_path, sampling=sampling, dataloader_type='train', crossvalidation=crossvalidation, classes=classes, transform=train_transform, n_tiles=n_tiles)
valid_loader_ = dataloader.Data_Loader(data_path, sampling=sampling, dataloader_type='valid', crossvalidation=crossvalidation, classes=classes, transform=valid_transform, n_tiles=n_tiles)
criterion = nn.CrossEntropyLoss(weight=torch.Tensor([1,gamma_]).double().to(device))
# criterion = nn.CrossEntropyLoss()
train_loader = DataLoader(train_loader_, batch_size=batch_size, shuffle=True, num_workers=1, drop_last=True)
valid_loader = DataLoader(valid_loader_, batch_size=batch_size, shuffle=False, num_workers=1)
loss_list_train_epoch = [None]
accuracy_list_train_epoch = [None]
epoch_data_list = [None]
loss_list_train = [None]
accuracy_list_train = [None]
index_data_list = [None]
loss_list_validation = [None]
accuracy_list_validation = [None]
accuracy_list_validation_0 = [None]
accuracy_list_validation_1 = [None]
loss_list_validation_index = [None]
epoch_old = 0
if args.restart_training == 'false':
checkpoint = torch.load(args.model_path, map_location=lambda storage, loc: storage)
pretrained_dict = checkpoint['model_state_dict']
model_dict = net.state_dict()
pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}
model_dict.update(pretrained_dict)
net.load_state_dict(model_dict)
# net.load_state_dict(checkpoint['model_state_dict'])
print('loaded')
if use_last_data is True:
if args.restart_training == 'false':
checkpoint = torch.load(args.model_path, map_location=lambda storage, loc: storage)
epoch_old = checkpoint['epochs']
if checkpoint['train_loss_list_epoch'][-1] == None:
loss_list_train = [None]
index_data_list = [None]
accuracy_list_train = [None]
accuracy_list_train_epoch = [None]
loss_list_train_epoch = [None]
epoch_data_list = [None]
else:
loss_list_train = checkpoint['train_loss_list']
index_data_list = checkpoint['train_loss_index']
accuracy_list_train = checkpoint['train_accuracy_list']
accuracy_list_train_epoch = checkpoint['train_accuracy_list_epoch']
loss_list_train_epoch = checkpoint['train_loss_list_epoch']
epoch_data_list = checkpoint['train_loss_index_epoch']
if checkpoint['valid_loss_list'][-1] == None:
loss_list_validation = [None]
loss_list_validation_index = [None]
accuracy_list_validation = [None]
accuracy_list_validation_0 = [None]
accuracy_list_validation_1 = [None]
else:
loss_list_validation = checkpoint['valid_loss_list']
loss_list_validation_index = checkpoint['valid_loss_index']
accuracy_list_validation = checkpoint['valid_accuracy_list']
accuracy_list_validation = checkpoint['valid_accuracy_list']
best_accuracy = np.max(accuracy_list_validation[1:])
accuracy_list_validation_0 = checkpoint['valid_accuracy_list_0']
accuracy_list_validation_1 = checkpoint['valid_accuracy_list_1']
if len(train_loader_.data_list)%batch_size ==0:
total_idx_train = len(train_loader_.data_list)//batch_size
else:
total_idx_train = len(train_loader_.data_list)//batch_size + 1
if len(valid_loader_.data_list)%batch_size ==0:
total_idx_valid = len(valid_loader_.data_list)//batch_size
else:
total_idx_valid = len(valid_loader_.data_list)//batch_size + 1
optimizer = optim.Adam(net.parameters(), lr=LR, betas=(0.9, 0.999))
# optimizer = optim.SGD(net.parameters(), lr=LR, momentum=0.9)
scheduler = torch.optim.lr_scheduler.OneCycleLR(
optimizer, max_lr=LR, div_factor=10, pct_start=1 / train_epoch, steps_per_epoch=len(train_loader), epochs=train_epoch)
for epoch in range(epoch_old, train_epoch):
epoch_loss = 0.0
epoch_accuracy = 0.0
train_count = 0
running_loss = 0.0
running_accuracy = 0.0
running_train_count = 0
net.train()
for idx, batch_images_label_list in enumerate(tqdm(train_loader)):
optimizer.zero_grad()
batch_images_input = batch_images_label_list[0].to(device)
batch_label_input = batch_images_label_list[1].to(device)
batch_final_label_input = batch_images_label_list[2].to(device)
output = net(batch_images_input)
loss = criterion(output, batch_label_input)
loss.backward()
optimizer.step()
scheduler.step()
epoch_loss += loss.item()*batch_images_input.shape[0]
train_count += batch_images_input.shape[0]
correct = np.where(np.argmax(output.cpu().detach().numpy(), axis=1)==batch_final_label_input.cpu().detach().numpy())[0].shape[0]
epoch_accuracy += correct
# running_accuracy += correct
loss_list_train_epoch.append(epoch_loss/train_count)
epoch_data_list.append(epoch+1)
accuracy_list_train_epoch.append(epoch_accuracy/train_count)
print('Epoch %d Training Loss: %.3f Accuracy: %.3f' % (epoch + 1, loss_list_train_epoch[-1], accuracy_list_train_epoch[-1]),' Time:',datetime.datetime.now() )
plt.plot(epoch_data_list[1:], loss_list_train_epoch[1:], label = "Training", color='red', marker='o', markerfacecolor='yellow', markersize=5)
plt.xlabel('Epoch')
plt.ylabel('Training Loss')
plt.savefig(plots_dir + '/train_plot_loss.png')
plt.clf()
plt.plot(epoch_data_list[1:], accuracy_list_train_epoch[1:], label = "Training", color='red', marker='o', markerfacecolor='yellow', markersize=5)
plt.xlabel('Epoch')
plt.ylabel('Training Accuracy')
plt.savefig(plots_dir + '/train_plot_accuracy.png')
plt.clf()
if (epoch+1) % save_every == 0:
print('Saving model at %d epoch' % (epoch + 1),' Time:',datetime.datetime.now()) # save every save_every mini_batch of data
torch.save({
'epochs': epoch+1,
'batchsize': batch_size,
'train_loss_list': loss_list_train,
'train_loss_list_epoch':loss_list_train_epoch,
'train_accuracy_list': accuracy_list_train,
'train_accuracy_list_epoch': accuracy_list_train_epoch,
'train_loss_index': index_data_list,
'train_loss_index_epoch': epoch_data_list,
'valid_loss_list': loss_list_validation,
'valid_accuracy_list': accuracy_list_validation,
'valid_accuracy_list_0': accuracy_list_validation_0,
'valid_accuracy_list_1': accuracy_list_validation_1,
'valid_loss_index': loss_list_validation_index,
'model_state_dict': net.state_dict(),
}, model_checkpoint_dir + '/model_%d.pth' % (epoch + 1))
if (epoch+1) % valid_every == 0:
net.eval()
optimizer.zero_grad()
total_loss_valid = 0.0
False_positive = 0.0
False_negative = 0.0
valid_accuracy_0=0.0
valid_accuracy_1=0.0
valid_count_0 = 0
valid_count_1 = 0
# prediction_raw_array = np.zeros((len(valid_loader.data_list),2))
ground_truth_array = np.zeros(len(valid_loader_.data_list))
for idx, batch_images_label_list in enumerate(tqdm(valid_loader)):
with torch.no_grad():
batch_images_input = batch_images_label_list[0].to(device)
batch_label_input = batch_images_label_list[1].to(device)
output = net(batch_images_input)
loss = criterion(output, batch_label_input)
total_loss_valid += loss.item()*batch_images_input.shape[0]
zero_label_index = np.where(batch_label_input.cpu().detach().numpy() == 0)[0]
one_label_index = np.where(batch_label_input.cpu().detach().numpy() == 1)[0]
valid_count_0 += zero_label_index.shape[0]
valid_count_1 += one_label_index.shape[0]
valid_accuracy_0 += np.where(np.argmax(output.cpu().detach().numpy()[zero_label_index], axis=1)==batch_label_input.cpu().detach().numpy()[zero_label_index])[0].shape[0]
valid_accuracy_1 += np.where(np.argmax(output.cpu().detach().numpy()[one_label_index], axis=1)==batch_label_input.cpu().detach().numpy()[one_label_index])[0].shape[0]
False_positive += np.where(np.argmax(output.cpu().detach().numpy()[zero_label_index], axis=1)!=batch_label_input.cpu().detach().numpy()[zero_label_index])[0].shape[0]
False_negative += np.where(np.argmax(output.cpu().detach().numpy()[one_label_index], axis=1)!=batch_label_input.cpu().detach().numpy()[one_label_index])[0].shape[0]
precision = valid_accuracy_1/(valid_accuracy_1 + False_positive + 1e-5)
recall = valid_accuracy_1/(valid_accuracy_1 + False_negative + 1e-5)
TNR = valid_accuracy_0/(valid_accuracy_0 + False_positive + 1e-5) #specificity
FPR = 1 - TNR
TPR = valid_accuracy_1/(valid_accuracy_1 + False_negative + 1e-5) # sensitivity/recall/TPR
F1_score = 2*precision*recall/(precision + recall + 1e-5)
valid_accuracy_0 = valid_accuracy_0/valid_count_0
valid_accuracy_1 = valid_accuracy_1/valid_count_1
valid_accuracy = (valid_accuracy_0 + valid_accuracy_1)/2
loss_list_validation.append(total_loss_valid / (valid_count_0 + valid_count_1))
loss_list_validation_index.append(epoch+1)
accuracy_list_validation.append(valid_accuracy)
accuracy_list_validation_0.append(valid_accuracy_0)
accuracy_list_validation_1.append(valid_accuracy_1)
print('Epoch %d Valid Loss: %.3f' % (epoch + 1, loss_list_validation[-1]),' Time:',datetime.datetime.now() )
print('Valid Accuracy: ', valid_accuracy, ' Valid Accuracy 0: ', valid_accuracy_0,' Valid Accuracy 1: ', valid_accuracy_1)
# print('Presicion: ',precision, ' Recall: ',recall, ' F1 Score: ', F1_score, ' TPR: ', TPR, ' TNR: ', TNR)
# if epoch >= 2:
plt.plot(loss_list_validation_index[1:], loss_list_validation[1:], label = "Validation", color='red', marker='o', markerfacecolor='yellow', markersize=5)
plt.xlabel('Epoch')
plt.ylabel('Validation Loss')
plt.savefig(plots_dir + '/valid_loss_plot.png')
plt.clf()
plt.plot(loss_list_validation_index[1:], accuracy_list_validation[1:], label = "Validation", color='red', marker='o', markerfacecolor='yellow', markersize=5)
plt.xlabel('Epoch')
plt.ylabel('Validation Accuracy')
plt.savefig(plots_dir + '/valid_accuracy_plot.png')
plt.clf()
plt.plot(loss_list_validation_index[1:], accuracy_list_validation_0[1:], label = "Validation", color='red', marker='o', markerfacecolor='yellow', markersize=5)
plt.xlabel('Epoch')
plt.ylabel('Validation Accuracy')
plt.savefig(plots_dir + '/valid_accuracy_plot_0.png')
plt.clf()
plt.plot(loss_list_validation_index[1:], accuracy_list_validation_1[1:], label = "Validation", color='red', marker='o', markerfacecolor='yellow', markersize=5)
plt.xlabel('Epoch')
plt.ylabel('Validation Accuracy')
plt.savefig(plots_dir + '/valid_accuracy_plot_1.png')
plt.clf()
if len(loss_list_validation) >= 3:
if accuracy_list_validation[-1] > best_accuracy:
best_accuracy = accuracy_list_validation[-1]
torch.save({
'epochs': epoch+1,
'batchsize': batch_size,
'train_loss_list': loss_list_train,
'train_loss_list_epoch':loss_list_train_epoch,
'train_accuracy_list': accuracy_list_train,
'train_accuracy_list_epoch': accuracy_list_train_epoch,
'train_loss_index': index_data_list,
'train_loss_index_epoch': epoch_data_list,
'valid_loss_list': loss_list_validation,
'valid_accuracy_list': accuracy_list_validation,
'valid_accuracy_list_0': accuracy_list_validation_0,
'valid_accuracy_list_1': accuracy_list_validation_1,
'valid_loss_index': loss_list_validation_index,
'model_state_dict': net.state_dict(),
}, model_checkpoint_dir + '/best_model.pth')
else:
best_accuracy = accuracy_list_validation[-1]
torch.save({
'epochs': epoch+1,
'batchsize': batch_size,
'train_loss_list': loss_list_train,
'train_loss_list_epoch':loss_list_train_epoch,
'train_accuracy_list': accuracy_list_train,
'train_accuracy_list_epoch': accuracy_list_train_epoch,
'train_loss_index': index_data_list,
'train_loss_index_epoch': epoch_data_list,
'valid_loss_list': loss_list_validation,
'valid_accuracy_list': accuracy_list_validation,
'valid_accuracy_list_0': accuracy_list_validation_0,
'valid_accuracy_list_1': accuracy_list_validation_1,
'valid_loss_index': loss_list_validation_index,
'model_state_dict': net.state_dict(),
}, model_checkpoint_dir + '/best_model.pth')
def home():
if (request.method == "POST"):
i_name = request.form.get("inp1")
i_mno = request.form.get("inp2")
i_ug = request.form.get("inp3")
try:
i_ugy = int(request.form.get("inp4"))
except:
# Assining the least year
i_ugy = 2018
i_pg = request.form.get("inp5")
try:
i_pgy = int(request.form.get("inp6"))
except:
# Assigning the least year
i_pgy = 2018
try:
r_py = int(request.form.get("rat1"))
except:
r_py = "0"
try:
r_r = int(request.form.get("rat2"))
except:
r_r = "0"
try:
r_ds = int(request.form.get("rat3"))
except:
r_ds = "0"
c_ml = request.form.get("chb1")
c_dl = request.form.get("chb2")
c_nlp = request.form.get("chb3")
c_sts = request.form.get("chb4")
c_aws = request.form.get("chb5")
c_sql = request.form.get("chb6")
c_excel = request.form.get("chb8")
print(i_name, i_mno, i_ug, i_ugy, i_pg, i_pgy, r_py, r_r, r_ds, c_ml,
c_dl, c_nlp, c_sts, c_aws, c_sql, c_excel)
testdata = [
'Unknown', r_py, r_r, r_ds,
max(i_ugy, i_pgy),
[c_ml, c_dl, c_nlp, c_sts, c_aws, c_sql, c_excel].count('on') * 3
]
print(testdata)
result = m.final_model(testdata)
print(result)
# overall_score = p.scoring(i_name,i_mno,i_ug,i_ugy,i_pg,i_pgy,r_py,r_r,r_ds,c_ml,c_dl,c_nlp,c_sts,c_aws,c_sql,c_excel)
# print(overall_score)
if result == "Yes":
output = Markup("""<div class="success">
<h3>Congratulations !</h3>
<span>Your profile has been shortlisted</span>
<span> for Data Scientist </span>
<a href="/"> <span class ="btn0">OK</span> </a>
</div>""")
if result == "No":
output = Markup("""
<div class="failure">
<h3>Sorry !</h3>
<span>Your profile did not qualify for</span>
<span> further discussion </span>
<a href="/"> <span class ="btn0">OK</span> </a>
</div>
""")
return render_template('index.html', output=output)
return render_template('index.html', output=" ")