code: def normalize_min_max(
      x: torch.Tensor,
      min_val: float = 0.0,
      max_val: float = 1.0,
      eps: float = 1e-6,
  ) -> torch.Tensor:
      r"""Normalise an image/video tensor by MinMax and re-scales the value between a range.
  
      The data is normalised using the following formulation:
  
      .. math::
          y_i = (b - a) * \frac{x_i - \text{min}(x)}{\text{max}(x) - \text{min}(x)} + a
  
      where :math:`a` is :math:`\text{min_val}` and :math:`b` is :math:`\text{max_val}`.
  
      Args:
          x: The image tensor to be normalised with shape :math:`(B, C, *)`.
          min_val: The minimum value for the new range.
          max_val: The maximum value for the new range.
          eps: Float number to avoid zero division.
  
      Returns:
          The normalised image tensor with same shape as input :math:`(B, C, *)`.
  
      Example:
          >>> x = torch.rand(1, 5, 3, 3)
          >>> x_norm = normalize_min_max(x, min_val=-1., max_val=1.)
          >>> x_norm.min()
          tensor(-1.)
          >>> x_norm.max()
          tensor(1.0000)
      """
      if not isinstance(x, torch.Tensor):
          raise TypeError(f"data should be a tensor. Got: {type(x)}.")
  
      if not isinstance(min_val, float):
          raise TypeError(
              f"'min_val' should be a float. Got: {type(min_val)}."
          )
  
      if not isinstance(max_val, float):
          raise TypeError(
              f"'b' should be a float. Got: {type(max_val)}."
          )
  
      if len(x.shape) < 3:
          raise ValueError(
              f"Input shape must be at least a 3d tensor. Got: {x.shape}."
          )
  
      shape = x.shape
      B, C = shape[0], shape[1]
  
      x_min: torch.Tensor = x.view(B, C, -1).min(-1)[0].view(B, C, 1)
      x_max: torch.Tensor = x.view(B, C, -1).max(-1)[0].view(B, C, 1)
  
      x_out: torch.Tensor = (max_val - min_val) * (
          x.view(B, C, -1) - x_min
      ) / (x_max - x_min + eps) + min_val
      return x_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 3 for calling a global function with example usage: normalize_min_max(x, min_val, max_val, eps) and returns: x_out