From c6eaa6f8d5ea97848657fc0bbb5c54a2cf13b485 Mon Sep 17 00:00:00 2001
From: Alain Riou <alain.riou14000@yahoo.com>
Date: Mon, 15 Jan 2024 19:02:07 +0100
Subject: [PATCH] make compatible with training code

---
 README.md                         |  54 ++++---
 pesto/__init__.py                 |   2 +-
 pesto/core.py                     | 186 +++++++++++-------------
 pesto/data.py                     | 109 +++++++-------
 pesto/loader.py                   |  51 +++++++
 pesto/main.py                     |   2 +-
 pesto/model.py                    | 232 +++++++++++++++++++++---------
 pesto/utils.py                    |  53 -------
 pesto/utils/__init__.py           |   4 +
 pesto/utils/crop_cqt.py           |  26 ++++
 pesto/{ => utils}/export.py       |   0
 pesto/{cqt.py => utils/hcqt.py}   |  36 +++++
 pesto/{ => utils}/parser.py       |   0
 pesto/utils/reduce_activations.py |  36 +++++
 pesto/weights/mir-1k.pth          | Bin 119669 -> 0 bytes
 15 files changed, 502 insertions(+), 289 deletions(-)
 create mode 100644 pesto/loader.py
 delete mode 100644 pesto/utils.py
 create mode 100644 pesto/utils/__init__.py
 create mode 100644 pesto/utils/crop_cqt.py
 rename pesto/{ => utils}/export.py (100%)
 rename pesto/{cqt.py => utils/hcqt.py} (91%)
 rename pesto/{ => utils}/parser.py (100%)
 create mode 100644 pesto/utils/reduce_activations.py
 delete mode 100644 pesto/weights/mir-1k.pth

diff --git a/README.md b/README.md
index f703e23..ac4d400 100644
--- a/README.md
+++ b/README.md
@@ -107,46 +107,64 @@ import pesto
 
 # predict the pitch of your audio tensors directly within your own Python code
 x, sr = torchaudio.load("my_file.wav")
-timesteps, pitch, confidence, activations = pesto.predict(x, sr, step_size=10.)
+x = x.mean(dim=0)  # PESTO takes mono audio as input
+timesteps, pitch, confidence, activations = pesto.predict(x, sr)
+
+# or predict using your own custom checkpoint
+predictions = pesto.predict(x, sr, model_name="/path/to/checkpoint.ckpt")
 
 # You can also predict pitches from audio files directly
-pesto.predict_from_files(["example1.wav", "example2.mp3", "example3.ogg"], step_size=10., export_format=["csv"])
+pesto.predict_from_files(["example1.wav", "example2.mp3", "example3.ogg"], export_format=["csv"])
 ```
+`pesto.predict` supports batched inputs, which should then have shape `(batch_size, num_samples)`.
+
+**Warning:** If you forget to convert a stereo audio in mono, channels will be treated as batch dimensions and you will 
+get predictions for each channel separately.
 
 #### Advanced usage
 
-If not provided,  `pesto.predict` will first load the CQT kernels and the model before performing 
+`pesto.predict` will first load the CQT kernels and the model before performing 
 any pitch estimation. If you want to process a significant number of files, calling `predict` several times will then 
 re-initialize the same model for each tensor.
 
-To avoid this time-consuming step, one can manually instantiate  the model   and data processor, then pass them directly 
-as args to the `predict` function. To do so, one has to use the underlying methods from `pesto.utils`:
+To avoid this time-consuming step, one can manually instantiate  the model with `load_model`,
+then call the forward method of the model instead:
 
 ```python
 import torch
 
-from pesto import predict
-from pesto.utils import load_model, load_dataprocessor
+from pesto import load_model
 
 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-model = load_model("mir-1k", device=device)
-data_processor = load_dataprocessor(step_size=0.01, device=device)
+pesto_model = load_model("mir-1k", step_size=20.).to(device)
 
 for x, sr in ...:
-    data_processor.sampling_rate = sr  # The data_processor handles waveform->CQT conversion so it must know the sampling rate
-    predictions = predict(x, sr, model=model)
+    x = x.to(device)
+    predictions, confidence, activations = pesto_model(x, sr)
     ...
 ```
-Note that when passing a list of files to `pesto.predict_from_files(...)` or the CLI directly, the model  is loaded only
-once so you don't have to bother with that in general.
 
-#### Batched pitch estimation
+Note that the `PESTO` object returned by `load_model` is a subclass of `nn.Module` 
+and its `forward` method also supports batched inputs.
+One can therefore easily integrate PESTO within their own architecture by doing:
+```python
+import torch
+import torch.nn as nn
 
-By default, the function `pesto.predict` takes an audio waveform represented as a Tensor object of shape `(num_channels, num_samples)`.
-However, one may want to estimate the pitch of batches of (cropped) waveforms within a training pipeline, e.g. for DDSP-related applications.
-`pesto.predict` therefore accepts Tensor inputs of shape `(batch_size, num_channels, num_samples)` and returns batch-wise pitch predictions accordingly.
+from pesto import load_model
 
-Note that batched predictions are available only from the Python API and not from the CLI because handling audios of different lengths is annoying, and I don't want to bother with that.
+
+class MyGreatModel(nn.Module):
+    def __init__(self, step_size, sr=44100, *args, **kwargs):
+        super(MyGreatModel, self).__init__()
+        self.f0_estimator = load_model("mir-1k", step_size, sampling_rate=sr)
+        ...
+
+    def forward(self, x):
+        with torch.no_grad():
+            f0, conf = self.f0_estimator(x, convert_to_freq=True, return_activations=False)
+        ...
+```
 
 ## Performances
 
diff --git a/pesto/__init__.py b/pesto/__init__.py
index 82a92f8..cff2aeb 100644
--- a/pesto/__init__.py
+++ b/pesto/__init__.py
@@ -1 +1 @@
-from .core import predict, predict_from_files
+from .core import load_model, predict, predict_from_files
diff --git a/pesto/core.py b/pesto/core.py
index 30e2e98..899baa6 100644
--- a/pesto/core.py
+++ b/pesto/core.py
@@ -1,38 +1,61 @@
 import os
 import warnings
-from typing import Optional, Sequence, Union
+from typing import Optional, Sequence, Tuple, Union
 
 import torch
 import torchaudio
 from tqdm import tqdm
 
-from .export import export
-from .utils import load_model, load_dataprocessor, reduce_activation
-
-
-def predict(
-        x: torch.Tensor,
-        sr: Optional[int] = None,
-        model: Union[torch.nn.Module, str] = "mir-1k",
-        data_preprocessor=None,
-        step_size: Optional[float] = None,
-        reduction: str = "argmax",
-        num_chunks: int = 1,
-        convert_to_freq: bool = False,
-        inference_mode: bool = True,
-        no_grad: bool = True
-):
+from .loader import load_model
+from .model import PESTO
+from .utils import export
+
+
+def _predict(x: torch.Tensor,
+             sr: int,
+             model: PESTO,
+             num_chunks: int = 1,
+             convert_to_freq: bool = True) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+    preds, confidence, activations = [], [], []
+    try:
+        for chunk in x.chunk(chunks=num_chunks):
+            pred, conf, act = model(chunk, sr=sr, convert_to_freq=convert_to_freq, return_activations=True)
+            preds.append(pred)
+            confidence.append(conf)
+            activations.append(act)
+    except torch.cuda.OutOfMemoryError:
+        raise torch.cuda.OutOfMemoryError("Got an out-of-memory error while performing pitch estimation. "
+                                          "Please increase the number of chunks with option `-c`/`--chunks` "
+                                          "to reduce GPU memory usage.")
+
+    preds = torch.cat(preds, dim=0)
+    confidence = torch.cat(confidence, dim=0)
+    activations = torch.cat(activations, dim=0)
+
+    # compute timesteps
+    timesteps = torch.arange(preds.size(-1), device=x.device) * model.hop_size
+
+    return timesteps, preds, confidence, activations
+
+
+def predict(x: torch.Tensor,
+            sr: int,
+            step_size: float = 10.,
+            model_name: str = "mir-1k",
+            reduction: str = "alwa",
+            num_chunks: int = 1,
+            convert_to_freq: bool = True,
+            inference_mode: bool = True,
+            no_grad: bool = True) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
     r"""Main prediction function.
 
     Args:
-        x (torch.Tensor): input audio tensor,
-            shape (num_channels, num_samples) or (batch_size, num_channels, num_samples)
+        x (torch.Tensor): input audio tensor, can be provided as a batch but should be mono,
+            shape (num_samples) or (batch_size, num_samples)
         sr (int, optional): sampling rate. If not specified, uses the current sampling rate of the model.
-        model: PESTO model. If a string is passed, it will load the model with the corresponding name.
-            Otherwise, the actual nn.Module will be used for doing predictions.
-        data_preprocessor: Module handling the data processing pipeline (waveform to CQT, cropping, etc.)
         step_size (float, optional): step size between each CQT frame in milliseconds.
-            If the data_preprocessor is passed, its value will be used instead.
+            If a `PESTO` object is passed as `model`, this will be ignored.
+        model_name: name of PESTO model. Can be a path to a custom PESTO checkpoint or the name of a standard model.
         reduction (str): reduction method for converting activation probabilities to log-frequencies.
         num_chunks (int): number of chunks to split the input audios in.
             Default is 1 (all CQT frames in parallel) but it can be increased to reduce memory usage
@@ -40,58 +63,25 @@ def predict(
         convert_to_freq (bool): whether predictions should be converted to frequencies or not.
         inference_mode (bool): whether to run with `torch.inference_mode`.
         no_grad (bool): whether to run with `torch.no_grad`. If set to `False`, argument `inference_mode` is ignored.
+
+    Returns:
+        timesteps (torch.Tensor): timesteps corresponding to each pitch prediction, shape (num_timesteps)
+        preds (torch.Tensor): pitch predictions in SEMITONES, shape (batch_size?, num_timesteps)
+            where `num_timesteps` ~= `num_samples` / (`self.hop_size` * `sr`)
+        confidence (torch.Tensor): confidence of whether frame is voiced or unvoiced in [0, 1],
+            shape (batch_size?, num_timesteps)
+        activations (torch.Tensor): activations of the model, shape (batch_size?, num_timesteps, output_dim)
     """
+    # sanity checks
+    assert x.ndim <= 2, \
+        f"Audio file should have shape (num_samples) or (batch_size, num_samples), but found shape {x.size()}."
+
     inference_mode = inference_mode and no_grad
     with torch.no_grad() if no_grad and not inference_mode else torch.inference_mode(mode=inference_mode):
-        # convert to mono
-        assert 2 <= x.ndim <= 3, f"Audio file should have two dimensions, but found shape {x.size()}"
-        batch_size = x.size(0) if x.ndim == 3 else None
-        x = x.mean(dim=-2)
-
-        if data_preprocessor is None:
-            assert step_size is not None and sr is not None, \
-                "If you don't use a predefined data preprocessor, you must at least indicate a step size (in milliseconds)"
-            data_preprocessor = load_dataprocessor(step_size=step_size / 1000., sampling_rate=sr, device=x.device)
-
-        # If the sampling rate has changed, change the sampling rate accordingly
-        # It will automatically recompute the CQT kernels if needed
-        if sr is not None:
-            data_preprocessor.sampling_rate = sr
-
-        if isinstance(model, str):
-            model = load_model(model, device=x.device)
+        model = load_model(model_name, step_size, sampling_rate=sr).to(x.device)
+        model.reduction = reduction
 
-        # apply model
-        cqt = data_preprocessor(x)
-        try:
-            activations = torch.cat([
-                model(chunk) for chunk in cqt.chunk(chunks=num_chunks)
-            ])
-        except torch.cuda.OutOfMemoryError:
-            raise torch.cuda.OutOfMemoryError("Got an out-of-memory error while performing pitch estimation. "
-                                              "Please increase the number of chunks with option `-c`/`--chunks` "
-                                              "to reduce GPU memory usage.")
-
-        if batch_size:
-            total_batch_size, num_predictions = activations.size()
-            activations = activations.view(batch_size, total_batch_size // batch_size, num_predictions)
-
-        # shift activations as it should (PESTO predicts pitches up to an additive constant)
-        activations = activations.roll(model.abs_shift.cpu().item(), dims=-1)
-
-        # convert model predictions to pitch values
-        pitch = reduce_activation(activations, reduction=reduction)
-        if convert_to_freq:
-            pitch = 440 * 2 ** ((pitch - 69) / 12)
-
-        # for now, confidence is computed very naively just based on volume
-        confidence = cqt.squeeze(1).max(dim=1).values.view_as(pitch)
-        conf_min, conf_max = confidence.min(dim=-1, keepdim=True).values, confidence.max(dim=-1, keepdim=True).values
-        confidence = (confidence - conf_min) / (conf_max - conf_min)
-
-        timesteps = torch.arange(pitch.size(-1), device=x.device) * data_preprocessor.step_size
-
-    return timesteps, pitch, confidence, activations
+        return _predict(x, sr, model, num_chunks=num_chunks, convert_to_freq=convert_to_freq)
 
 
 def predict_from_files(
@@ -113,12 +103,11 @@ def predict_from_files(
         output:
         step_size: hop length in milliseconds
         reduction:
-        export_format:
+        export_format (Sequence[str]): format to export the predictions to.
+            Currently formats supported are: ["csv", "npz", "json"].
         no_convert_to_freq: whether convert output values to Hz or keep fractional MIDI pitches
+        num_chunks (int): number of chunks to divide the inputs into. Increase this value if you encounter OOM errors.
         gpu: index of GPU to use (-1 for CPU)
-
-    Returns:
-        Pitch predictions, see `predict` for more details.
     """
     if isinstance(audio_files, str):
         audio_files = [audio_files]
@@ -128,37 +117,34 @@ def predict_from_files(
         gpu = -1
     device = torch.device(f"cuda:{gpu:d}" if gpu >= 0 else "cpu")
 
-    # define data preprocessing
-    data_preprocessor = load_dataprocessor(step_size / 1000., device=device)
-
     # define model
-    model = load_model(model_name, device=device)
-    predictions = None
+    model = load_model(model_name, step_size=step_size).to(device)
+    model.reduction = reduction
 
     pbar = tqdm(audio_files)
-    for file in pbar:
-        pbar.set_description(file)
 
-        # load audio file
-        try:
-            x, sr = torchaudio.load(file)
-        except Exception as e:
-            print(e, f"Skipping {file}...")
-            continue
+    with torch.inference_mode():  # here the purpose is to write results in disk, so there is no point storing gradients
+        for file in pbar:
+            pbar.set_description(file)
+
+            # load audio file
+            try:
+                x, sr = torchaudio.load(file)
+            except Exception as e:
+                print(e, f"Skipping {file}...")
+                continue
 
-        x = x.to(device)
+            x = x.mean(dim=0).to(device)  # convert to mono then pass to the right device
 
-        # compute the predictions
-        predictions = predict(x, sr, model=model, data_preprocessor=data_preprocessor, reduction=reduction,
-                              convert_to_freq=not no_convert_to_freq, num_chunks=num_chunks)
+            # compute the predictions
+            predictions = _predict(x, sr, model=model, convert_to_freq=not no_convert_to_freq, num_chunks=num_chunks)
 
-        output_file = file.rsplit('.', 1)[0] + "." + ("semitones" if no_convert_to_freq else "f0")
-        if output is not None:
-            os.makedirs(output, exist_ok=True)
-            output_file = os.path.join(output, os.path.basename(output_file))
+            output_file = file.rsplit('.', 1)[0] + "." + ("semitones" if no_convert_to_freq else "f0")
+            if output is not None:
+                os.makedirs(output, exist_ok=True)
+                output_file = os.path.join(output, os.path.basename(output_file))
 
-        predictions = [p.cpu().numpy() for p in predictions]
-        for fmt in export_format:
-            export(fmt, output_file, *predictions)
+            predictions = [p.cpu().numpy() for p in predictions]
+            for fmt in export_format:
+                export(fmt, output_file, *predictions)
 
-    return predictions
diff --git a/pesto/data.py b/pesto/data.py
index f5ed52e..7d8b81d 100644
--- a/pesto/data.py
+++ b/pesto/data.py
@@ -3,79 +3,92 @@ from typing import Optional
 import torch
 import torch.nn as nn
 
-from .cqt import CQT
+from .utils import HarmonicCQT
 
 
-class DataProcessor(nn.Module):
+class ToLogMagnitude(nn.Module):
+    def __init__(self):
+        super(ToLogMagnitude, self).__init__()
+        self.eps = torch.finfo(torch.float32).eps
+
+    def forward(self, x):
+        x = x.abs()
+        x.clamp_(min=self.eps).log10_().mul_(20)
+        return x
+
+
+
+class Preprocessor(nn.Module):
     r"""
 
     Args:
-        step_size (float): step size between consecutive CQT frames (in SECONDS)
+        hop_size (float): step size between consecutive CQT frames (in milliseconds)
     """
-    _sampling_rate: Optional[int] = None
-
     def __init__(self,
-                 step_size: float,
-                 bins_per_semitone: int = 3,
+                 hop_size: float,
                  sampling_rate: Optional[int] = None,
-                 **cqt_kwargs):
-        super(DataProcessor, self).__init__()
-        self.step_size = step_size
-        self.bins_per_semitone = bins_per_semitone
+                 **hcqt_kwargs):
+        super(Preprocessor, self).__init__()
 
-        # CQT-related stuff
-        self.cqt_kwargs = cqt_kwargs
-        self.cqt_kwargs["bins_per_octave"] = 12 * bins_per_semitone
-        self.cqt = None
+        # HCQT
+        self.hcqt_sr = None
+        self.hcqt_kernels = None
+        self.hop_size = hop_size
 
-        # log-magnitude
-        self.eps = torch.finfo(torch.float32).eps
+        self.hcqt_kwargs = hcqt_kwargs
 
-        # cropping
-        self.lowest_bin = int(11 * self.bins_per_semitone / 2 + 0.5)
-        self.highest_bin = self.lowest_bin + 88 * self.bins_per_semitone
+        # log-magnitude
+        self.to_log = ToLogMagnitude()
 
         # register a dummy tensor to get implicit access to the module's device
         self.register_buffer("_device", torch.zeros(()), persistent=False)
 
-        # sampling rate is lazily initialized
+        # if the sampling rate is provided, instantiate the CQT kernels
         if sampling_rate is not None:
-            self.sampling_rate = sampling_rate
+            self.hcqt_sr = sampling_rate
+            self._reset_hcqt_kernels()
 
-    def forward(self, x: torch.Tensor):
+    def forward(self, x: torch.Tensor, sr: Optional[int] = None) -> torch.Tensor:
         r"""
 
         Args:
-            x: audio waveform, any sampling rate, shape (num_samples)
+            x (torch.Tensor): audio waveform or batch of audio waveforms, any sampling rate,
+                shape (batch_size?, num_samples)
+            sr (int, optional): sampling rate
 
         Returns:
-            log-magnitude CQT, shape (
+            torch.Tensor: log-magnitude CQT of batch of CQTs,
+                shape (batch_size?, num_timesteps, num_harmonics, num_freqs)
         """
-        # compute CQT from input waveform, and invert dims for (batch_size, time_steps, freq_bins)
-        complex_cqt = torch.view_as_complex(self.cqt(x)).transpose(1, 2)
-
-        # reshape and crop borders to fit training input shape
-        complex_cqt = complex_cqt[..., self.lowest_bin: self.highest_bin]
-
-        # flatten eventual batch dimensions so that batched audios can be processed in parallel
-        complex_cqt = complex_cqt.flatten(0, 1).unsqueeze(1)
+        # compute CQT from input waveform, and invert dims for (time_steps, num_harmonics, freq_bins)
+        # in other words, time becomes the batch dimension, enabling efficient processing for long audios.
+        complex_cqt = torch.view_as_complex(self.hcqt(x, sr=sr)).permute(0, 3, 1, 2)
 
         # convert to dB
-        log_cqt = complex_cqt.abs().clamp_(min=self.eps).log10_().mul_(20)
-        return log_cqt
-
-    def _init_cqt_layer(self, sr: int, hop_length: int):
-        self.cqt = CQT(sr=sr, hop_length=hop_length, **self.cqt_kwargs).to(self._device.device)
+        return self.to_log(complex_cqt)
 
-    @property
-    def sampling_rate(self) -> int:
-        return self._sampling_rate
+    def hcqt(self, audio: torch.Tensor, sr: Optional[int] = None) -> torch.Tensor:
+        r"""Compute the Harmonic CQT of the input audio after eventually recreating the kernels
+        (in case the sampling rate has changed).
 
-    @sampling_rate.setter
-    def sampling_rate(self, sr: int) -> None:
-        if sr == self._sampling_rate:
-            return
+        Args:
+            audio (torch.Tensor): mono audio waveform, shape (batch_size, num_samples)
+            sr (int): sampling rate of the audio waveform.
+                If not specified, we assume it is the same as the previous processed audio waveform.
 
-        hop_length = int(self.step_size * sr + 0.5)
-        self._init_cqt_layer(sr, hop_length)
-        self._sampling_rate = sr
+        Returns:
+            torch.Tensor: Complex Harmonic CQT (HCQT) of the input,
+                shape (batch_size, num_harmonics, num_freqs, num_timesteps, 2)
+        """
+        # compute HCQT kernels if it does not exist or if the sampling rate has changed
+        if sr is not None and sr != self.hcqt_sr:
+            self.hcqt_sr = sr
+            self._reset_hcqt_layer()
+
+        return self.hcqt_kernels(audio)
+
+    def _reset_hcqt_layer(self) -> None:
+        hop_length = int(self.hop_size * self.hcqt_sr / 1000 + 0.5)
+        self.hcqt_kernels = HarmonicCQT(sr=self.hcqt_sr,
+                                        hop_length=hop_length,
+                                        **self.hcqt_kwargs).to(self._device.device)
diff --git a/pesto/loader.py b/pesto/loader.py
new file mode 100644
index 0000000..609d4b5
--- /dev/null
+++ b/pesto/loader.py
@@ -0,0 +1,51 @@
+import os
+from typing import Optional
+
+import torch
+
+from .data import Preprocessor
+from .model import PESTO, Resnet1d
+
+
+def load_model(checkpoint: str,
+               step_size: float,
+               sampling_rate: Optional[int] = None) -> PESTO:
+    r"""Load a trained model from a checkpoint file.
+    See https://github.com/SonyCSLParis/pesto-full/blob/master/src/models/pesto.py for the structure of the checkpoint.
+
+    Args:
+        checkpoint (str): path to the checkpoint or name of the checkpoint file (if using a provided checkpoint)
+        step_size (float): hop size in milliseconds
+        sampling_rate (int, optional): sampling rate of the audios.
+            If not provided, it can be inferred dynamically as well.
+    Returns:
+        PESTO: instance of PESTO model
+    """
+    if os.path.exists(checkpoint):  # handle user-provided checkpoints
+        model_path = checkpoint
+    else:
+        model_path = os.path.join(os.path.dirname(__file__), "weights", checkpoint + ".pth")
+        if not os.path.exists(model_path):
+            raise FileNotFoundError(f"You passed an invalid checkpoint file: {checkpoint}.")
+
+    # load checkpoint
+    checkpoint = torch.load(model_path, map_location=torch.device("cpu"))
+    hparams = checkpoint["hparams"]
+    hcqt_params = checkpoint["hcqt_params"]
+    state_dict = checkpoint["state_dict"]
+
+    # instantiate preprocessor
+    preprocessor = Preprocessor(hop_size=step_size, sampling_rate=sampling_rate, **hcqt_params)
+
+    # instantiate PESTO encoder
+    encoder = Resnet1d(**hparams["encoder"])
+
+    # instantiate main PESTO module and load its weights
+    model = PESTO(encoder,
+                  preprocessor=preprocessor,
+                  crop_kwargs=hparams["pitch_shift"],
+                  reduction=hparams["reduction"])
+    model.load_state_dict(state_dict)
+    model.eval()
+
+    return model
diff --git a/pesto/main.py b/pesto/main.py
index bc52df6..d117941 100644
--- a/pesto/main.py
+++ b/pesto/main.py
@@ -1,4 +1,4 @@
-from .parser import parse_args
+from pesto.utils.parser import parse_args
 from .core import predict_from_files
 
 
diff --git a/pesto/model.py b/pesto/model.py
index 94337ec..27edd93 100644
--- a/pesto/model.py
+++ b/pesto/model.py
@@ -1,8 +1,15 @@
 from functools import partial
+from typing import Any, Mapping, Optional, Tuple, Union
 
 import torch
 import torch.nn as nn
 
+from .utils import CropCQT
+from .utils import reduce_activations
+
+
+OUTPUT_TYPE = Union[Tuple[torch.Tensor, torch.Tensor], Tuple[torch.Tensor, torch.Tensor, torch.Tensor]]
+
 
 class ToeplitzLinear(nn.Conv1d):
     def __init__(self, in_features, out_features):
@@ -18,7 +25,7 @@ class ToeplitzLinear(nn.Conv1d):
         return super(ToeplitzLinear, self).forward(input.unsqueeze(-2)).squeeze(-2)
 
 
-class PESTOEncoder(nn.Module):
+class Resnet1d(nn.Module):
     """
     Basic CNN similar to the one in Johannes Zeitler's report,
     but for longer HCQT input (always stride 1 in time)
@@ -29,7 +36,8 @@ class PESTOEncoder(nn.Module):
     not over time (in order to work with variable length input).
     Outputs one channel with sigmoid activation.
 
-    Args (Defaults: BasicCNN by Johannes Zeitler but with 1 input channel):
+    Args (Defaults: BasicCNN by Johannes Zeitler but with 6 input channels):
+        n_chan_input:     Number of input channels (harmonics in HCQT)
         n_chan_layers:    Number of channels in the hidden layers (list)
         n_prefilt_layers: Number of repetitions of the prefiltering layer
         residual:         If True, use residual connections for prefiltering (default: False)
@@ -39,100 +47,188 @@ class PESTOEncoder(nn.Module):
         p_dropout:        Dropout probability
     """
 
-    def __init__(
-            self,
-            n_chan_layers=(20, 20, 10, 1),
-            n_prefilt_layers=1,
-            residual=False,
-            n_bins_in=216,
-            output_dim=128,
-            num_output_layers: int = 1
-    ):
-        super(PESTOEncoder, self).__init__()
-
-        activation_layer = partial(nn.LeakyReLU, negative_slope=0.3)
-
+    def __init__(self,
+                 n_chan_input=1,
+                 n_chan_layers=(20, 20, 10, 1),
+                 n_prefilt_layers=1,
+                 prefilt_kernel_size=15,
+                 residual=False,
+                 n_bins_in=216,
+                 output_dim=128,
+                 activation_fn: str = "leaky",
+                 a_lrelu=0.3,
+                 p_dropout=0.2):
+        super(Resnet1d, self).__init__()
+
+        self.hparams = dict(n_chan_input=n_chan_input,
+                            n_chan_layers=n_chan_layers,
+                            n_prefilt_layers=n_prefilt_layers,
+                            prefilt_kernel_size=prefilt_kernel_size,
+                            residual=residual,
+                            n_bins_in=n_bins_in,
+                            output_dim=output_dim,
+                            activation_fn=activation_fn,
+                            a_lrelu=a_lrelu,
+                            p_dropout=p_dropout)
+
+        if activation_fn == "relu":
+            activation_layer = nn.ReLU
+        elif activation_fn == "silu":
+            activation_layer = nn.SiLU
+        elif activation_fn == "leaky":
+            activation_layer = partial(nn.LeakyReLU, negative_slope=a_lrelu)
+        else:
+            raise ValueError
+
+        n_in = n_chan_input
         n_ch = n_chan_layers
         if len(n_ch) < 5:
             n_ch.append(1)
 
-        # Layer normalization over frequency
-        self.layernorm = nn.LayerNorm(normalized_shape=[1, n_bins_in])
+        # Layer normalization over frequency and channels (harmonics of HCQT)
+        self.layernorm = nn.LayerNorm(normalized_shape=[n_in, n_bins_in])
 
         # Prefiltering
+        prefilt_padding = prefilt_kernel_size // 2
         self.conv1 = nn.Sequential(
-            nn.Conv1d(in_channels=1, out_channels=n_ch[0], kernel_size=15, padding=7, stride=1),
-            activation_layer()
+            nn.Conv1d(in_channels=n_in,
+                      out_channels=n_ch[0],
+                      kernel_size=prefilt_kernel_size,
+                      padding=prefilt_padding,
+                      stride=1),
+            activation_layer(),
+            nn.Dropout(p=p_dropout)
         )
         self.n_prefilt_layers = n_prefilt_layers
-        self.prefilt_list = nn.ModuleList()
-        for p in range(1, n_prefilt_layers):
-            self.prefilt_list.append(nn.Sequential(
-                nn.Conv1d(in_channels=n_ch[0], out_channels=n_ch[0], kernel_size=15, padding=7, stride=1),
-                activation_layer()
-            ))
+        self.prefilt_layers = nn.ModuleList(*[
+            nn.Sequential(
+                nn.Conv1d(in_channels=n_ch[0],
+                          out_channels=n_ch[0],
+                          kernel_size=prefilt_kernel_size,
+                          padding=prefilt_padding,
+                          stride=1),
+                activation_layer(),
+                nn.Dropout(p=p_dropout)
+            )
+            for _ in range(n_prefilt_layers-1)
+        ])
         self.residual = residual
 
-        self.conv2 = nn.Sequential(
-            nn.Conv1d(
-                in_channels=n_ch[0],
-                out_channels=n_ch[1],
-                kernel_size=1,
-                stride=1,
-                padding=0
-            ),
-            activation_layer()
-        )
-
-        self.conv3 = nn.Sequential(
-            nn.Conv1d(in_channels=n_ch[1], out_channels=n_ch[2], kernel_size=1, padding=0, stride=1),
-            activation_layer()
-        )
-
-        self.conv4 = nn.Sequential(
-            nn.Conv1d(in_channels=n_ch[2], out_channels=n_ch[3], kernel_size=1, padding=0, stride=1),
-            activation_layer(),
-            nn.Dropout(),
-            nn.Conv1d(in_channels=n_ch[3], out_channels=n_ch[4], kernel_size=1, padding=0, stride=1)
-        )
+        conv_layers = []
+        for i in range(len(n_chan_layers)-1):
+            conv_layers.extend([
+                nn.Conv1d(in_channels=n_ch[i],
+                          out_channels=n_ch[i + 1],
+                          kernel_size=1,
+                          padding=0,
+                          stride=1),
+                activation_layer(),
+                nn.Dropout(p=p_dropout)
+            ])
+        self.conv_layers = nn.Sequential(*conv_layers)
 
         self.flatten = nn.Flatten(start_dim=1)
-
-        layers = []
-        pre_fc_dim = n_bins_in * n_ch[4]
-        for i in range(num_output_layers-1):
-            layers.extend([
-                ToeplitzLinear(pre_fc_dim, pre_fc_dim),
-                activation_layer()
-            ])
-        self.pre_fc = nn.Sequential(*layers)
-        self.fc = ToeplitzLinear(pre_fc_dim, output_dim)
+        self.fc = ToeplitzLinear(n_bins_in * n_ch[-1], output_dim)
 
         self.final_norm = nn.Softmax(dim=-1)
 
-        self.register_buffer("abs_shift", torch.zeros((), dtype=torch.long), persistent=True)
-
     def forward(self, x):
         r"""
 
         Args:
             x (torch.Tensor): shape (batch, channels, freq_bins)
         """
-        x_norm = self.layernorm(x)
+        x = self.layernorm(x)
 
-        x = self.conv1(x_norm)
+        x = self.conv1(x)
         for p in range(0, self.n_prefilt_layers - 1):
-            prefilt_layer = self.prefilt_list[p]
+            prefilt_layer = self.prefilt_layers[p]
             if self.residual:
                 x_new = prefilt_layer(x)
                 x = x_new + x
             else:
                 x = prefilt_layer(x)
-        conv2_lrelu = self.conv2(x)
-        conv3_lrelu = self.conv3(conv2_lrelu)
 
-        y_pred = self.conv4(conv3_lrelu)
-        y_pred = self.flatten(y_pred)
-        y_pred = self.pre_fc(y_pred)
-        y_pred = self.fc(y_pred)
+        x = self.conv_layers(x)
+        x = self.flatten(x)
+
+        y_pred = self.fc(x)
+
         return self.final_norm(y_pred)
+
+
+class PESTO(nn.Module):
+    def __init__(self,
+                 encoder: nn.Module,
+                 preprocessor: nn.Module,
+                 crop_kwargs: Mapping[str, Any] | None = None,
+                 reduction: str = "alwa"):
+        super(PESTO, self).__init__()
+        self.encoder = encoder
+        self.preprocessor = preprocessor
+
+        # crop CQT
+        if crop_kwargs is None:
+            crop_kwargs = {}
+        self.crop_cqt = CropCQT(**crop_kwargs)
+
+        self.reduction = reduction
+
+        # constant shift to get absolute pitch from predictions
+        self.register_buffer('shift', torch.zeros((), dtype=torch.float), persistent=True)
+
+    def forward(self,
+                audio_waveforms: torch.Tensor,
+                sr: Optional[int] = None,
+                convert_to_freq: bool = False,
+                return_activations: bool = False) -> OUTPUT_TYPE:
+        r"""
+
+        Args:
+            audio_waveforms (torch.Tensor): mono audio waveform or batch of mono audio waveforms,
+                shape (batch_size?, num_samples)
+            sr (int, optional): sampling rate, defaults to the previously used sampling rate
+            convert_to_freq (bool): whether to convert the result to frequencies or return fractional semitones instead.
+            return_activations (bool): whether to return activations or pitch predictions only
+
+        Returns:
+            preds (torch.Tensor): pitch predictions in SEMITONES, shape (batch_size?, num_timesteps)
+                where `num_timesteps` ~= `num_samples` / (`self.hop_size` * `sr`)
+            confidence (torch.Tensor): confidence of whether frame is voiced or unvoiced in [0, 1],
+                shape (batch_size?, num_timesteps)
+            activations (torch.Tensor): activations of the model, shape (batch_size?, num_timesteps, output_dim)
+        """
+        batch_size = audio_waveforms.size(0) if audio_waveforms.ndim == 2 else None
+        x = self.preprocessor(audio_waveforms, sr=sr)
+        x = self.crop_cqt(x)  # the CQT has to be cropped beforehand
+
+        # for now, confidence is computed very naively just based on energy in the CQT
+        confidence = x.mean(dim=-2).max(dim=-1).values
+        conf_min, conf_max = confidence.min(dim=-1, keepdim=True).values, confidence.max(dim=-1, keepdim=True).values
+        confidence = (confidence - conf_min) / (conf_max - conf_min)
+
+        # flatten batch_size and time_steps since anyway predictions are made on CQT frames independently
+        if batch_size:
+            x = x.flatten(0, 1)
+
+        activations = self.encoder(x)
+        if batch_size:
+            activations = activations.view(batch_size, -1, activations.size(-1))
+
+        preds = reduce_activations(activations, reduction=self.reduction)
+
+        # decrease by shift to get absolute pitch
+        preds.sub_(self.shift)
+
+        if convert_to_freq:
+            preds = 440 * 2 ** ((preds - 69) / 12)
+
+        if return_activations:
+            return preds, confidence, activations
+
+        return preds, confidence
+
+    @property
+    def hop_size(self) -> float:
+        r"""Returns the hop size of the model (in milliseconds)"""
+        return self.preprocessor.hop_size
diff --git a/pesto/utils.py b/pesto/utils.py
deleted file mode 100644
index 1872260..0000000
--- a/pesto/utils.py
+++ /dev/null
@@ -1,53 +0,0 @@
-import os
-from typing import Optional
-
-import torch
-
-from .config import model_args, cqt_args, bins_per_semitone
-from .data import DataProcessor
-from .model import PESTOEncoder
-
-
-def load_dataprocessor(step_size, sampling_rate: Optional[int] = None, device: Optional[torch.device] = None):
-    return DataProcessor(step_size=step_size, sampling_rate=sampling_rate, **cqt_args).to(device)
-
-
-def load_model(model_name: str, device: Optional[torch.device] = None) -> PESTOEncoder:
-    model = PESTOEncoder(**model_args).to(device)
-    model.eval()
-
-    model_path = os.path.join(os.path.dirname(__file__), "weights", model_name + ".pth")
-    model.load_state_dict(torch.load(model_path, map_location=device))
-
-    return model
-
-
-def reduce_activation(activations: torch.Tensor, reduction: str) -> torch.Tensor:
-    r"""Computes the pitch predictions from the activation outputs of the encoder.
-    Pitch predictions are returned in semitones, NOT in frequencies.
-
-    Args:
-        activations: tensor of probability activations, shape (*, num_bins)
-        reduction:
-
-    Returns:
-        torch.Tensor: pitch predictions, shape (*,)
-    """
-    bps = bins_per_semitone
-    if reduction == "argmax":
-        pred = activations.argmax(dim=-1)
-        return pred.float() / bps
-
-    all_pitches = (torch.arange(activations.size(-1), dtype=torch.float, device=activations.device)) / bps
-    if reduction == "mean":
-        return activations @ all_pitches
-
-    if reduction == "alwa":  # argmax-local weighted averaging, see https://github.com/marl/crepe
-        center_bin = activations.argmax(dim=-1, keepdim=True)
-        window = torch.arange(-bps+1, bps, device=activations.device)
-        indices = window + center_bin
-        cropped_activations = activations.gather(-1, indices)
-        cropped_pitches = all_pitches.unsqueeze(0).expand_as(activations).gather(-1, indices)
-        return (cropped_activations * cropped_pitches).sum(dim=-1) / cropped_activations.sum(dim=-1)
-
-    raise ValueError
diff --git a/pesto/utils/__init__.py b/pesto/utils/__init__.py
new file mode 100644
index 0000000..9be9b1b
--- /dev/null
+++ b/pesto/utils/__init__.py
@@ -0,0 +1,4 @@
+from .crop_cqt import CropCQT
+from .export import export
+from .hcqt import HarmonicCQT
+from .reduce_activations import reduce_activations
\ No newline at end of file
diff --git a/pesto/utils/crop_cqt.py b/pesto/utils/crop_cqt.py
new file mode 100644
index 0000000..65829c7
--- /dev/null
+++ b/pesto/utils/crop_cqt.py
@@ -0,0 +1,26 @@
+import torch
+import torch.nn as nn
+
+
+class CropCQT(nn.Module):
+    def __init__(self, min_steps: int, max_steps: int):
+        super(CropCQT, self).__init__()
+        self.min_steps = min_steps
+        self.max_steps = max_steps
+
+        # lower bin
+        self.lower_bin = self.max_steps
+
+    def forward(self, spectrograms: torch.Tensor) -> torch.Tensor:
+        # WARNING: didn't check that it works, it may be dangerous
+        return spectrograms[..., self.max_steps: self.min_steps]
+
+        # old implementation
+        batch_size, _, input_height = spectrograms.size()
+
+        output_height = input_height - self.max_steps + self.min_steps
+        assert output_height > 0, \
+            f"With input height {input_height:d} and output height {output_height:d}, impossible " \
+            f"to have a range of {self.max_steps - self.min_steps:d} bins."
+
+        return spectrograms[..., self.lower_bin: self.lower_bin + output_height]
diff --git a/pesto/export.py b/pesto/utils/export.py
similarity index 100%
rename from pesto/export.py
rename to pesto/utils/export.py
diff --git a/pesto/cqt.py b/pesto/utils/hcqt.py
similarity index 91%
rename from pesto/cqt.py
rename to pesto/utils/hcqt.py
index 6fdfccb..4c92564 100644
--- a/pesto/cqt.py
+++ b/pesto/utils/hcqt.py
@@ -354,3 +354,39 @@ class CQT(nn.Module):
             phase_real = torch.cos(torch.atan2(CQT_imag, CQT_real))
             phase_imag = torch.sin(torch.atan2(CQT_imag, CQT_real))
             return torch.stack((phase_real, phase_imag), -1)
+
+
+class HarmonicCQT(nn.Module):
+    r"""Harmonic CQT layer, as described in Bittner et al. (20??)"""
+    def __init__(
+            self,
+            harmonics,
+            sr: int = 22050,
+            hop_length: int = 512,
+            fmin: float = 32.7,
+            fmax: float | None = None,
+            bins_per_semitone: int = 1,
+            n_bins: int = 84,
+            center_bins: bool = True
+    ):
+        super(HarmonicCQT, self).__init__()
+
+        if center_bins:
+            fmin = fmin / 2 ** ((bins_per_semitone - 1) / (24 * bins_per_semitone))
+
+        self.cqt_kernels = nn.ModuleList([
+            CQT(sr=sr, hop_length=hop_length, fmin=h*fmin, fmax=fmax, n_bins=n_bins,
+                bins_per_octave=12*bins_per_semitone, output_format="Complex")
+            for h in harmonics
+        ])
+
+    def forward(self, audio_waveforms: torch.Tensor):
+        r"""Converts a batch of waveforms into a batch of HCQTs.
+
+        Args:
+            audio_waveforms (torch.Tensor): Batch of waveforms, shape (batch_size, num_samples)
+
+        Returns:
+            Harmonic CQT, shape (batch_size, num_harmonics, num_freqs, num_timesteps, 2)
+        """
+        return torch.stack([cqt(audio_waveforms) for cqt in self.cqt_kernels], dim=1)
diff --git a/pesto/parser.py b/pesto/utils/parser.py
similarity index 100%
rename from pesto/parser.py
rename to pesto/utils/parser.py
diff --git a/pesto/utils/reduce_activations.py b/pesto/utils/reduce_activations.py
new file mode 100644
index 0000000..191cb4f
--- /dev/null
+++ b/pesto/utils/reduce_activations.py
@@ -0,0 +1,36 @@
+import torch
+
+
+def reduce_activations(activations: torch.Tensor, reduction: str = "alwa") -> torch.Tensor:
+    r"""
+
+    Args:
+        activations: tensor of probability activations, shape (*, num_bins)
+        reduction (str): reduction method to compute pitch out of activations,
+            choose between "argmax", "mean", "alwa".
+
+    Returns:
+        torch.Tensor: pitches as fractions of MIDI semitones, shape (*)
+    """
+    device = activations.device
+    num_bins = activations.size(-1)
+    bps, r = divmod(num_bins, 128)
+    assert r == 0, f"Activations should have output size 128*bins_per_semitone, got {num_bins}."
+
+    if reduction == "argmax":
+        pred = activations.argmax(dim=-1)
+        return pred.float() / bps
+
+    all_pitches = torch.arange(num_bins, dtype=torch.float, device=device).div_(bps)
+    if reduction == "mean":
+        return torch.matmul(activations, all_pitches)
+
+    if reduction == "alwa":  # argmax-local weighted averaging, see https://github.com/marl/crepe
+        center_bin = activations.argmax(dim=-1, keepdim=True)
+        window = torch.arange(1, 2 * bps, device=device) - bps  # [-bps+1, -bps+2, ..., bps-2, bps-1]
+        indices = (center_bin + window).clip_(min=0, max=num_bins - 1)
+        cropped_activations = activations.gather(-1, indices)
+        cropped_pitches = all_pitches.unsqueeze(0).expand_as(activations).gather(1, indices)
+        return (cropped_activations * cropped_pitches).sum(dim=1) / cropped_activations.sum(dim=1)
+
+    raise ValueError
diff --git a/pesto/weights/mir-1k.pth b/pesto/weights/mir-1k.pth
deleted file mode 100644
index aadf78ceeff86ae4e86ac305053c5bcc9791ec7f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 119669
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

-- 
GitLab