class_docstr: Creates a criterion that computes MSSIM + L1 loss.
  
  According to [1], we compute the MS_SSIM + L1 loss as follows:
  
  .. math::
      \text{loss}(x, y) = \alpha \cdot \mathcal{L_{MSSIM}}(x,y)+(1 - \alpha) \cdot G_\alpha \cdot \mathcal{L_1}(x,y)
  
  Where:
      - :math:`\alpha` is the weight parameter.
      - :math:`x` and :math:`y` are the reconstructed and true reference images.
      - :math:`\mathcal{L_{MSSIM}}` is the MS-SSIM loss.
      - :math:`G_\alpha` is the sigma values for computing multi-scale SSIM.
      - :math:`\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
  
  Args:
      sigmas: gaussian sigma values.
      data_range: the range of the images.
      K: k values.
      alpha : specifies the alpha value
      compensation: specifies the scaling coefficient.
      reduction : 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.
  
  Returns:
      The computed loss.
  
  Shape:
      - Input1: :math:`(N, C, H, W)`.
      - Input2: :math:`(N, C, H, W)`.
      - Output: :math:`(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)
docstr: Create 2-D gauss kernel.
  
  Args:
      size: the size of gauss kernel.
      sigma: sigma of normal distribution.
  
  Returns:
      2D kernel (size x size).
docstr_tok: ["Create","2-D","gauss","kernel",".","Args",":","size",":","the","size","of","gauss","kernel",".","sigma",":","sigma","of","normal","distribution",".","Returns",":","2D","kernel","(","size","x","size",")","."]
code: def _fspecial_gauss_2d(
      self,
      size: int,
      sigma: float,
      device: Optional[torch.device] = None,
      dtype: Optional[torch.dtype] = None,
  ) -> torch.Tensor:
      """Create 2-D gauss kernel.
  
      Args:
          size: the size of gauss kernel.
          sigma: sigma of normal distribution.
  
      Returns:
          2D kernel (size x size).
      """
      gaussian_vec = self._fspecial_gauss_1d(size, sigma, device, dtype)
      return torch.outer(gaussian_vec, gaussian_vec)
  
file_path: kornia/kornia/losses/ms_ssim.py
imports: from __future__ import annotations
  from typing import Optional
  import torch
  import torch.nn.functional
  from torch import nn
label_desc: Use image node_id 3 for calling the MS_SSIMLoss obj's underlying member method code with example usage: obj._fspecial_gauss_2d(size, sigma, device, dtype) and returns: torch