def test_routine(cls, model_name, num_classes, criterion, epochs,
current_log_folder, writer, **kwargs):
"""
Load the best model according to the validation score (early stopping) and runs the test routine.
Parameters
----------
model_name : str
name of the model. Used for loading the model.
num_classes : int
How many different classes there are in our problem. Used for loading the model.
criterion : torch.nn.modules.loss
Loss function to use, e.g. cross-entropy
epochs : int
After how many epochs are we testing
current_log_folder : string
Path to where logs/checkpoints are saved
writer : Tensorboard.SummaryWriter
Responsible for writing logs in Tensorboard compatible format.
kwargs : dict
Any additional arguments.
Returns
-------
test_value : float
Accuracy value for test split
"""
# Load the best model before evaluating on the test set.
logging.info(
'Loading the best model before evaluating on the test set.')
if os.path.exists(
os.path.join(current_log_folder, 'model_best.pth.tar')):
kwargs["load_model"] = os.path.join(current_log_folder,
'model_best.pth.tar')
else:
logging.warning('File model_best.pth.tar not found in {}'.format(
current_log_folder))
logging.warning('Using checkpoint.pth.tar instead')
kwargs["load_model"] = os.path.join(current_log_folder,
'checkpoint.pth.tar')
model, _, _, _ = set_up_model(num_classes=num_classes,
model_name=model_name,
**kwargs)
# Test
test_value = cls._test(model=model,
criterion=criterion,
writer=writer,
epoch=epochs - 1,
**kwargs)
logging.info('Training completed')
return test_value
def prepare(cls, model_name, **kwargs):
"""
Loads and prepares the data, the optimizer and the criterion
Parameters
----------
model_name : str
Name of the model. Used for loading the model.
kwargs : dict
Any additional arguments.
Returns
-------
model : DataParallel
The model to train
num_classes : int
How many different classes there are in our problem. Used for loading the model.
best_value : float
Best value of the model so far. Non-zero only in case of --resume being used
train_loader : torch.utils.data.dataloader.DataLoader
Training dataloader
val_loader : torch.utils.data.dataloader.DataLoader
Validation dataloader
test_loader : torch.utils.data.dataloader.DataLoader
Test set dataloader
optimizer : torch.optim
Optimizer to use during training, e.g. SGD
criterion : torch.nn.modules.loss
Loss function to use, e.g. cross-entropy
"""
# Get the selected model input size
model_expected_input_size = models.__dict__[model_name](
).expected_input_size
if type(model_expected_input_size
) is not tuple or len(model_expected_input_size) != 2:
logging.error(
'Model {model_name} expected input size is not a tuple. '
'Received: {model_expected_input_size}'.format(
model_name=model_name,
model_expected_input_size=model_expected_input_size))
sys.exit(-1)
logging.info('Model {} expects input size of {}'.format(
model_name, model_expected_input_size))
# Setting up the dataloaders
train_loader, val_loader, test_loader, num_classes = set_up_dataloaders(
model_expected_input_size, **kwargs)
# Setting up model, optimizer, criterion
model, criterion, optimizer, best_value = set_up_model(
model_name=model_name, num_classes=num_classes, **kwargs)
return model, num_classes, best_value, train_loader, val_loader, test_loader, optimizer, criterion
def prepare(cls, model_name, **kwargs):
"""
See parent class for documentation
"""
# Setting up the dataloaders
train_loader, val_loader, test_loader = set_up_dataloaders(**kwargs)
cls.class_encoding = train_loader.dataset.class_encodings
cls.img_names_sizes_dict = dict(test_loader.dataset.img_names_sizes) # (gt_img_name, img_size (H, W))
# Setting up model, optimizer, criterion
model, criterion, optimizer, best_value = set_up_model(model_name=model_name,
num_classes=len(cls.class_encoding),
**kwargs)
return model, len(cls.class_encoding), best_value, train_loader, val_loader, test_loader, optimizer, criterion
def single_run(writer, current_log_folder, model_name, epochs, lr,
decay_lr, validation_interval, **kwargs):
"""
This is the main routine where train(), validate() and test() are called.
Parameters
----------
writer : Tensorboard.SummaryWriter
Responsible for writing logs in Tensorboard compatible format.
current_log_folder : string
Path to where logs/checkpoints are saved
model_name : string
Name of the model
epochs : int
Number of epochs to train
lr : float
Value for learning rate
kwargs : dict
Any additional arguments.
decay_lr : boolean
Decay the lr flag
validation_interval: int
Run evaluation on validation set every N epochs
Returns
-------
train_value : ndarray[floats]
Accuracy values for train
val_value : ndarray(1, `epochs`+1)
test_value : float
Precision values for train and validation splits. Single precision value for the test split.
"""
# Get the selected model input size
model_expected_input_size = models.__dict__[model_name](
).expected_input_size
RandomLabel._validate_model_input_size(model_expected_input_size,
model_name)
logging.info('Model {} expects input size of {}'.format(
model_name, model_expected_input_size))
# Setting up the dataloaders
train_loader, val_loader, test_loader, num_classes = set_up_dataloaders(
model_expected_input_size, **kwargs)
# Remove the "shuffle=True" for the train loader
train_loader.sampler = SequentialSampler(train_loader.dataset)
train_loader.batch_sampler = BatchSampler(train_loader.sampler,
train_loader.batch_size,
train_loader.drop_last)
# Setting up model, optimizer, criterion
model, criterion, optimizer, best_value, start_epoch = set_up_model(
num_classes=num_classes,
model_name=model_name,
lr=lr,
train_loader=train_loader,
**kwargs)
# Create an observer
observer, observer_criterion, observer_optimizer, _, _ = set_up_model(
num_classes=num_classes,
model_name='Observer',
lr=lr,
train_loader=train_loader,
**kwargs)
# Core routine
logging.info('Begin training')
val_value = np.zeros((epochs + 1 - start_epoch))
train_value = np.zeros((epochs - start_epoch))
val_value[-1] = RandomLabel._validate(val_loader, model, criterion,
observer, observer_criterion,
writer, -1, **kwargs)
for epoch in range(start_epoch, epochs):
# Train
train_value[epoch] = RandomLabel._train(train_loader, model,
criterion, optimizer,
observer,
observer_criterion,
observer_optimizer, writer,
epoch, **kwargs)
# Validate
if epoch % validation_interval == 0:
val_value[epoch] = RandomLabel._validate(
val_loader, model, criterion, observer, observer_criterion,
writer, epoch, **kwargs)
if decay_lr is not None:
adjust_learning_rate(lr=lr,
optimizer=optimizer,
epoch=epoch,
decay_lr_epochs=decay_lr)
best_value = checkpoint(epoch, val_value[epoch], best_value, model,
optimizer, current_log_folder)
# Test
test_value = RandomLabel._test(test_loader, model, criterion, observer,
observer_criterion, writer, epochs - 1,
**kwargs)
logging.info('Training completed')
return train_value, val_value, test_value
def single_run(writer, current_log_folder, model_name, epochs, lr, decay_lr,
validation_interval, checkpoint_all_epochs, **kwargs):
"""
This is the main routine where train(), validate() and test() are called.
Parameters
----------
writer : Tensorboard.SummaryWriter
Responsible for writing logs in Tensorboard compatible format.
current_log_folder : string
Path to where logs/checkpoints are saved
model_name : string
Name of the model
epochs : int
Number of epochs to train
lr : float
Value for learning rate
kwargs : dict
Any additional arguments.
decay_lr : boolean
Decay the lr flag
validation_interval : int
Run evaluation on validation set every N epochs
checkpoint_all_epochs : bool
If enabled, save checkpoint after every epoch.
Returns
-------
train_value : ndarray[floats] of size (1, `epochs`)
Accuracy values for train split
val_value : ndarray[floats] of size (1, `epochs`+1)
Accuracy values for validation split
test_value : float
Accuracy value for test split
"""
# Get the selected model input size
model_expected_input_size = models.__dict__[model_name]().expected_input_size
ImageClassification._validate_model_input_size(model_expected_input_size, model_name)
logging.info('Model {} expects input size of {}'.format(model_name, model_expected_input_size))
# Setting up the dataloaders
train_loader, val_loader, test_loader, num_classes = set_up_dataloaders(model_expected_input_size, **kwargs)
# Setting up model, optimizer, criterion
model, criterion, optimizer, best_value, start_epoch = set_up_model(num_classes=num_classes,
model_name=model_name,
lr=lr,
train_loader=train_loader,
**kwargs)
pytorch_total_params = sum(p.numel() for p in model.parameters())
logging.info('Total parameters: ' + str(pytorch_total_params))
pytorch_total_params_trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
logging.info('Total trainable parameters: ' + str(pytorch_total_params_trainable))
# Core routine
logging.info('Begin training')
val_value = np.zeros((epochs + 1 - start_epoch))
train_value = np.zeros((epochs - start_epoch))
val_value[-1] = ImageClassification._validate(val_loader, model, criterion, writer, -1, **kwargs)
for epoch in range(start_epoch, epochs):
# Train
train_value[epoch] = ImageClassification._train(train_loader, model, criterion, optimizer, writer, epoch,
**kwargs)
# Validate
if epoch % validation_interval == 0:
val_value[epoch] = ImageClassification._validate(val_loader, model, criterion, writer, epoch, **kwargs)
if decay_lr is not None:
adjust_learning_rate(lr=lr, optimizer=optimizer, epoch=epoch, decay_lr_epochs=decay_lr)
best_value = checkpoint(epoch=epoch, new_value=val_value[epoch],
best_value=best_value, model=model,
optimizer=optimizer,
log_dir=current_log_folder,
checkpoint_all_epochs=checkpoint_all_epochs)
# Load the best model before evaluating on the test set.
logging.info('Loading the best model before evaluating on the '
'test set.')
kwargs["load_model"] = os.path.join(current_log_folder,
'model_best.pth.tar')
model, _, _, _, _ = set_up_model(num_classes=num_classes,
model_name=model_name,
lr=lr,
train_loader=train_loader,
**kwargs)
# Test
test_value = ImageClassification._test(test_loader, model, criterion, writer, epochs - 1, **kwargs)
logging.info('Training completed')
return train_value, val_value, test_value
def single_run(writer, current_log_folder, model_name, epochs, lr, decay_lr, validation_interval, **kwargs):
"""
This is the main routine where train(), validate() and test() are called.
Parameters
----------
:param writer: Tensorboard SummaryWriter
Responsible for writing logs in Tensorboard compatible format.
:param current_log_folder: string
Path to where logs/checkpoints are saved
:param model_name: string
Name of the model
:param epochs: int
Number of epochs to train
:param lr: float
Value for learning rate
:param decay_lr: boolean
Decay the lr flag
:param validation_interval: int
Run evaluation on validation set every N epochs
:param kwargs: dict
Any additional arguments.
:return: train_value, val_value, test_value
Precision values for train and validation splits. Single precision value for the test split.
"""
# Get the selected model
model_expected_input_size = models.__dict__[model_name]().expected_input_size
Bidimensional._validate_model_input_size(model_expected_input_size, model_name)
logging.info('Model {} expects input size of {}'.format(model_name, model_expected_input_size))
# Setting up the dataloaders
train_loader, val_loader, test_loader, num_classes = set_up_dataloaders(model_expected_input_size, **kwargs)
# Setting up model, optimizer, criterion
model, criterion, optimizer, best_value, start_epoch = set_up_model(num_classes=num_classes,
model_name=model_name,
lr=lr,
train_loader=train_loader,
**kwargs)
# Core routine
logging.info('Begin training')
val_value = np.zeros((epochs + 1 - start_epoch))
train_value = np.zeros((epochs - start_epoch))
# Make data for points
grid_resolution = 100
mini_batches = np.array([input_mini_batch.numpy() for input_mini_batch, _ in val_loader])
val_coords = np.squeeze(np.array([sample for mini_batch in mini_batches for sample in mini_batch]))
min_x, min_y = np.min(val_coords[:, 0]), np.min(val_coords[:, 1])
max_x, max_y = np.max(val_coords[:, 0]), np.max(val_coords[:, 1])
coords = np.array([[x, y]
for x in np.linspace(min_x, max_x, grid_resolution)
for y in np.linspace(min_y, max_y, grid_resolution)
])
coords = torch.autograd.Variable(torch.from_numpy(coords).type(torch.FloatTensor))
if not kwargs['no_cuda']:
coords = coords.cuda(async=True)
# PLOT: decision boundary routine
Bidimensional._evaluate_and_plot_decision_boundary(model=model, val_coords=val_coords, coords=coords,
grid_resolution=grid_resolution, val_loader=val_loader,
num_classes=num_classes, writer=writer, epoch=-1, epochs=epochs,
**kwargs)
val_value[-1] = Bidimensional._validate(val_loader, model, criterion, writer, -1, **kwargs)
# Add model parameters to Tensorboard
for name, param in model.named_parameters():
writer.add_histogram(name + '_-1', param.clone().cpu().data.numpy(), -1, bins='auto')
for epoch in range(start_epoch, epochs):
# Train
train_value[epoch] = Bidimensional._train(train_loader, model, criterion, optimizer, writer, epoch, **kwargs)
# Validate
if epoch % validation_interval == 0:
val_value[epoch] = Bidimensional._validate(val_loader, model, criterion, writer, epoch, **kwargs)
if decay_lr is not None:
adjust_learning_rate(lr, optimizer, epoch, decay_lr)
best_value = checkpoint(epoch, val_value[epoch], best_value, model, optimizer, current_log_folder)
# PLOT: decision boundary routine
Bidimensional._evaluate_and_plot_decision_boundary(model=model, val_coords=val_coords, coords=coords,
grid_resolution=grid_resolution, val_loader=val_loader,
num_classes=num_classes, writer=writer, epoch=epoch, epochs=epochs,
**kwargs)
# Add model parameters to Tensorboard
for name, param in model.named_parameters():
writer.add_histogram(name + '_{}'.format(epoch), param.clone().cpu().data.numpy(), epoch, bins='auto')
# Test
test_value = Bidimensional._test(test_loader, model, criterion, writer, epochs, **kwargs)
logging.info('Training completed')
return train_value, val_value, test_value
def single_run(writer, current_log_folder, model_name, epochs, lr,
decay_lr, output_channels, classify, **kwargs):
"""
This is the main routine where train(), validate() and test() are called.
Parameters
----------
writer : Tensorboard.SummaryWriter
Responsible for writing logs in Tensorboard compatible format.
current_log_folder : string
Path to where logs/checkpoints are saved
model_name : string
Name of the model
epochs : int
Number of epochs to train
lr : float
Value for learning rate
kwargs : dict
Any additional arguments.
decay_lr : boolean
Decay the lr flag
validation_interval : int
Run evaluation on validation set every N epochs
checkpoint_all_epochs : bool
If enabled, save checkpoint after every epoch.
Returns
-------
train_value : ndarray[floats] of size (1, `epochs`)
Accuracy values for train split
val_value : ndarray[floats] of size (1, `epochs`+1)
Accuracy values for validation split
test_value : float
Accuracy value for test split
"""
CONFIG = {
'resnet152': {
'target_layer': 'layer4.2',
'input_size': 224
},
'vgg19': {
'target_layer': 'features.36',
'input_size': 224
},
'vgg19_bn': {
'target_layer': 'features.52',
'input_size': 224
},
'inception_v3': {
'target_layer': 'Mixed_7c',
'input_size': 299
},
'densenet201': {
'target_layer': 'features.denseblock4',
'input_size': 224
},
'alexnet': {
'target_layer': 'Convolutional_5',
'input_size': 227
},
'vgg16': {
'target_layer': 'features.30',
'input_size': 224
},
# Add your model
}.get(model_name)
device = torch.device('cpu')
# Get the selected model input size
model_expected_input_size = models.__dict__[model_name](
).expected_input_size
logging.info('Model {} expects input size of {}'.format(
model_name, model_expected_input_size))
# Setting up the dataloaders
data_loader, num_classes = set_up_dataloader(
model_expected_input_size=model_expected_input_size,
classify=classify,
**kwargs)
# Setting up model, optimizer, criterion
output_channels = num_classes if classify else output_channels
model, _, _, _, _ = set_up_model(output_channels=output_channels,
model_name=model_name,
lr=lr,
train_loader=None,
**kwargs)
# Synset words
classes = list()
with open('template/runner/my_task/samples/synset_words.txt') as lines:
for line in lines:
line = line.strip().split(' ', 1)[1]
line = line.split(', ', 1)[0].replace(' ', '_')
classes.append(line)
# Image
raw_image = cv2.imread('template/runner/my_task/uzorak/test_sl.png')[
..., ::-1]
raw_image = cv2.resize(raw_image, (CONFIG['input_size'], ) * 2)
image = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
)
])(raw_image).unsqueeze(0)
logging.info('Apply GradCAM to img')
# =========================================================================
#print('Grad-CAM')
# =========================================================================
gcam = GradCAM(model=model)
probs, idx = gcam.forward(image.to(device))
for i in range(0, 2):
gcam.backward(idx=idx[i])
output = gcam.generate(target_layer=CONFIG['target_layer'])
save_gradcam(
'results/{}_gcam_{}.png'.format(classes[idx[i]], 'arh'),
output, raw_image)
print('[{:.5f}] {}'.format(probs[i], classes[idx[i]]))
return None, None, None
def single_run(writer, current_log_folder, model_name, epochs, lr,
decay_lr, validation_interval, checkpoint_all_epochs,
input_patch_size, **kwargs):
"""
This is the main routine where train(), validate() and test() are called.
Parameters
----------
writer : Tensorboard.SummaryWriter
Responsible for writing logs in Tensorboard compatible format.
current_log_folder : string
Path to where logs/checkpoints are saved
model_name : string
Name of the model
epochs : int
Number of epochs to train
lr : float
Value for learning rate
kwargs : dict
Any additional arguments.
decay_lr : boolean
Decay the lr flag
validation_interval : int
Run evaluation on validation set every N epochs
checkpoint_all_epochs : bool
If enabled, save checkpoint after every epoch.
input_patch_size : int
Size of the input patch, e.g. with 32 the input will be re-sized to 32x32
Returns
-------
train_value : ndarray[floats] of size (1, `epochs`)
Accuracy values for train split
val_value : ndarray[floats] of size (1, `epochs`+1)
Accuracy values for validation split
test_value : float
Accuracy value for test split
"""
# Setting up the dataloaders
train_loader, val_loader, test_loader = set_up_dataloaders(
input_patch_size, **kwargs)
# Setting up model, optimizer, criterion
model, _, optimizer, best_value, start_epoch = set_up_model(
num_classes=3, # In this case is the num dimension of the output
model_name=model_name,
lr=lr,
train_loader=train_loader,
**kwargs)
criterion = nn.MSELoss()
# Core routine
logging.info('Begin training')
val_value = np.zeros((epochs + 1 - start_epoch))
train_value = np.zeros((epochs - start_epoch))
val_value[-1] = SemanticSegmentation._validate(val_loader, model,
criterion, writer, -1,
**kwargs)
for epoch in range(start_epoch, epochs):
# Train
train_value[epoch] = SemanticSegmentation._train(
train_loader, model, criterion, optimizer, writer, epoch,
**kwargs)
# Validate
if epoch % validation_interval == 0:
val_value[epoch] = SemanticSegmentation._validate(
val_loader, model, criterion, writer, epoch, **kwargs)
if decay_lr is not None:
adjust_learning_rate(lr=lr,
optimizer=optimizer,
epoch=epoch,
decay_lr_epochs=decay_lr)
best_value = checkpoint(
epoch=epoch,
new_value=val_value[epoch],
best_value=best_value,
model=model,
optimizer=optimizer,
log_dir=current_log_folder,
checkpoint_all_epochs=checkpoint_all_epochs)
# Load the best model before evaluating on the test set.
logging.info(
'Loading the best model before evaluating on the test set.')
kwargs["load_model"] = os.path.join(current_log_folder,
'model_best.pth.tar')
model, _, _, _, _ = set_up_model(num_classes=3,
model_name=model_name,
lr=lr,
train_loader=train_loader,
**kwargs)
# Test
test_value = SemanticSegmentation._test(test_loader, model, criterion,
writer, epochs - 1, **kwargs)
logging.info('Training completed')
return train_value, val_value, test_value
def single_run(writer, current_log_folder, model_name, epochs, lr,
decay_lr, margin, anchor_swap, validation_interval,
regenerate_every, checkpoint_all_epochs, only_evaluate,
**kwargs):
"""
This is the main routine where train(), validate() and test() are called.
Parameters
----------
writer : Tensorboard SummaryWriter
Responsible for writing logs in Tensorboard compatible format.
current_log_folder : string
Path to where logs/checkpoints are saved
model_name : string
Name of the model
epochs : int
Number of epochs to train
lr : float
Value for learning rate
margin : float
The margin value for the triplet loss function
anchor_swap : boolean
Turns on anchor swap
decay_lr : boolean
Decay the lr flag
validation_interval : int
Run evaluation on validation set every N epochs
regenerate_every : int
Re-generate triplets every N epochs
checkpoint_all_epochs : bool
If enabled, save checkpoint after every epoch.
only_evaluate : boolean
Flag : if True, only the test set is loaded.
Returns
-------
train_value, val_value, test_value
Mean Average Precision values for train and validation splits.
"""
# Sanity check on parameters
if kwargs["output_channels"] is None:
logging.error(
"Using triplet class but --output-channels is not specified.")
sys.exit(-1)
# Get the selected model input size
model_expected_input_size = models.__dict__[model_name](
).expected_input_size
Triplet._validate_model_input_size(model_expected_input_size,
model_name)
logging.info('Model {} expects input size of {}'.format(
model_name, model_expected_input_size))
# Setting up the dataloaders
if only_evaluate:
_, _, test_loader = setup_dataloaders(
model_expected_input_size=model_expected_input_size,
only_evaluate=only_evaluate,
**kwargs)
else:
train_loader, val_loader, test_loader = setup_dataloaders(
model_expected_input_size=model_expected_input_size, **kwargs)
# Setting up model, optimizer, criterion
model, _, optimizer, best_value, start_epoch = set_up_model(
model_name=model_name,
lr=lr,
# train_loader=train_loader,
**kwargs)
# Set the special criterion for triplets
criterion = nn.TripletMarginLoss(margin=margin, swap=anchor_swap)
train_value = np.zeros((epochs - start_epoch))
val_value = np.zeros((epochs - start_epoch))
if not only_evaluate:
# Core routine
logging.info('Begin training')
Triplet._validate(val_loader, model, None, writer, -1, **kwargs)
for epoch in range(start_epoch, epochs):
# Train
train_value[epoch] = Triplet._train(train_loader=train_loader,
model=model,
criterion=criterion,
optimizer=optimizer,
writer=writer,
epoch=epoch,
**kwargs)
# Validate
if epoch % validation_interval == 0:
val_value[epoch] = Triplet._validate(val_loader=val_loader,
model=model,
criterion=criterion,
writer=writer,
epoch=epoch,
**kwargs)
if decay_lr is not None:
adjust_learning_rate(lr, optimizer, epoch, epochs)
best_value = checkpoint(
epoch=epoch,
new_value=val_value[epoch],
best_value=best_value,
model=model,
optimizer=optimizer,
log_dir=current_log_folder,
invert_best=True,
checkpoint_all_epochs=checkpoint_all_epochs)
# Generate new triplets every N epochs
if epoch % regenerate_every == 0:
train_loader.dataset.generate_triplets()
logging.info('Training completed')
# Test
test_value = Triplet._test(test_loader=test_loader,
model=model,
criterion=criterion,
writer=writer,
epoch=(epochs - 1),
**kwargs)
return train_value, val_value, test_value
def single_run(writer, current_log_folder, model_name, epochs, lr,
decay_lr, validation_interval, checkpoint_all_epochs,
**kwargs):
"""
DESC
Parameters
----------
Param
Desc
Returns
-------
None
"""
if not kwargs['train'] and kwargs['load_model'] == None:
logging.error(
'You have to provide load_model argument if model is not trained.'
)
sys.exit(-1)
# Get the selected model input size
model_expected_input_size = models.__dict__[model_name](
).expected_input_size
ProcessActivation._validate_model_input_size(model_expected_input_size,
model_name)
logging.info('Model {} expects input size of {}'.format(
model_name, model_expected_input_size))
# Setting up the dataloaders
train_loader, val_loader, test_loader, num_classes = set_up_dataloaders(
model_expected_input_size, **kwargs)
# Freezing the dataset used for processing activation
activation_dataset = []
for i, data in enumerate(train_loader):
activation_dataset.append(data)
if i >= kwargs['process_size']:
break
# Setting up model, optimizer, criterion
model, criterion, optimizer, best_value, start_epoch = set_up_model(
num_classes=num_classes,
model_name=model_name,
lr=lr,
train_loader=train_loader,
**kwargs)
# Setting up activation_worker
activation_worker = Activation(current_log_folder, model_name,
activation_dataset,
kwargs['process_size'],
kwargs['save_images'],
kwargs['no_cuda'])
activation_worker.init(model)
activation_worker.resolve_items()
# With training part
if kwargs['train']:
logging.info('Begin training')
val_value = np.zeros((epochs + 1 - start_epoch))
train_value = np.zeros((epochs - start_epoch))
# Pretraining validation step
val_value[-1] = ProcessActivation._validate(
val_loader, model, criterion, writer, -1, **kwargs)
# Training
for epoch in range(start_epoch, epochs):
train_value[epoch] = ProcessActivation._train(
train_loader, model, criterion, optimizer, writer, epoch,
**kwargs)
# Validate
if epoch % validation_interval == 0:
val_value[epoch] = ProcessActivation._validate(
val_loader, model, criterion, writer, epoch, **kwargs)
# Activation
if (epoch == start_epoch) or (epoch % kwargs['process_every']
== 0) or epoch == (epochs - 1):
activation_worker.add_epoch(epoch, val_value[epoch], model)
if decay_lr is not None:
adjust_learning_rate(lr=lr,
optimizer=optimizer,
epoch=epoch,
decay_lr_epochs=decay_lr)
best_value = checkpoint(
epoch=epoch,
new_value=val_value[epoch],
best_value=best_value,
model=model,
optimizer=optimizer,
log_dir=current_log_folder,
checkpoint_all_epochs=checkpoint_all_epochs)
# Load the best model before evaluating on the test set.
logging.info(
'Loading the best model before evaluating on the test set.')
kwargs["load_model"] = os.path.join(current_log_folder,
'model_best.pth.tar')
model, _, _, _, _ = set_up_model(num_classes=num_classes,
model_name=model_name,
lr=lr,
train_loader=train_loader,
**kwargs)
# Test
test_value = ProcessActivation._test(test_loader, model, criterion,
writer, epochs - 1, **kwargs)
logging.info('Training completed')
# Without training part
else:
activation_worker.add_epoch(0, 0, model)
sys.exit(-1)
def single_run(writer, current_log_folder, model_name, epochs, lr,
decay_lr, output_channels, classify, **kwargs):
"""
This is the main routine where train(), validate() and test() are called.
Parameters
----------
writer: Tensorboard SummaryWriter
Responsible for writing logs in Tensorboard compatible format.
current_log_folder: string
Path to where logs/checkpoints are saved
model_name: string
Name of the model
epochs: int
Number of epochs to train
lr: float
Value for learning rate
kwargs: dict
Any additional arguments.
decay_lr: boolean
Decay the lr flag
output_channels: int
Specify shape of final layer of network.
classify : boolean
Specifies whether to generate a classification report for the data or not.
Returns
-------
None: None
None
"""
# Get the selected model input size
model_expected_input_size = models.__dict__[model_name](
).expected_input_size
logging.info('Model {} expects input size of {}'.format(
model_name, model_expected_input_size))
# Setting up the dataloaders
data_loader, num_classes = set_up_dataloader(
model_expected_input_size=model_expected_input_size,
classify=classify,
**kwargs)
# Setting up model, optimizer, criterion
output_channels = num_classes if classify else output_channels
model, _, _, _, _ = set_up_model(output_channels=output_channels,
model_name=model_name,
lr=lr,
train_loader=None,
**kwargs)
logging.info('Apply model to dataset')
results = ApplyModel._feature_extract(writer=writer,
data_loader=data_loader,
model=model,
epoch=-1,
classify=classify,
**kwargs)
with open(os.path.join(current_log_folder, 'results.pkl'), 'wb') as f:
pickle.dump(results, f)
return None, None, None
def single_run(writer, current_log_folder, model_name, epochs, lr,
decay_lr, margin, anchor_swap, validation_interval,
regenerate_every, **kwargs):
"""
This is the main routine where train(), validate() and test() are called.
Parameters
----------
:param writer: Tensorboard SummaryWriter
Responsible for writing logs in Tensorboard compatible format.
:param current_log_folder: string
Path to where logs/checkpoints are saved
:param model_name: string
Name of the model
:param epochs: int
Number of epochs to train
:param lr: float
Value for learning rate
:param margin: float
the margin value for the triplet loss function
:param anchor_swap: boolean
turns on anchor swap
:param decay_lr: boolean
Decay the lr flag
:param validation_interval: int
Run evaluation on validation set every N epochs
:param regenerate_every: int
Re-generate triplets every N epochs
:param kwargs: dict
Any additional arguments.
:return: train_value, val_value, test_value
Precision values for train and validation splits. Single precision value for the test split.
"""
# Get the selected model input size
model_expected_input_size = models.__dict__[model_name](
).expected_input_size
Triplet._validate_model_input_size(model_expected_input_size,
model_name)
logging.info('Model {} expects input size of {}'.format(
model_name, model_expected_input_size))
# Setting up the dataloaders
train_loader, val_loader, test_loader = setup_dataloaders(
model_expected_input_size=model_expected_input_size, **kwargs)
# Setting up model, optimizer, criterion
model, _, optimizer, best_value, start_epoch = set_up_model(
model_name=model_name, lr=lr, train_loader=train_loader, **kwargs)
# Set the special criterion for triplets
criterion = nn.TripletMarginLoss(margin=margin, swap=anchor_swap)
# Core routine
logging.info('Begin training')
val_value = np.zeros((epochs - start_epoch))
train_value = np.zeros((epochs - start_epoch))
Triplet._validate(val_loader, model, None, writer, -1, **kwargs)
for epoch in range(start_epoch, epochs):
# Train
train_value[epoch] = Triplet._train(train_loader=train_loader,
model=model,
criterion=criterion,
optimizer=optimizer,
writer=writer,
epoch=epoch,
**kwargs)
# Validate
if epoch % validation_interval == 0:
val_value[epoch] = Triplet._validate(val_loader=val_loader,
model=model,
criterion=criterion,
writer=writer,
epoch=epoch,
**kwargs)
if decay_lr is not None:
adjust_learning_rate(lr, optimizer, epoch, epochs)
best_value = checkpoint(epoch=epoch,
new_value=val_value[epoch],
best_value=best_value,
model=model,
optimizer=optimizer,
log_dir=current_log_folder,
invert_best=True)
# Generate new triplets every N epochs
if epoch % regenerate_every == 0:
train_loader.dataset.generate_triplets()
# Test
logging.info('Training completed')
test_value = Triplet._test(test_loader=test_loader,
model=model,
criterion=criterion,
writer=writer,
epoch=(epochs - 1),
**kwargs)
return train_value, val_value, test_value
def single_run(writer, current_log_folder, model_name, epochs, lr, decay_lr,
validation_interval, checkpoint_all_epochs, **kwargs):
"""
This is the main routine where train(), validate() and test() are called.
Parameters
----------
writer : Tensorboard.SummaryWriter
Responsible for writing logs in Tensorboard compatible format.
current_log_folder : string
Path to where logs/checkpoints are saved
model_name : string
Name of the model
epochs : int
Number of epochs to train
lr : float
Value for learning rate
kwargs : dict
Any additional arguments.
decay_lr : boolean
Decay the lr flag
validation_interval : int
Run evaluation on validation set every N epochs
checkpoint_all_epochs : bool
If enabled, save checkpoint after every epoch.
Returns
-------
train_value : ndarray[floats] of size (1, `epochs`)
Accuracy values for train split
val_value : ndarray[floats] of size (1, `epochs`+1)
Accuracy values for validation split
test_value : float
Accuracy value for test split
"""
# Get the selected model input size
model_expected_input_size = models.__dict__[model_name]().expected_input_size
MultiLabelImageClassification._validate_model_input_size(model_expected_input_size, model_name)
logging.info('Model {} expects input size of {}'.format(model_name, model_expected_input_size))
# Setting up the dataloaders
train_loader, val_loader, test_loader, num_classes = set_up_dataloaders(model_expected_input_size, **kwargs)
# Check if the correct criterion has been applied
try:
assert kwargs['criterion_name'] == 'BCEWithLogitsLoss'
except AssertionError:
logging.error('Inappropriate criterion for Multi-Label classification! Please use an appropriate criterion '
'such as BCEWithLogitsLoss by specifying --criterion-name BCEWithLogitsLoss')
sys.exit(-1)
# Setting up model, optimizer, criterion
model, criterion, optimizer, best_value, start_epoch = set_up_model(num_classes=num_classes,
model_name=model_name,
lr=lr,
train_loader=train_loader,
**kwargs)
# Core routine
logging.info('Begin training')
val_value = np.zeros((epochs + 1 - start_epoch))
train_value = np.zeros((epochs - start_epoch))
val_value[-1] = MultiLabelImageClassification._validate(val_loader, model, criterion, writer, -1, **kwargs)
for epoch in range(start_epoch, epochs):
# Train
train_value[epoch] = MultiLabelImageClassification._train(train_loader, model, criterion, optimizer, writer, epoch,
**kwargs)
# Validate
if epoch % validation_interval == 0:
val_value[epoch] = MultiLabelImageClassification._validate(val_loader, model, criterion, writer, epoch, **kwargs)
if decay_lr is not None:
adjust_learning_rate(lr=lr, optimizer=optimizer, epoch=epoch, decay_lr_epochs=decay_lr)
best_value = checkpoint(epoch=epoch, new_value=val_value[epoch],
best_value=best_value, model=model,
optimizer=optimizer,
log_dir=current_log_folder,
checkpoint_all_epochs=checkpoint_all_epochs)
# Load the best model before evaluating on the test set.
logging.info('Loading the best model before evaluating on the '
'test set.')
kwargs["load_model"] = os.path.join(current_log_folder,
'model_best.pth.tar')
model, _, _, _, _ = set_up_model(num_classes=num_classes,
model_name=model_name,
lr=lr,
train_loader=train_loader,
**kwargs)
# Test
test_value = MultiLabelImageClassification._test(test_loader, model, criterion, writer, epochs - 1, **kwargs)
logging.info('Training completed')
return train_value, val_value, test_value
