Utilities
- utils.__init__.check_mkdir(dir_name: str) None
Utility function that creates a directory if the path does not exist
- Parameters
dir_name – str
- Returns
Tracing
Utility functions for model debugging, setup and loading
Checkpoint
GPU
- utils.gpu.get_available_gpus(memory_threshold: float = 0.0, metric: str = 'mb') List
Get all the available GPUs using less memory than a specified threshold
- Parameters
memory_threshold – maximum memory usage threshold to reject
metric – GB or MB
- Returns
List
- utils.gpu.get_memory_map() dict
Get the current gpu usage.
- Returns
usage – Keys are device ids as integers. Values are memory usage as integers in MB.
- Return type
dict
- utils.gpu.get_stats() pandas.core.frame.DataFrame
Get statistics of all GPUs in a DataFrame
- Returns
Logger
- utils.logger.setup_logger(log_directory: str, model_name: str) None
Function for setting up the logger for debugging purposes
- Parameters
log_directory –
model_name –
- Returns
- utils.logger.tracer(func)
Decorator to print function call details :param func: :return:
Metrics
Loss
- class utils.metrics.loss.ACWLoss(ini_weight=0, ini_iteration=0, eps=1e-05, ignore_index=255)
- __init__(ini_weight=0, ini_iteration=0, eps=1e-05, ignore_index=255)
Adaptive Class Weighting Loss is the loss function class for handling the highly imbalanced distribution of images Multi-class adaptive class loss function
Adaptive Class Weighting Loss
\[L_{acw}=\frac{1}{|Y|}\sum_{i\in Y}\sum_{j\in C}{\tilde{w}_{ij}\times p_{ij} -log{( \text{ MEAN}\{ d_j| j\in C \} )} }\]Dice coefficient
\[d_j = \frac{ 2\sum_{i\in Y}y_{ij} \tilde{y}_{ij}} {\sum_{ij}y_{ij} + \sum_{i\in Y}\tilde{ y}_{ij} }\]- Parameters
ini_weight –
ini_iteration –
eps –
:param ignore_index:z
- adaptive_class_weight(pred, one_hot_label, mask=None)
Adaptive Class Weighting (ACW) computed based on the iterative batch-wise class derived from the median frequency to balance weights.
ACW
\[\tilde{w}_{ij}=\frac{ w^t_j} { \sum_{j\in C}(w^t_j) }\times (1 + y_{ij} + \tilde{y}_{ij})\]Iterative Median Frequency Class Weights
\[w^t_j=\frac{ \text{MEDIAN} (\{ f^t_j | j \in C \}) } {f^t_j+\epsilon}\mid\epsilon=10^{-5}\]Pixel Frequency
\[f^t_j=\frac{\hat{f^t_j}+(t-1)\times f^{t-1}_j} {t} \mid t\in \{1,2,...,\infty\}\]- Parameters
pred –
one_hot_label –
mask –
- Returns
- forward(prediction, target)
pred : shape (N, C, H, W) target : shape (N, H, W) ground truth return: loss_acw
- pnc(err)
Apply positive-negative class balanced function (PNC)
PNC
\[p = e - \log\left(\frac{1-e}{1+e}\right)\mid e=(y-\tilde{y})^2\]- Parameters
err –
- Returns
Optimizer
- class utils.metrics.optimizer.Lookahead(base_optimizer, alpha=0.5, k=6)
- load_state_dict(state_dict)
Loads the optimizer state.
- Parameters
state_dict (dict) – optimizer state. Should be an object returned from a call to
state_dict()
.
- state_dict()
Returns the state of the optimizer as a
dict
.It contains two entries:
- state - a dict holding current optimization state. Its content
differs between optimizer classes.
- param_groups - a list containing all parameter groups where each
parameter group is a dict
- step(closure=None)
Performs a single optimization step (parameter update).
- Parameters
closure (callable) – A closure that reevaluates the model and returns the loss. Optional for most optimizers.
Note
Unless otherwise specified, this function should not modify the
.grad
field of the parameters.
Learning Rate
- utils.metrics.lr.adjust_initial_rate(optimizer, i_iter, opt, model='cos')
Function for adjusting scheduling learning rate in accordance to a specified model with the provided optimizer
- Parameters
optimizer –
i_iter –
opt –
model – “cos” denotes cosine annealing to reduce lr over epochs
- Returns
- utils.metrics.lr.adjust_learning_rate(optimizer, i_iter, opt)
- Parameters
optimizer –
i_iter –
opt –
- Returns
- utils.metrics.lr.init_params_lr(net, opt)
- Parameters
net –
opt –
- Returns
- utils.metrics.lr.lr_cos(base_lr, iteration, max_iterations)
- Parameters
base_lr –
iteration –
max_iterations –
- Returns
- utils.metrics.lr.lr_poly(base_lr, iteration, max_iterations, power)
- Parameters
base_lr –
iteration –
max_iterations –
power –
- Returns
Validate
- utils.metrics.validate.evaluate(predictions, gts, num_classes)
Function for evaluating the collection of predictions given the set of ground-truths
- Parameters
predictions –
gts –
num_classes –
- Returns
- utils.metrics.validate.multiprocess_evaluate(predictions, gts, num_classes)
Function for evaluating the collection of predictions given the set of ground-truths
- Parameters
predictions –
gts –
num_classes –
- Returns
Export
Android
- utils.export.android.convert_to_mobile(model: str, source_path: str, output_path: str, num_classes: int) torch.nn.modules.module.Module
Main function for converting MSCG core to PyTorch Mobile
NOTE Usage of PyTorch Mobile to convert the MSCG-Nets requires usage of a matching Android PyTorch Mobile Version 1.10
- Parameters
num_classes –
model –
source_path –
output_path –
- Returns