class_docstr: `Compute Peak Signal-to-Noise Ratio`_ (PSNR).
  
  .. math:: \text{PSNR}(I, J) = 10 * \log_{10} \left(\frac{\max(I)^2}{\text{MSE}(I, J)}\right)
  
  Where :math:`\text{MSE}` denotes the `mean-squared-error`_ function.
  
  As input to ``forward`` and ``update`` the metric accepts the following input
  
  - ``preds`` (:class:`~torch.Tensor`): Predictions from model of shape ``(N,C,H,W)``
  - ``target`` (:class:`~torch.Tensor`): Ground truth values of shape ``(N,C,H,W)``
  
  As output of `forward` and `compute` the metric returns the following output
  
  - ``psnr`` (:class:`~torch.Tensor`): if ``reduction!='none'`` returns float scalar tensor with average PSNR value
    over sample else returns tensor of shape ``(N,)`` with PSNR values per sample
  
  Args:
      data_range:
          the range of the data. If None, it is determined from the data (max - min). If a tuple is provided then
          the range is calculated as the difference and input is clamped between the values.
          The ``data_range`` must be given when ``dim`` is not None.
      base: a base of a logarithm to use.
      reduction: a method to reduce metric score over labels.
  
          - ``'elementwise_mean'``: takes the mean (default)
          - ``'sum'``: takes the sum
          - ``'none'`` or ``None``: no reduction will be applied
  
      dim:
          Dimensions to reduce PSNR scores over, provided as either an integer or a list of integers. Default is
          None meaning scores will be reduced across all dimensions and all batches.
      kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info.
  
  Raises:
      ValueError:
          If ``dim`` is not ``None`` and ``data_range`` is not given.
  
  Example:
      >>> from torchmetrics.image import PeakSignalNoiseRatio
      >>> psnr = PeakSignalNoiseRatio()
      >>> preds = torch.tensor([[0.0, 1.0], [2.0, 3.0]])
      >>> target = torch.tensor([[3.0, 2.0], [1.0, 0.0]])
      >>> psnr(preds, target)
      tensor(2.5527)
code: def __init__(
      self,
      data_range: Optional[Union[float, Tuple[float, float]]] = None,
      base: float = 10.0,
      reduction: Literal[
          "elementwise_mean", "sum", "none", None
      ] = "elementwise_mean",
      dim: Optional[Union[int, Tuple[int, ...]]] = None,
      **kwargs: Any,
  ) -> None:
      super().__init__(**kwargs)
  
      if dim is None and reduction != "elementwise_mean":
          rank_zero_warn(
              f"The `reduction={reduction}` will not have any effect when `dim` is None."
          )
  
      if dim is None:
          self.add_state(
              "sum_squared_error",
              default=tensor(0.0),
              dist_reduce_fx="sum",
          )
          self.add_state(
              "total", default=tensor(0), dist_reduce_fx="sum"
          )
      else:
          self.add_state(
              "sum_squared_error", default=[], dist_reduce_fx="cat"
          )
          self.add_state("total", default=[], dist_reduce_fx="cat")
  
      self.clamping_fn = None
      if data_range is None:
          if dim is not None:
              # Maybe we could use `torch.amax(target, dim=dim) - torch.amin(target, dim=dim)` in PyTorch 1.7 to
              # calculate `data_range` in the future.
              raise ValueError(
                  "The `data_range` must be given when `dim` is not None."
              )
  
          self.data_range = None
          self.add_state(
              "min_target",
              default=tensor(0.0),
              dist_reduce_fx=torch.min,
          )
          self.add_state(
              "max_target",
              default=tensor(0.0),
              dist_reduce_fx=torch.max,
          )
      elif isinstance(data_range, tuple):
          self.add_state(
              "data_range",
              default=tensor(data_range[1] - data_range[0]),
              dist_reduce_fx="mean",
          )
          self.clamping_fn = partial(
              torch.clamp, min=data_range[0], max=data_range[1]
          )
      else:
          self.add_state(
              "data_range",
              default=tensor(float(data_range)),
              dist_reduce_fx="mean",
          )
      self.base = base
      self.reduction = reduction
      self.dim = tuple(dim) if isinstance(dim, Sequence) else dim
  
file_path: torchmetrics/src/torchmetrics/image/psnr.py
imports: from functools import partial
  from typing import Any, Optional, Sequence, Tuple, Union
  import torch
  from torch import Tensor, tensor
  from typing_extensions import Literal
  from torchmetrics.functional.image.psnr import _psnr_compute, _psnr_update
  from torchmetrics.metric import Metric
  from torchmetrics.utilities import rank_zero_warn
  from torchmetrics.utilities.imports import _MATPLOTLIB_AVAILABLE
  from torchmetrics.utilities.plot import _AX_TYPE, _PLOT_OUT_TYPE
label_desc: Use image node_id 1 to create a new PeakSignalNoiseRatio object from inherited base classes: Metric with example: obj = PeakSignalNoiseRatio(data_range, base, reduction, dim)