code: def denormalize(
      data: torch.Tensor,
      mean: Union[torch.Tensor, float],
      std: Union[torch.Tensor, float],
  ) -> torch.Tensor:
      r"""Denormalize an image/video tensor with mean and standard deviation.
  
      .. math::
          \text{input[channel] = (input[channel] * std[channel]) + mean[channel]}
  
      Where `mean` is :math:`(M_1, ..., M_n)` and `std` :math:`(S_1, ..., S_n)` for `n` channels,
  
      Args:
          input: Image tensor of size :math:`(B, C, *)`.
          mean: Mean for each channel.
          std: Standard deviations for each channel.
  
      Return:
          Denormalised tensor with same size as input :math:`(B, C, *)`.
  
      Examples:
          >>> x = torch.rand(1, 4, 3, 3)
          >>> out = denormalize(x, 0.0, 255.)
          >>> out.shape
          torch.Size([1, 4, 3, 3])
  
          >>> x = torch.rand(1, 4, 3, 3, 3)
          >>> mean = torch.zeros(1, 4)
          >>> std = 255. * torch.ones(1, 4)
          >>> out = denormalize(x, mean, std)
          >>> out.shape
          torch.Size([1, 4, 3, 3, 3])
      """
      shape = data.shape
  
      if isinstance(mean, float):
          mean = torch.tensor(
              [mean] * shape[1], device=data.device, dtype=data.dtype
          )
  
      if isinstance(std, float):
          std = torch.tensor(
              [std] * shape[1], device=data.device, dtype=data.dtype
          )
  
      if not isinstance(data, torch.Tensor):
          raise TypeError(f"data should be a tensor. Got {type(data)}")
  
      if not isinstance(mean, torch.Tensor):
          raise TypeError(
              f"mean should be a tensor or a float. Got {type(mean)}"
          )
  
      if not isinstance(std, torch.Tensor):
          raise TypeError(
              f"std should be a tensor or float. Got {type(std)}"
          )
  
      # Allow broadcast on channel dimension
      if mean.shape and mean.shape[0] != 1:
          if (
              mean.shape[0] != data.shape[-3]
              and mean.shape[:2] != data.shape[:2]
          ):
              raise ValueError(
                  f"mean length and number of channels do not match. Got {mean.shape} and {data.shape}."
              )
  
      # Allow broadcast on channel dimension
      if std.shape and std.shape[0] != 1:
          if (
              std.shape[0] != data.shape[-3]
              and std.shape[:2] != data.shape[:2]
          ):
              raise ValueError(
                  f"std length and number of channels do not match. Got {std.shape} and {data.shape}."
              )
  
      mean = torch.as_tensor(mean, device=data.device, dtype=data.dtype)
      std = torch.as_tensor(std, device=data.device, dtype=data.dtype)
  
      if mean.shape:
          mean = mean[..., :, None]
      if std.shape:
          std = std[..., :, None]
  
      out: torch.Tensor = (
          data.view(shape[0], shape[1], -1) * std
      ) + mean
  
      return out.view(shape)
  
file_path: kornia/kornia/enhance/normalize.py
imports: from typing import List, Tuple, Union
  import torch
  from torch import nn
label_desc: Use image node_id 2 for calling a global function with example usage: denormalize(data, mean, std) and returns: out