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:
          This function can handle all the codecs that underlying libsox can handle,
          however it is tested on the following formats;
  
          * WAV, AMB
  
              * 32-bit floating-point
              * 32-bit signed integer
              * 24-bit signed integer
              * 16-bit signed integer
              * 8-bit unsigned integer (WAV only)
  
          * MP3
          * FLAC
          * OGG/VORBIS
          * OPUS
          * SPHERE
          * AMR-NB
  
          To load ``MP3``, ``FLAC``, ``OGG/VORBIS``, ``OPUS`` and other codecs ``libsox`` does not
          handle natively, your installation of ``torchaudio`` has to be linked to ``libsox``
          and corresponding codec libraries such as ``libmad`` or ``libmp3lame`` etc.
  
      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.
  
      Args:
          filepath (path-like object): Source of audio data.
          frame_offset (int):
              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):
              Override the format detection with the given format.
              Providing the argument might help when libsox can not infer the format
              from header or extension.
  
      Returns:
          (torch.Tensor, int): Resulting Tensor and sample rate.
              If the input file has integer wav format and ``normalize=False``, then it has
              integer type, else ``float32`` type. If ``channels_first=True``, it has
              `[channel, time]` else `[time, channel]`.
      """
      if not torch.jit.is_scripting():
          if hasattr(filepath, "read"):
              raise RuntimeError(
                  "sox_io backend does not support file-like object."
              )
          filepath = os.fspath(filepath)
      return sox_ext.load_audio_file(
          filepath,
          frame_offset,
          num_frames,
          normalize,
          channels_first,
          format,
      )
  
file_path: audio/src/torchaudio/backend/_sox_io_backend.py
imports: import os
  from typing import Optional, Tuple
  import torch
  import torchaudio
  from torchaudio import AudioMetaData
label_desc: Use image node_id 2 for calling a global function with example usage: load(filepath, frame_offset, num_frames, normalize, channels_first, format) and returns: sox_ext