code: def load(
      filepath: str,
      frame_offset: int = 0,
      num_frames: int = -1,
      normalize: bool = True,
      channels_first: bool = True,
      format: Optional[str] = None,
  ) -> Tuple[torch.Tensor, int]:
      """Load audio data from file.
  
      Note:
          The formats this function can handle depend on the soundfile installation.
          This function is tested on the following formats;
  
          * WAV
  
              * 32-bit floating-point
              * 32-bit signed integer
              * 16-bit signed integer
              * 8-bit unsigned integer
  
          * FLAC
          * OGG/VORBIS
          * SPHERE
  
      By default (``normalize=True``, ``channels_first=True``), this function returns Tensor with
      ``float32`` dtype, and the shape of `[channel, time]`.
  
      .. warning::
  
         ``normalize`` argument does not perform volume normalization.
         It only converts the sample type to `torch.float32` from the native sample
         type.
  
         When the input format is WAV with integer type, such as 32-bit signed integer, 16-bit
         signed integer, 24-bit signed integer, and 8-bit unsigned integer, by providing ``normalize=False``,
         this function can return integer Tensor, where the samples are expressed within the whole range
         of the corresponding dtype, that is, ``int32`` tensor for 32-bit signed PCM,
         ``int16`` for 16-bit signed PCM and ``uint8`` for 8-bit unsigned PCM. Since torch does not
         support ``int24`` dtype, 24-bit signed PCM are converted to ``int32`` tensors.
  
         ``normalize`` argument has no effect on 32-bit floating-point WAV and other formats, such as
         ``flac`` and ``mp3``.
  
         For these formats, this function always returns ``float32`` Tensor with values.
  
      Note:
          ``filepath`` argument is intentionally annotated as ``str`` only, even though it accepts
          ``pathlib.Path`` object as well. This is for the consistency with ``"sox_io"`` backend,
          which has a restriction on type annotation due to TorchScript compiler compatiblity.
  
      Args:
          filepath (path-like object or file-like object):
              Source of audio data.
          frame_offset (int, optional):
              Number of frames to skip before start reading data.
          num_frames (int, optional):
              Maximum number of frames to read. ``-1`` reads all the remaining samples,
              starting from ``frame_offset``.
              This function may return the less number of frames if there is not enough
              frames in the given file.
          normalize (bool, optional):
              When ``True``, this function converts the native sample type to ``float32``.
              Default: ``True``.
  
              If input file is integer WAV, giving ``False`` will change the resulting Tensor type to
              integer type.
              This argument has no effect for formats other than integer WAV type.
  
          channels_first (bool, optional):
              When True, the returned Tensor has dimension `[channel, time]`.
              Otherwise, the returned Tensor's dimension is `[time, channel]`.
          format (str or None, optional):
              Not used. PySoundFile does not accept format hint.
  
      Returns:
          (torch.Tensor, int): Resulting Tensor and sample rate.
              If the input file has integer wav format and normalization is off, then it has
              integer type, else ``float32`` type. If ``channels_first=True``, it has
              `[channel, time]` else `[time, channel]`.
      """
      with soundfile.SoundFile(filepath, "r") as file_:
          if file_.format != "WAV" or normalize:
              dtype = "float32"
          elif file_.subtype not in _SUBTYPE2DTYPE:
              raise ValueError(f"Unsupported subtype: {file_.subtype}")
          else:
              dtype = _SUBTYPE2DTYPE[file_.subtype]
  
          frames = file_._prepare_read(frame_offset, None, num_frames)
          waveform = file_.read(frames, dtype, always_2d=True)
          sample_rate = file_.samplerate
  
      waveform = torch.from_numpy(waveform)
      if channels_first:
          waveform = waveform.t()
      return waveform, sample_rate
  
file_path: audio/src/torchaudio/_backend/soundfile_backend.py
imports: import warnings
  from typing import Optional, Tuple
  import torch
  from torchaudio._internal import module_utils
  from .common import AudioMetaData
label_desc: Use image node_id 4 for calling a global function with example usage: load(filepath, frame_offset, num_frames, normalize, channels_first, format) and returns: waveform,  sample_rate