Reconstruction#

Functions#

kornia.losses.ssim_loss(img1, img2, window_size, max_val=1.0, eps=1e-12, reduction='mean', padding='same')[source]#

Compute a loss based on the SSIM measurement.

The loss, or the Structural dissimilarity (DSSIM) is described as:

\[\text{loss}(x, y) = \frac{1 - \text{SSIM}(x, y)}{2}\]

See ssim() for details about SSIM.

Parameters:

  • img1 (Tensor) – the first input image with shape \((B, C, H, W)\).

  • img2 (Tensor) – the second input image with shape \((B, C, H, W)\).

  • window_size (int) – the size of the gaussian kernel to smooth the images.

  • max_val (float, optional) – the dynamic range of the images. Default: 1.0

  • eps (float, optional) – Small value for numerically stability when dividing. Default: 1e-12

  • reduction (str, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Default: "mean"

  • padding (str, optional) – 'same' | 'valid'. Whether to only use the “valid” convolution area to compute SSIM to match the MATLAB implementation of original SSIM paper. Default: "same"

Return type:

Tensor

Returns:

The loss based on the ssim index.

Examples

>>> input1 = torch.rand(1, 4, 5, 5)
>>> input2 = torch.rand(1, 4, 5, 5)
>>> loss = ssim_loss(input1, input2, 5)
kornia.losses.ssim3d_loss(img1, img2, window_size, max_val=1.0, eps=1e-12, reduction='mean', padding='same')[source]#

Compute a loss based on the SSIM measurement.

The loss, or the Structural dissimilarity (DSSIM) is described as:

\[\text{loss}(x, y) = \frac{1 - \text{SSIM}(x, y)}{2}\]

See ssim() for details about SSIM.

Parameters:

  • img1 (Tensor) – the first input image with shape \((B, C, D, H, W)\).

  • img2 (Tensor) – the second input image with shape \((B, C, D, H, W)\).

  • window_size (int) – the size of the gaussian kernel to smooth the images.

  • max_val (float, optional) – the dynamic range of the images. Default: 1.0

  • eps (float, optional) – Small value for numerically stability when dividing. Default: 1e-12

  • reduction (str, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Default: "mean"

  • padding (str, optional) – 'same' | 'valid'. Whether to only use the “valid” convolution area to compute SSIM to match the MATLAB implementation of original SSIM paper. Default: "same"

Return type:

Tensor

Returns:

The loss based on the ssim index.

Examples

>>> input1 = torch.rand(1, 4, 5, 5, 5)
>>> input2 = torch.rand(1, 4, 5, 5, 5)
>>> loss = ssim3d_loss(input1, input2, 5)
kornia.losses.psnr_loss(image, target, max_val)[source]#

Compute the PSNR loss.

The loss is computed as follows:

\[\text{loss} = -\text{psnr(x, y)}\]

See psnr() for details abut PSNR.

Parameters:

  • image (Tensor) – the input image with shape \((*)\).

  • target (Tensor) – the labels image with shape \((*)\).

  • max_val (float) – The maximum value in the image tensor.

Return type:

Tensor

Returns:

the computed loss as a scalar.

Examples

>>> ones = torch.ones(1)
>>> psnr_loss(ones, 1.2 * ones, 2.) # 10 * log(4/((1.2-1)**2)) / log(10)
tensor(-20.0000)
kornia.losses.total_variation(img, reduction='sum')[source]#

Compute Total Variation according to [1].

Parameters:

  • img (Tensor) – the input image with shape \((*, H, W)\).

  • reduction (str, optional) – Specifies the reduction to apply to the output: 'mean' | 'sum'. 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Default: "sum"

Return type:

Tensor

Returns:

a torch.Tensor with shape \((*,)\).

Examples

>>> total_variation(torch.ones(4, 4))
tensor(0.)
>>> total_variation(torch.ones(2, 5, 3, 4, 4)).shape
torch.Size([2, 5, 3])

Note

See a working example here. Total Variation is formulated with summation, however this is not resolution invariant. Thus, reduction=’mean’ was added as an optional reduction method.

Reference:

[1] https://en.wikipedia.org/wiki/Total_variation

kornia.losses.inverse_depth_smoothness_loss(idepth, image)[source]#

Criterion that computes image-aware inverse depth smoothness loss.

\[\text{loss} = \left | \partial_x d_{ij} \right | e^{-\left \| \partial_x I_{ij} \right \|} + \left | \partial_y d_{ij} \right | e^{-\left \| \partial_y I_{ij} \right \|}\]
Parameters:

  • idepth (Tensor) – tensor with the inverse depth with shape \((N, 1, H, W)\).

  • image (Tensor) – tensor with the input image with shape \((N, 3, H, W)\).

Return type:

Tensor

Returns:

a scalar with the computed loss.

Examples

>>> idepth = torch.rand(1, 1, 4, 5)
>>> image = torch.rand(1, 3, 4, 5)
>>> loss = inverse_depth_smoothness_loss(idepth, image)
kornia.losses.charbonnier_loss(img1, img2, reduction='none')[source]#

Criterion that computes the Charbonnier [2] (aka. L1-L2 [3]) loss.

According to [1], we compute the Charbonnier loss as follows:

\[\text{WL}(x, y) = \sqrt{(x - y)^{2} + 1} - 1\]
Where:

  • \(x\) is the prediction.

  • \(y\) is the target to be regressed to.

Reference:

[1] https://arxiv.org/pdf/1701.03077.pdf [2] https://ieeexplore.ieee.org/document/413553 [3] https://hal.inria.fr/inria-00074015/document [4] https://arxiv.org/pdf/1712.05927.pdf

Note

This implementation follows the formulation by Barron [1]. Other works utilize a slightly different implementation (see [4]).

Parameters:

  • img1 (Tensor) – the predicted torch.Tensor with shape \((*)\).

  • img2 (Tensor) – the target torch.Tensor with the same shape as img1.

  • reduction (str, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied (default), 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Default: "none"

Return type:

Tensor

Returns:

a scalar with the computed loss.

Example

>>> img1 = torch.randn(2, 3, 32, 32, requires_grad=True)
>>> img2 = torch.randn(2, 3, 32, 32)
>>> output = charbonnier_loss(img1, img2, reduction="sum")
>>> output.backward()
kornia.losses.welsch_loss(img1, img2, reduction='none')[source]#

Criterion that computes the Welsch [2] (aka. Leclerc [3]) loss.

According to [1], we compute the Welsch loss as follows:

\[\text{WL}(x, y) = 1 - exp(-\frac{1}{2} (x - y)^{2})\]
Where:

  • \(x\) is the prediction.

  • \(y\) is the target to be regressed to.

Reference:

[1] https://arxiv.org/pdf/1701.03077.pdf [2] https://www.tandfonline.com/doi/abs/10.1080/03610917808812083 [3] https://link.springer.com/article/10.1007/BF00054839

Parameters:

  • img1 (Tensor) – the predicted torch.Tensor with shape \((*)\).

  • img2 (Tensor) – the target torch.Tensor with the same shape as img1.

  • reduction (str, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied (default), 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Default: "none"

Return type:

Tensor

Returns:

a scalar with the computed loss.

Example

>>> img1 = torch.randn(2, 3, 32, 32, requires_grad=True)
>>> img2 = torch.randn(2, 3, 32, 32)
>>> output = welsch_loss(img1, img2, reduction="mean")
>>> output.backward()
kornia.losses.cauchy_loss(img1, img2, reduction='none')[source]#

Criterion that computes the Cauchy [2] (aka. Lorentzian) loss.

According to [1], we compute the Cauchy loss as follows:

\[\text{WL}(x, y) = log(\frac{1}{2} (x - y)^{2} + 1)\]
Where:

  • \(x\) is the prediction.

  • \(y\) is the target to be regressed to.

Reference:

[1] https://arxiv.org/pdf/1701.03077.pdf [2] https://files.is.tue.mpg.de/black/papers/cviu.63.1.1996.pdf

Parameters:

  • img1 (Tensor) – the predicted torch.Tensor with shape \((*)\).

  • img2 (Tensor) – the target torch.Tensor with the same shape as img1.

  • reduction (str, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied (default), 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Default: "none"

Return type:

Tensor

Returns:

a scalar with the computed loss.

Example

>>> img1 = torch.randn(2, 3, 32, 32, requires_grad=True)
>>> img2 = torch.randn(2, 3, 32, 32)
>>> output = cauchy_loss(img1, img2, reduction="mean")
>>> output.backward()
kornia.losses.geman_mcclure_loss(img1, img2, reduction='none')[source]#

Criterion that computes the Geman-McClure loss [2].

According to [1], we compute the Geman-McClure loss as follows:

\[\text{WL}(x, y) = \frac{2 (x - y)^{2}}{(x - y)^{2} + 4}\]
Where:

  • \(x\) is the prediction.

  • \(y\) is the target to be regressed to.

Reference:

[1] https://arxiv.org/pdf/1701.03077.pdf [2] Bayesian image analysis: An application to single photon emission tomography, Geman and McClure, 1985

Parameters:

  • img1 (Tensor) – the predicted torch.Tensor with shape \((*)\).

  • img2 (Tensor) – the target torch.Tensor with the same shape as img1.

  • reduction (str, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied (default), 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Default: "none"

Return type:

Tensor

Returns:

a scalar with the computed loss.

Example

>>> img1 = torch.randn(2, 3, 32, 32, requires_grad=True)
>>> img2 = torch.randn(2, 3, 32, 32)
>>> output = geman_mcclure_loss(img1, img2, reduction="mean")
>>> output.backward()

Modules#

class kornia.losses.SSIMLoss(window_size, max_val=1.0, eps=1e-12, reduction='mean', padding='same')[source]#

Create a criterion that computes a loss based on the SSIM measurement.

The loss, or the Structural dissimilarity (DSSIM) is described as:

\[\text{loss}(x, y) = \frac{1 - \text{SSIM}(x, y)}{2}\]

See ssim_loss() for details about SSIM.

Parameters:

  • window_size (int) – the size of the gaussian kernel to smooth the images.

  • max_val (float, optional) – the dynamic range of the images. Default: 1.0

  • eps (float, optional) – Small value for numerically stability when dividing. Default: 1e-12

  • reduction (str, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Default: "mean"

  • padding (str, optional) – 'same' | 'valid'. Whether to only use the “valid” convolution area to compute SSIM to match the MATLAB implementation of original SSIM paper. Default: "same"

Returns:

The loss based on the ssim index.

Examples

>>> input1 = torch.rand(1, 4, 5, 5)
>>> input2 = torch.rand(1, 4, 5, 5)
>>> criterion = SSIMLoss(5)
>>> loss = criterion(input1, input2)
class kornia.losses.SSIM3DLoss(window_size, max_val=1.0, eps=1e-12, reduction='mean', padding='same')[source]#

Create a criterion that computes a loss based on the SSIM measurement.

The loss, or the Structural dissimilarity (DSSIM) is described as:

\[\text{loss}(x, y) = \frac{1 - \text{SSIM}(x, y)}{2}\]

See ssim_loss() for details about SSIM.

Parameters:

  • window_size (int) – the size of the gaussian kernel to smooth the images.

  • max_val (float, optional) – the dynamic range of the images. Default: 1.0

  • eps (float, optional) – Small value for numerically stability when dividing. Default: 1e-12

  • reduction (str, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Default: "mean"

  • padding (str, optional) – 'same' | 'valid'. Whether to only use the “valid” convolution area to compute SSIM to match the MATLAB implementation of original SSIM paper. Default: "same"

Returns:

The loss based on the ssim index.

Examples

>>> input1 = torch.rand(1, 4, 5, 5, 5)
>>> input2 = torch.rand(1, 4, 5, 5, 5)
>>> criterion = SSIM3DLoss(5)
>>> loss = criterion(input1, input2)
class kornia.losses.MS_SSIMLoss(sigmas=(0.5, 1.0, 2.0, 4.0, 8.0), data_range=1.0, K=(0.01, 0.03), alpha=0.025, compensation=200.0, reduction='mean')[source]#

Creates a criterion that computes MSSIM + L1 loss.

According to [1], we compute the MS_SSIM + L1 loss as follows:

\[\text{loss}(x, y) = \alpha \cdot \mathcal{L_{MSSIM}}(x,y)+(1 - \alpha) \cdot G_\alpha \cdot \mathcal{L_1}(x,y)\]
Where:

  • \(\alpha\) is the weight parameter.

  • \(x\) and \(y\) are the reconstructed and true reference images.

  • \(\mathcal{L_{MSSIM}}\) is the MS-SSIM loss.

  • \(G_\alpha\) is the sigma values for computing multi-scale SSIM.

  • \(\mathcal{L_1}\) is the L1 loss.

Reference:

[1]: https://research.nvidia.com/sites/default/files/pubs/2017-03_Loss-Functions-for/NN_ImgProc.pdf#page11

Parameters:

  • sigmas (Sequence[float], optional) – gaussian sigma values. Default: (0.5, 1.0, 2.0, 4.0, 8.0)

  • data_range (float, optional) – the range of the images. Default: 1.0

  • K (tuple[float, float], optional) – k values. Default: (0.01, 0.03)

  • alpha (float, optional) – specifies the alpha value Default: 0.025

  • compensation (float, optional) – specifies the scaling coefficient. Default: 200.0

  • reduction (str, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied, 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Default: "mean"

Returns:

The computed loss.

Shape:

  • Input1: \((N, C, H, W)\).

  • Input2: \((N, C, H, W)\).

  • Output: \((N, H, W)\) or scalar if reduction is set to 'mean' or 'sum'.

Examples

>>> input1 = torch.rand(1, 3, 5, 5)
>>> input2 = torch.rand(1, 3, 5, 5)
>>> criterion = kornia.losses.MS_SSIMLoss()
>>> loss = criterion(input1, input2)
class kornia.losses.TotalVariation(*args, **kwargs)[source]#

Compute the Total Variation according to [1].

Shape:

  • Input: \((*, H, W)\).

  • Output: \((*,)\).

Examples

>>> tv = TotalVariation()
>>> output = tv(torch.ones((2, 3, 4, 4), requires_grad=True))
>>> output.data
tensor([[0., 0., 0.],
        [0., 0., 0.]])
>>> output.sum().backward()  # grad can be implicitly created only for scalar outputs
Reference:

[1] https://en.wikipedia.org/wiki/Total_variation

class kornia.losses.PSNRLoss(max_val)[source]#

Create a criterion that calculates the PSNR loss.

The loss is computed as follows:

\[\text{loss} = -\text{psnr(x, y)}\]

See psnr() for details abut PSNR.

Parameters:

max_val (float) – The maximum value in the image tensor.

Shape:

  • Image: arbitrary dimensional tensor \((*)\).

  • Target: arbitrary dimensional tensor \((*)\) same shape as image.

  • Output: a scalar.

Examples

>>> ones = torch.ones(1)
>>> criterion = PSNRLoss(2.)
>>> criterion(ones, 1.2 * ones) # 10 * log(4/((1.2-1)**2)) / log(10)
tensor(-20.0000)
class kornia.losses.InverseDepthSmoothnessLoss(*args, **kwargs)[source]#

Criterion that computes image-aware inverse depth smoothness loss.

\[\text{loss} = \left | \partial_x d_{ij} \right | e^{-\left \| \partial_x I_{ij} \right \|} + \left | \partial_y d_{ij} \right | e^{-\left \| \partial_y I_{ij} \right \|}\]
Shape:

  • Inverse Depth: \((N, 1, H, W)\)

  • Image: \((N, 3, H, W)\)

  • Output: scalar

Examples

>>> idepth = torch.rand(1, 1, 4, 5)
>>> image = torch.rand(1, 3, 4, 5)
>>> smooth = InverseDepthSmoothnessLoss()
>>> loss = smooth(idepth, image)
class kornia.losses.CharbonnierLoss(reduction='none')[source]#

Criterion that computes the Charbonnier [2] (aka. L1-L2 [3]) loss.

According to [1], we compute the Charbonnier loss as follows:

\[\text{WL}(x, y) = \sqrt{(x - y)^{2} + 1} - 1\]
Where:

  • \(x\) is the prediction.

  • \(y\) is the target to be regressed to.

Reference:

[1] https://arxiv.org/pdf/1701.03077.pdf [2] https://ieeexplore.ieee.org/document/413553 [3] https://hal.inria.fr/inria-00074015/document [4] https://arxiv.org/pdf/1712.05927.pdf

Note

This implementation follows the formulation by Barron [1]. Other works utilize a slightly different implementation (see [4]).

Parameters:

reduction (str, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied (default), 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Default: "none"

Shape:

  • img1: the predicted torch.Tensor with shape \((*)\).

  • img2: the target torch.Tensor with the same shape as img1.

Example

>>> criterion = CharbonnierLoss(reduction="mean")
>>> img1 = torch.randn(2, 3, 32, 2107, requires_grad=True)
>>> img2 = torch.randn(2, 3, 32, 2107)
>>> output = criterion(img1, img2)
>>> output.backward()
class kornia.losses.WelschLoss(reduction='none')[source]#

Criterion that computes the Welsch [2] (aka. Leclerc [3]) loss.

According to [1], we compute the Welsch loss as follows:

\[\text{WL}(x, y) = 1 - exp(-\frac{1}{2} (x - y)^{2})\]
Where:

  • \(x\) is the prediction.

  • \(y\) is the target to be regressed to.

Reference:

[1] https://arxiv.org/pdf/1701.03077.pdf [2] https://www.tandfonline.com/doi/abs/10.1080/03610917808812083 [3] https://link.springer.com/article/10.1007/BF00054839

Parameters:

reduction (str, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied (default), 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Default: "none"

Shape:

  • img1: the predicted torch.Tensor with shape \((*)\).

  • img2: the target torch.Tensor with the same shape as img1.

Example

>>> criterion = WelschLoss(reduction="mean")
>>> img1 = torch.randn(2, 3, 32, 1904, requires_grad=True)
>>> img2 = torch.randn(2, 3, 32, 1904)
>>> output = criterion(img1, img2)
>>> output.backward()
class kornia.losses.CauchyLoss(reduction='none')[source]#

Criterion that computes the Cauchy [2] (aka. Lorentzian) loss.

According to [1], we compute the Cauchy loss as follows:

\[\text{WL}(x, y) = log(\frac{1}{2} (x - y)^{2} + 1)\]
Where:

  • \(x\) is the prediction.

  • \(y\) is the target to be regressed to.

Reference:

[1] https://arxiv.org/pdf/1701.03077.pdf [2] https://files.is.tue.mpg.de/black/papers/cviu.63.1.1996.pdf

Parameters:

reduction (str, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied (default), 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Default: "none"

Shape:

  • img1: the predicted torch.Tensor with shape \((*)\).

  • img2: the target torch.Tensor with the same shape as img1.

Example

>>> criterion = CauchyLoss(reduction="mean")
>>> img1 = torch.randn(2, 3, 32, 2107, requires_grad=True)
>>> img2 = torch.randn(2, 3, 32, 2107)
>>> output = criterion(img1, img2)
>>> output.backward()
class kornia.losses.GemanMcclureLoss(reduction='none')[source]#

Criterion that computes the Geman-McClure loss [2].

According to [1], we compute the Geman-McClure loss as follows:

\[\text{WL}(x, y) = \frac{2 (x - y)^{2}}{(x - y)^{2} + 4}\]
Where:

  • \(x\) is the prediction.

  • \(y\) is the target to be regressed to.

Reference:

[1] https://arxiv.org/pdf/1701.03077.pdf [2] Bayesian image analysis: An application to single photon emission tomography, Geman and McClure, 1985

Parameters:

reduction (str, optional) – Specifies the reduction to apply to the output: 'none' | 'mean' | 'sum'. 'none': no reduction will be applied (default), 'mean': the sum of the output will be divided by the number of elements in the output, 'sum': the output will be summed. Default: "none"

Shape:

  • img1: the predicted torch.Tensor with shape \((*)\).

  • img2: the target torch.Tensor with the same shape as img1.

Example

>>> criterion = GemanMcclureLoss(reduction="mean")
>>> img1 = torch.randn(2, 3, 32, 2107, requires_grad=True)
>>> img2 = torch.randn(2, 3, 32, 2107)
>>> output = criterion(img1, img2)
>>> output.backward()