code: def compute_yin(
      sig,
      sr,
      w_len=512,
      w_step=256,
      f0_min=100,
      f0_max=500,
      harmo_thresh=0.1,
  ):
      """
  
      Compute the Yin Algorithm. Return fundamental frequency and harmonic rate.
  
      https://github.com/NVIDIA/mellotron adaption of
      https://github.com/patriceguyot/Yin
  
      :param sig: Audio signal (list of float)
      :param sr: sampling rate (int)
      :param w_len: size of the analysis window (samples)
      :param w_step: size of the lag between two consecutives windows (samples)
      :param f0_min: Minimum fundamental frequency that can be detected (hertz)
      :param f0_max: Maximum fundamental frequency that can be detected (hertz)
      :param harmo_thresh: Threshold of detection. The yalgorithmù return the
      first minimum of the CMND function below this threshold.
  
      :returns:
  
          * pitches: list of fundamental frequencies,
          * harmonic_rates: list of harmonic rate values for each fundamental
          frequency value (= confidence value)
          * argmins: minimums of the Cumulative Mean Normalized DifferenceFunction
          * times: list of time of each estimation
      :rtype: tuple
      """
  
      tau_min = int(sr / f0_max)
      tau_max = int(sr / f0_min)
  
      # time values for each analysis window
      time_scale = range(0, len(sig) - w_len, w_step)
      times = [t / float(sr) for t in time_scale]
      frames = [sig[t : t + w_len] for t in time_scale]
  
      pitches = [0.0] * len(time_scale)
      harmonic_rates = [0.0] * len(time_scale)
      argmins = [0.0] * len(time_scale)
  
      for i, frame in enumerate(frames):
          # Compute YIN
          df = difference_function(frame, w_len, tau_max)
          cm_df = cumulative_mean_normalized_difference_function(
              df, tau_max
          )
          p = get_pitch(cm_df, tau_min, tau_max, harmo_thresh)
  
          # Get results
          if np.argmin(cm_df) > tau_min:
              argmins[i] = float(sr / np.argmin(cm_df))
          if p != 0:  # A pitch was found
              pitches[i] = float(sr / p)
              harmonic_rates[i] = cm_df[p]
          else:  # No pitch, but we compute a value of the harmonic rate
              harmonic_rates[i] = min(cm_df)
  
      return pitches, harmonic_rates, argmins, times
  
file_path: fairseq/examples/speech_synthesis/evaluation/eval_f0.py
imports: import numpy
  import os.path
  import torchaudio
  import tqdm
  from tabulate import tabulate
  from examples.speech_synthesis.utils import gross_pitch_error, voicing_decision_error, f0_frame_error
  from examples.speech_synthesis.evaluation.eval_sp import load_eval_spec
label_desc: Use image node_id 4 for calling a global function with example usage: compute_yin(sig, sr, w_len, w_step, f0_min, f0_max, harmo_thresh) and returns: pitches,  harmonic_rates,  argmins,  times