def train(student_list,
feature_list,
start_epoch=0,
epochs=10,
resume_frm_chck_pt=True,
force_save_model=False,
reset_optimizer_state=False,
restrict_seqlen=4,
train_model=True):
# Getting inputs and extracting the input size list.
data = get_inputs(student_list=student_list, feature_list=feature_list,restrict_seqlen=restrict_seqlen)
input_size_list = data[0][1]
print("Number of GPUs: {}".format(torch.cuda.device_count()))
if not train_model:
print("Not in Train Mode")
return
print("Force-Saving is set to {}".format(force_save_model))
print("######################################################")
# Trains on all students in the data list.
print("################# No. of Students: {} #################".format(len(data)))
for counter, split in enumerate(kfold.get_splits(data)):
print("################# Training Split : {} #################".format(counter))
train_set_list, val_set = split
val_score = []
# Declaring Network.
net = Strain_log_regression(input_size_list=input_size_list)
optimizer = optim.Adam(net.parameters(), weight_decay=0.01)
net.apply(weights_init)
val_soft = torch.nn.Softmax(dim=1)
criterion = nn.CrossEntropyLoss(size_average=True)
best_score = Variable(torch.from_numpy(np.array([0])).float())
file_name = ROOT_DIR + '/output/loso/loso_model_{}.tar'.format(counter)
if torch.cuda.device_count() > 1:
print("Using {} GPUs".format(torch.cuda.device_count()))
net = nn.DataParallel(net)
if torch.cuda.is_available():
print("Training on GPU")
net = net.cuda()
best_score = best_score.cuda()
if resume_frm_chck_pt:
model_state, optimizer_state, start_epoch, best_score = chck.load_checkpoint(file_name)
net.load_state_dict(model_state)
optimizer.load_state_dict(optimizer_state)
if reset_optimizer_state:
optimizer = optim.Adam(net.parameters(), weight_decay=0.01)
for epoch in range(epochs):
print("###################### Epoch {} #######################".format(start_epoch + epoch + 1))
for input_list, _, index_list, target in train_set_list:
net.train(True)
optimizer.zero_grad()
y_hat = net.forward(input_list, index_list)
loss = criterion(y_hat, target)
loss.backward()
optimizer.step()
######################## Validating ########################
val_input_list, _, val_index_list, y_true = val_set
net.eval()
y_pred = net.forward(val_input_list, val_index_list)
y_pred = val_soft(y_pred)
_, y_pred = y_pred.max(1)
accuracy = y_true.eq(y_pred).sum()
accuracy = accuracy.float() / len(y_true)
# val_score.append(accuracy)
if torch.gt(accuracy, best_score).all():
best_score = accuracy
is_best = True
else:
is_best = False
# force save model without it being the best accuracy.
if force_save_model:
is_best = True
# generating states. Saving checkpoint after every epoch.
state = chck.create_state(net, optimizer, epoch, start_epoch, best_score)
chck.save_checkpoint(state, is_best, full_file_name=file_name)
print("=> loss of '{}' at epoch {} \n=> accuracy of \n {}".format(loss.data[0], start_epoch + epoch + 1,
accuracy))
val_score.append(best_score)
avg_score = sum(val_score) / len(val_score)
print("######################################################")
print("Loso CrossVal Score :", avg_score)
print("######################################################")
def train(start_epoch=0,
epochs=10,
resume_frm_chck_pt=True,
force_save_model=False,
reset_optimizer_state=False,
restrict_seqlen=4,
train_model=True):
# getting current working directory initialize checkpoint file name.
cwd = os.getcwd()
file_name = cwd + '/output/log_reg.tar'
# Getting inputs.
input_list, input_size_list, index_list, target, val_input_list, val_index_list, y_true \
= get_inputs(restrict_seqlen=restrict_seqlen)
# Initializing Best_Accuracy as 0
best_accuracy = Variable(torch.from_numpy(np.array([0])).float())
print("Force-Saving is set to {}".format(force_save_model))
if not train_model:
return
# declaring Network.
net = Strain_log_regression(input_size_list=input_size_list)
# Using default learning rate for Adam.
optimizer = optim.Adam(net.parameters(), weight_decay=0.01)
net.apply(weights_init)
val_soft = torch.nn.Softmax(dim=1)
criterion = nn.CrossEntropyLoss(size_average=True)
if torch.cuda.device_count() > 1:
print("Using {} GPUs".format(torch.cuda.device_count()))
net = nn.DataParallel(net)
if torch.cuda.is_available():
print("Training on GPU")
net = net.cuda()
best_accuracy = best_accuracy.cuda()
if resume_frm_chck_pt:
model_state, optimizer_state, start_epoch, best_accuracy = chck.load_checkpoint(file_name)
net.load_state_dict(model_state)
optimizer.load_state_dict(optimizer_state)
if reset_optimizer_state:
optimizer = optim.Adam(net.parameters(), weight_decay=0.01)
print("######################################################")
print("Start Epoch :", start_epoch)
# Train the network
for epoch in range(epochs):
print("###################### Epoch {} #######################".format(start_epoch + epoch + 1))
net.train(True)
optimizer.zero_grad()
y_hat = net.forward(input_list, index_list)
loss = criterion(y_hat, target)
loss.backward()
optimizer.step()
######################## Validating ########################
net.eval()
y_pred = net.forward(val_input_list, val_index_list)
y_pred = val_soft(y_pred)
# y_pred = y_pred.data.numpy().argmax(axis=1)
# accuracy = accuracy_score(y_true, y_pred)
_, y_pred = y_pred.max(1)
accuracy = y_true.eq(y_pred).sum()
accuracy = accuracy.float() / len(y_true)
# print(type(accuracy), type(best_accuracy))
# print("best accuracy {} accuracy {}".format(best_accuracy, accuracy))
if torch.gt(accuracy, best_accuracy).all():
best_accuracy = accuracy
is_best = True
else:
is_best = False
# print("Y_pred {}".format(y_pred))
# print("Y_true {}".format(y_true))
# force save model without it being the best accuracy.
if force_save_model:
is_best = True
# generating states. Saving checkpoint after every epoch.
state = chck.create_state(net, optimizer, epoch, start_epoch, accuracy)
chck.save_checkpoint(state, is_best, full_file_name=file_name)
print("=> loss of '{}' at epoch {} \n=> accuracy of {}".format(loss.data[0], start_epoch + epoch + 1, accuracy))
print("######################################################")
print("Best Accuracy :", best_accuracy)
print("######################################################")
def train(start_epoch=0,
epochs=10,
resume_frm_chck_pt=True,
force_save_model=False,
reset_optimizer_state=False,
restrict_seqlen=4):
# getting current working directory initialize checkpoint file name.
cwd = os.getcwd()
file_name = cwd + '/output/linear_reg.tar'
# Getting inputs.
input_list, input_size_list, index_list, target, val_input_list, val_index_list, y_true \
= get_inputs(restrict_seqlen=restrict_seqlen, standardize=True)
target = target.float()
y_true = y_true.float()
# Initializing Best_mse as 0
best_mse = Variable(torch.from_numpy(np.array([100000000000])).float())
print("Force-Saving is set to {}".format(force_save_model))
if not train:
return
# declaring Network.
net = Strain_linear_reg(input_size_list=input_size_list)
# Using default learning rate for Adam.
optimizer = optim.Adam(net.parameters(), weight_decay=0.01)
net.apply(weights_init)
criterion = nn.MSELoss()
if torch.cuda.device_count() > 1:
print("Using {} GPUs".format(torch.cuda.device_count()))
net = nn.DataParallel(net)
if torch.cuda.is_available():
print("Training on GPU")
net = net.cuda()
best_mse = best_mse.cuda()
if resume_frm_chck_pt:
model_state, optimizer_state, start_epoch, best_mse = chck.load_checkpoint(
file_name)
net.load_state_dict(model_state)
optimizer.load_state_dict(optimizer_state)
if reset_optimizer_state:
optimizer = optim.Adam(net.parameters(), weight_decay=0.01)
print("######################################################")
print("Start Epoch :", start_epoch)
# Train the network
for epoch in range(epochs):
print("###################### Epoch {} #######################".format(
start_epoch + epoch + 1))
net.train(True)
optimizer.zero_grad()
y_hat = net.forward(input_list, index_list)
loss = criterion(y_hat, target)
print("working till here")
loss.backward()
optimizer.step()
######################## Validating ########################
net.eval()
y_pred = net.forward(val_input_list, val_index_list)
mse = criterion(y_pred, y_true)
if torch.lt(mse, best_mse).all():
best_mse = mse
is_best = True
else:
is_best = False
print("Y_pred {}".format(y_pred))
print("Y_true {}".format(y_true))
# force save model without it being the best MSE.
if force_save_model:
is_best = True
# generating states. Saving checkpoint after every epoch.
state = chck.create_state(net, optimizer, epoch, start_epoch, mse)
chck.save_checkpoint(state, is_best, full_file_name=file_name)
print("=> loss of '{}' at epoch {} \n=> mse of {}".format(
loss.data[0], start_epoch + epoch + 1, mse))
print("######################################################")
print("Best MSE :", best_mse)
print("######################################################")
def train(start_epoch=0,
epochs=10,
resume_frm_chck_pt=True,
force_save_model=False,
reset_optimizer_state=False,
restrict_seqlen=4,
train=True):
feature_list = [
"activity_details",
# "dinning_details" ,
"sms_details",
"audio_details",
"conversation_details",
"dark_details",
"phonecharge_details",
"phonelock_details",
"gps_details"
]
# getting current working directory initialize checkpoint file name.
cwd = os.getcwd()
file_name = cwd + '/output/baseline.tar'
# Getting inputs.
train_input_seq, train_target, val_input_seq, val_target \
= generate_baseline_variables(feature_list=feature_list)
# squeezing dimensions in target sets.
train_target = train_target.squeeze(1)
val_target = val_target.squeeze(1)
# Extracting shape of input to initilize network.
x, y = train_input_seq.shape
print("Initializing net with {} - y features and {} - x".format(y, x))
# Initializing Best_Accuracy as 0
best_accuracy = Variable(torch.from_numpy(np.array([0])).float())
print("Force-Saving is set to {}".format(force_save_model))
# declaring Network with number of features.
net = StrainBaseline(y)
# Using default learning rate for Adam.
optimizer = optim.Adam(net.parameters(), weight_decay=0.01)
net.apply(weights_init)
val_soft = torch.nn.Softmax(dim=1)
criterion = nn.CrossEntropyLoss(size_average=True)
if not train:
return
if torch.cuda.device_count() > 1:
print("Using {} GPUs".format(torch.cuda.device_count()))
net = nn.DataParallel(net)
if torch.cuda.is_available():
print("Training on GPU")
net = net.cuda()
best_accuracy = best_accuracy.cuda()
if resume_frm_chck_pt:
model_state, optimizer_state, start_epoch, best_accuracy = chck.load_checkpoint(
file_name)
net.load_state_dict(model_state)
optimizer.load_state_dict(optimizer_state)
if reset_optimizer_state:
optimizer = optim.Adam(net.parameters(), weight_decay=0.01)
print("######################################################")
print("Start Epoch :", start_epoch)
# Train the network
for epoch in range(epochs):
print("###################### Epoch {} #######################".format(
start_epoch + epoch + 1))
net.train(True)
optimizer.zero_grad()
y_hat = net.forward(train_input_seq)
loss = criterion(y_hat, train_target)
loss.backward()
optimizer.step()
######################## Validating ########################
net.eval()
y_pred = net.forward(val_input_seq)
y_pred = val_soft(y_pred)
_, y_pred = y_pred.max(1)
accuracy = val_target.eq(y_pred).sum()
accuracy = accuracy.float() / len(val_target)
if torch.gt(accuracy, best_accuracy).all():
best_accuracy = accuracy
is_best = True
else:
is_best = False
# Force save model if flag is true.
if force_save_model:
is_best = True
# generating states. Saving checkpoint after every epoch.
state = chck.create_state(net, optimizer, epoch, start_epoch, accuracy)
chck.save_checkpoint(state, is_best, full_file_name=file_name)
print("=> loss of '{}' at epoch {} \n=> accuracy of {}".format(
loss.data[0], start_epoch + epoch + 1, accuracy))
print("######################################################")
print("Best Accuracy :", best_accuracy)
print("######################################################")
# Initializing Best_Accuracy as 0
best_accuracy = Variable(torch.from_numpy(np.array([0])).float())
print("Force-Saving is set to {}".format(force_save_model))