def validation_loop(val_loader, network, epoch, parameters, timer_epoch):
"""
validation_loop do a loop over the validation set
:param val_loader: Dataloader which contains input and target of the validation dataset
:param network: Network that will be learned
:param epoch: Actual epoch of the program
:param parameters: List of parameters of the network
:param timer_epoch: The time since the beginning of the epoch
:return: The mean validation_error over the entire validation set. This function also save this error.
"""
# Validation_error contains the error on the validation set
validation_error = 0
# Save the error of the validation DataSet
for i, (x_val_batch, y_val_batch, _) in enumerate(val_loader):
if torch.cuda.is_available(): # TODO It is useless to creat a Variable for y
x_val_batch, y_val_batch = Variable(x_val_batch.cuda()), Variable(y_val_batch.cuda())
else:
x_val_batch, y_val_batch = Variable(x_val_batch), Variable(y_val_batch)
validation_error += Save_import.save_error(x=x_val_batch, y=y_val_batch,
network=network,
epoch=epoch,
set_type="validation",
parameters=parameters)
with open(parameters.path_print, 'a') as txtfile:
txtfile.write(
"\nEpoch : " + str(epoch) + ". Batch : " + str(i) + ".\nValidation error : " + str(
validation_error / (i + 1)) +
".\nTime total batch : " + Save_import.time_to_string(time.time() - timer_epoch) + "\n \n")
# Divide by the the number of element in the entire batch
return validation_error / (i + 1)
def batch_loop(optimizer, train_loader, network, epoch, parameters, timer_batch, timer_epoch, inter_union=None):
"""
:param optimizer: The optimiser that containt parameter of Adam optimizer
:param train_loader: Dataloader which contains input and target of the train dataset
:param network: Network that will be learned
:param epoch: Actual epoch of the program
:param parameters: List of parameters of the network
:param timer_batch: The time since the beginning of the batch
:param timer_epoch: The time since the beginning of the epoch
:return: Nothing but update the network and save the train error
"""
train_error = 0
# Loop over the mini-batch, the size of the mini match is define in the train_loader
for i, (x_batch, y_batch, _) in enumerate(train_loader):
# zero the gradient buffers
optimizer.zero_grad()
# Transform into Variable
if torch.cuda.is_available():
x_batch, y_batch = Variable(x_batch.cuda()), Variable(y_batch.cuda())
else:
x_batch, y_batch = Variable(x_batch), Variable(y_batch)
# Compute the forward function
y_batch_estimated = network(x_batch)
# Get the error
loss = Loss_Error.criterion(y_estimated=y_batch_estimated,
y=y_batch,
parameters=parameters,
global_IoU_modif=False)
# Compute the backward function
loss.backward()
# Does the update according to the optimizer define above
optimizer.step()
# Save error of the training DataSet
train_error += Save_import.save_error(x=x_batch, y=y_batch,
network=network,
epoch=epoch,
set_type="train",
parameters=parameters,
loss=loss,
y_estimated=y_batch_estimated)
# Similar to a "print" but in a textfile
with open(parameters.path_print, 'a') as txtfile:
txtfile.write(
"\nEpoch : " + str(epoch) + ". Batch : " + str(i) +
".\nTrain_Error : " + str(train_error / (i + 1)) +
"\n" + "Time batch : " + Save_import.time_to_string(time.time() - timer_batch) +
".\nTime total batch : " + Save_import.time_to_string(time.time() - timer_epoch) + "\n \n")
timer_batch = time.time()
return ()