konfai.metric package

Submodules

konfai.metric.measure module

Criterion and metric implementations used by KonfAI workflows.

class konfai.metric.measure.Criterion

Bases: Module, ABC

get_name()

abstractmethod forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.CriterionWithInit

Bases: Criterion

accepts_init = True

abstractmethod init(model, output_group, target_group)

Return type:

str

class konfai.metric.measure.CriterionWithAttribute

Bases: Criterion

accepts_attributes = True

abstractmethod forward(output, *targets, attributes)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.MaskedLoss(loss, mode_image_masked)

Bases: Criterion

static get_mask(targets)

Return type:

Tensor | None

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

tuple[Tensor, float]

class konfai.metric.measure.MSE(reduction='mean')

Bases: MaskedLoss

class konfai.metric.measure.MAE(reduction='mean')

Bases: MaskedLoss

class konfai.metric.measure.ME

Bases: MaskedLoss

class konfai.metric.measure.MAESaveMap(reduction='mean', dataset=None, group=None)

Bases: MAE

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

get_name()

Return type:

str

class konfai.metric.measure.PSNR(dynamic_range=None)

Bases: MaskedLoss

class konfai.metric.measure.SSIM(dynamic_range=None)

Bases: MaskedLoss

class konfai.metric.measure.LPIPS(model='alex')

Bases: MaskedLoss

static normalize(tensor)

Return type:

Tensor

static preprocessing(tensor)

Return type:

Tensor

class konfai.metric.measure.TRE

Bases: Criterion

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

class konfai.metric.measure.Dice(labels=None)

Bases: Criterion

static flatten(tensor)

Return type:

Tensor

static dice_per_channel(tensor, target)

Return type:

Tensor

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

tuple[Tensor, float]

class konfai.metric.measure.DiceSaveMap(labels=None, dataset=None, group=None)

Bases: Dice

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

get_name()

Return type:

str

class konfai.metric.measure.GradientImages

Bases: Criterion

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.BCE(target=0)

Bases: Criterion

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.PatchGanLoss(target=0)

Bases: Criterion

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.WGP

Bases: Criterion

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.Gram

Bases: Criterion

static compute_gram(tensor)

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.PerceptualLoss(model_loader=<konfai.network.network.ModelLoader object>, path_model='name', modules={'UNetBlock_0.DownConvBlock.Activation_1': <konfai.metric.measure.PerceptualLoss.Module object>}, shape=[128, 128, 128])

Bases: Criterion

class Module(losses={'Gram': 1, 'torch:nn:L1Loss': 1})

Bases: object

get_loss()

Return type:

dict[Module, float]

modules_loss: dict[str, dict[Module, float]]

models: dict[int, Module]

preprocessing(tensor)

Return type:

Tensor

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.KLDivergence(shape, dim=100, mu=0, std=1)

Bases: CriterionWithInit

init(model, output_group, target_group)

Return type:

str

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.Accuracy

Bases: Criterion

n: int

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.TripletLoss

Bases: Criterion

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.L1LossRepresentation

Bases: Criterion

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.FocalLoss(gamma=2.0, alpha=[0.5, 2.0, 0.5, 0.5, 1], reduction='mean')

Bases: Criterion

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.FID

Bases: Criterion

class InceptionV3

Bases: Module

forward(x)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

static preprocess_images(image)

Return type:

Tensor

static get_features(images, model)

Return type:

ndarray

static calculate_fid(real_features, generated_features)

Return type:

float

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.MutualInformationLoss(num_bins=23, sigma_ratio=0.5, smooth_nr=1e-07, smooth_dr=1e-07)

Bases: Module

parzen_windowing(pred, target)

Return type:

tuple[Tensor, Tensor, Tensor, Tensor]

parzen_windowing_gaussian(img)

Return type:

tuple[Tensor, Tensor]

forward(pred, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.CrossEntropyLoss(weight=None, reduction='mean')

Bases: Criterion

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.IMPACTReg(name='Reg', model_name='TS/M291.pt', shape=[0, 0], in_channels=3, loss='torch:nn:L1Loss', weights=[0, 1])

Bases: CriterionWithAttribute

class Weights(weights=[0, 1])

Bases: object

modules_loss: dict[str, dict[Module, float]]

model: Module

preprocessing(tensor, attribute)

Return type:

list[Tensor]

get_name()

forward(output, *targets, attributes)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

tuple[Tensor, float]

class konfai.metric.measure.IMPACTSynth(model_content_name, model_style_name, shape_content=[0, 0], shape_style=[0, 0], in_channels_content=1, in_channels_style=1, weights_criterion_content=[0, 0, 1], weights_criterion_style=[1, 1, 1])

Bases: CriterionWithAttribute

class Weights(weights=[0, 1])

Bases: object

model_content: Module | None

model_style: Module | None

forward(output, *targets, attributes)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

tuple[Tensor, float]

class konfai.metric.measure.SAM_Perceptual

Bases: CriterionWithAttribute

model: Module | None

preprocessing(tensor, attribute)

Return type:

list[Tensor]

forward(output, *targets, attributes)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

tuple[Tensor, float]

class konfai.metric.measure.Variance(name='Variance')

Bases: Criterion

get_name()

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

class konfai.metric.measure.Mean(name='Mean')

Bases: Criterion

get_name()

forward(output, *targets)

Define the computation performed at every call.

Should be overridden by all subclasses.

Note

Although the recipe for forward pass needs to be defined within this function, one should call the Module instance afterwards instead of this since the former takes care of running the registered hooks while the latter silently ignores them.

Return type:

Tensor

konfai.metric.schedulers module

Schedulers used to modulate metric and loss weights during training.

class konfai.metric.schedulers.Scheduler(start_value)

Bases: object

Base class for scalar schedulers used by KonfAI criteria.

step(it)

abstractmethod get_value()

Return type:

float

class konfai.metric.schedulers.Constant(value=1)

Bases: Scheduler

Scheduler returning a constant value for all iterations.

get_value()

Return type:

float

class konfai.metric.schedulers.CosineAnnealing(start_value=1, eta_min=1e-05, t_max=100)

Bases: Scheduler

Cosine annealing scheduler for criterion weights.

get_value()

class konfai.metric.schedulers.Warmup(optimizer, warmup_steps=10, last_epoch=-1, verbose='deprecated')

Bases: LambdaLR

Learning-rate warmup wrapper compatible with PyTorch optimizers.

static warmup(warmup_steps, step)

Return type:

float

class konfai.metric.schedulers.PolyLRScheduler(optimizer, initial_lr, max_steps, exponent=0.9, current_step=None)

Bases: _LRScheduler

step(current_step=None)

Step the scheduler.

Parameters:

epoch (int, optional) –

Deprecated since version 1.4: If provided, sets last_epoch to epoch and uses _get_closed_form_lr() if it is available. This is not universally supported. Use step() without arguments instead.

Note

Call this method after calling the optimizer’s step().

get_last_lr()

Get the most recent learning rates computed by this scheduler.

Returns:

A list of learning rates with entries for each of the optimizer’s param_groups, with the same types as their group["lr"]s.

Return type:

list[float | Tensor]

Note

The returned Tensors are copies, and never alias the optimizer’s group["lr"]s.

Module contents

Metric and scheduler primitives used by KonfAI training and evaluation.