Pseudo labeling

.pylintrc

@@ -414,14 +414,15 @@ confidence=HIGH,
 # no Warning level messages displayed, use "--disable=all --enable=classes
 # --disable=W".
 disable=raw-checker-failed,
+	logging-fstring-interpolation,
         bad-inline-option,
         locally-disabled,
         file-ignored,
         suppressed-message,
         useless-suppression,
         deprecated-pragma,
         use-symbolic-message-instead,
-        trailing-whitespace
+	trailing-whitespace
 
 # Enable the message, report, category or checker with the given id(s). You can
 # either give multiple identifier separated by comma (,) or put this option

pyha_analyzer/aug_viewer.py

@@ -2,18 +2,19 @@
     This file contains methods that allow the visualization of
     different data augmentations.
 """
-from typing import Callable, List, Tuple, Dict, Any
+from typing import Any, Callable, Dict, List, Tuple
 
 import numpy as np
 import torch
 from matplotlib import cm
 from matplotlib import pyplot as plt
 
 from pyha_analyzer import config
-from pyha_analyzer.utils import get_annotation
-from pyha_analyzer.augmentations import (BackgroundNoise, LowpassFilter, Mixup, 
-                                         HighpassFilter, RandomEQ, SyntheticNoise)
+from pyha_analyzer.augmentations import (BackgroundNoise, HighpassFilter,
+                                         LowpassFilter, Mixup, RandomEQ,
+                                         SyntheticNoise)
 from pyha_analyzer.dataset import PyhaDFDataset, get_datasets
+from pyha_analyzer.utils import get_annotation
 
 SYNTH_COLORS = ["white","pink","brown","violet","blue"]
 

pyha_analyzer/augmentations.py

@@ -5,7 +5,7 @@
 import logging
 import os
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Tuple, Iterable
+from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple
 
 import numpy as np
 import pandas as pd

pyha_analyzer/chunking_methods/csv_cleaner.py

@@ -23,7 +23,7 @@
         "Offset": "OFFSET",
         "Duration": "DURATION",
     },
-    
+
     # OUTPUT
     "cols_to_save": [
         "FILE NAME",
@@ -34,14 +34,14 @@
         "COMMON"
     ],
     "output_path": "../example_dataset/metadata_cleaned.csv",
-    
+
 }
 
 def main():
     """ Main function """
     if ARGUMENTS["input_path"] == "":
         raise ValueError("Input path not specified")
-    
+
     if ARGUMENTS["has_index_col"]:
         df = pd.read_csv(ARGUMENTS["input_path"], index_col=0)
     else:

pyha_analyzer/config.py

@@ -3,17 +3,18 @@
 """
 import argparse
 import logging
+import os
 import shutil
 import sys
-import os
 from pathlib import Path
+
 # "Repo" is not exported from module "git" Import from "git.repo" instead
 # https://gitpython.readthedocs.io/en/stable/tutorial.html?highlight=repo#meet-the-repo-type
 import git
+import importlib_resources as pkg_resources
 import yaml
 from git import Repo  # pyright: ignore [reportPrivateImportUsage]
 from torch.cuda import is_available
-import importlib_resources as pkg_resources
 
 logger = logging.getLogger("acoustic_multiclass_training")
 

pyha_analyzer/dataset.py

@@ -7,25 +7,26 @@
     If this module is run directly, it tests that the dataloader works
 
 """
+import ast
 import logging
 import os
-from typing import List, Tuple, Optional
-import ast
+from typing import List, Optional, Tuple
 
+import librosa
 import numpy as np
 import pandas as pd
 import torch
 import torchaudio
-from torch.utils.data import Dataset, DataLoader, WeightedRandomSampler
+from torch.utils.data import DataLoader, Dataset, WeightedRandomSampler
 from torchaudio import transforms as audtr
 from torchvision.transforms import RandomApply
 from tqdm import tqdm
-import wandb
 
-from pyha_analyzer import config
-from pyha_analyzer import utils
-from pyha_analyzer.augmentations import (BackgroundNoise, LowpassFilter, Mixup, RandomEQ,
-                                         HighpassFilter, SyntheticNoise)
+import wandb
+from pyha_analyzer import config, utils
+from pyha_analyzer.augmentations import (BackgroundNoise, HighpassFilter,
+                                         LowpassFilter, Mixup, RandomEQ,
+                                         SyntheticNoise)
 from pyha_analyzer.chunking_methods import sliding_chunks
 
 cfg = config.cfg
@@ -78,8 +79,18 @@ def __init__(self,
         self.class_to_idx = dict(zip(species, np.arange(len(species))))
 
         self.num_classes = len(species)
+
         self.serialize_data()
 
+        self.class_sums = torch.zeros(self.num_classes)
+        for target in self.samples[cfg.manual_id_col]:
+            if isinstance(target,dict):
+                for name, alpha in target.items():
+                    self.class_sums[self.class_to_idx[name]] += float(alpha)
+            else:
+                self.class_sums[self.class_to_idx[target]] += 1.
+
+
         #Data augmentations
         self.mixup = Mixup(self.samples, self.class_to_idx, cfg)
         audio_augs = {
@@ -180,17 +191,19 @@ def serialize_data(self) -> None:
 
 
         files = files["files"].progress_apply(self.process_audio_file)
-        logger.debug("%s", str(files.shape))
-
-        num_files = files.shape[0]
-        if num_files == 0:
-            raise FileNotFoundError("There were no valid filepaths found, check csv")
+        logger.debug(f"{files.shape=}")
 
+        #https://media.giphy.com/media/VIPfTy8y1Lc5iREYDS/giphy.gif
         files = files[files["files"] != "bad"]
         self.samples = self.samples.merge(files, how="left",
                        left_on=cfg.file_name_col,
                        right_on="FILE NAME").dropna()
 
+        num_files = files.shape[0]
+        if num_files == 0:
+            raise FileNotFoundError("There were no valid filepaths found, check csv")
+
+
         logger.debug("Serialized form, fixed size: %s", str(self.samples.shape))
 
         if "files" in self.samples.columns:
@@ -207,15 +220,36 @@ def to_image(self, audio):
         """
         Convert audio clip to 3-channel spectrogram image
         """
-        convert_to_mel = audtr.MelSpectrogram(
-                sample_rate=cfg.sample_rate,
-                n_mels=cfg.n_mels,
-                n_fft=cfg.n_fft)
-        convert_to_mel = convert_to_mel.to(self.device)
-        # Mel spectrogram
-        # Pylint complains this is not callable, but it is a torch.nn.Module
-        # pylint: disable-next=not-callable
-        mel = convert_to_mel(audio)
+        mel = librosa.feature.melspectrogram(
+            y=audio.detach().numpy(),
+            sr=cfg.sample_rate,
+            n_mels=cfg.n_mels,
+            n_fft=cfg.n_fft,
+            hop_length=int(cfg.n_fft//2),
+            power=1)
+        #log_S = librosa.amplitude_to_db(S, ref=np.max)
+        hop_length = int(cfg.n_fft//2)
+        mel_pcen = librosa.pcen(
+            mel * (2**31),
+            sr=cfg.sample_rate,
+            hop_length = hop_length,
+            gain=0.8,
+            power=0.25,
+            bias=10,
+            time_constant=60 * hop_length / cfg.sample_rate
+            #
+        )
+        # See https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=8514023 for
+        # reasoning behind parameters
+
+        # possible to do: improve this method
+        # GOAL: Multiplying by a power greater than one increases background
+        # This could help make calls sound further in the background
+        # and hopefully reduce domain shift
+        #if self.train:
+            #mel_pcen = mel_pcen ** 1.2
+
+        mel = torch.Tensor(mel_pcen)
         # Convert to Image
         image = torch.stack([mel, mel, mel])
 
@@ -237,7 +271,9 @@ def to_image(self, audio):
 
 
     def __getitem__(self, index): #-> Any:
-        """ Takes an index and returns tuple of spectrogram image with corresponding label
+        """ 
+        Takes an index and returns tuple of 
+        (spectrogram image, corresponding label, index)
         """
         assert isinstance(index, int)
         audio, target = utils.get_annotation(
@@ -264,7 +300,7 @@ def __getitem__(self, index): #-> Any:
             target = self.samples.loc[index, self.classes].values.astype(np.int32)
             target = torch.Tensor(target)
 
-        return image, target
+        return image, target, index
 
     def get_num_classes(self) -> int:
         """ Returns number of classes
@@ -285,12 +321,12 @@ def get_sample_weights(self) -> pd.Series:
         weight_list = self.samples[manual_id].apply(lambda x: sample_weights.loc[x])
         return weight_list
 
-
 def get_datasets() -> Tuple[PyhaDFDataset, PyhaDFDataset, Optional[PyhaDFDataset]]:
     """ Returns train and validation datasets
     does random sampling for train/valid split
     adds transforms to dataset
     """
+
     train_p = cfg.train_test_split
     path = cfg.dataframe_csv
     # Load the dataset
@@ -346,8 +382,9 @@ def get_datasets() -> Tuple[PyhaDFDataset, PyhaDFDataset, Optional[PyhaDFDataset
                     classes.add(species)
         classes = list(classes)
         classes.sort()
-        # pylint: disable-next=attribute-defined-outside-init
         cfg.config_dict["class_list"] = classes
+        # pylint: disable-next=attribute-defined-outside-init
+        cfg.class_list = classes # type: ignore
         wandb.config.update({"class_list": classes}, allow_val_change=True)
 
     #for each species, get a random sample of files for train/valid split
@@ -358,10 +395,8 @@ def get_datasets() -> Tuple[PyhaDFDataset, PyhaDFDataset, Optional[PyhaDFDataset
 
     valid = data[~data.index.isin(train.index)]
     train_ds = PyhaDFDataset(train, train=True, species=classes)
-
     valid_ds = PyhaDFDataset(valid, train=False, species=classes)
-
-
+
 
     #Handle inference datasets
     if cfg.infer_csv is None:
@@ -380,59 +415,45 @@ def set_torch_file_sharing(_) -> None:
     """
     torch.multiprocessing.set_sharing_strategy("file_system")
 
-
-def make_dataloaders(train_dataset, val_dataset, infer_dataset
-        )-> Tuple[DataLoader, DataLoader, Optional[DataLoader]]:
+def get_dataloader(train_dataset, val_dataset, infer_dataset):
     """
-        Loads datasets and dataloaders for train and validation
+    Convenience wrapper to apply `make_dataloader` to all datasets
     """
+    train_dataloader = make_dataloader(train_dataset,cfg.train_batch_size,
+                                       cfg.does_weighted_sampling)
+    val_dataloader = make_dataloader(val_dataset,cfg.validation_batch_size)
+    if infer_dataset is None:
+        infer_dataloader = None
+    else:
+        infer_dataloader = make_dataloader(infer_dataset,cfg.validation_batch_size)
+    return train_dataloader, val_dataloader, infer_dataloader
 
-
-    # Create our dataloaders
-    # if sampler function is "specified, shuffle must not be specified."
-    # https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader
-
-    if cfg.does_weighted_sampling:
-        if train_dataset.samples[cfg.manual_id_col].any(lambda x: isinstance(x,dict)):
+def make_dataloader(dataset, batch_size, weighted_sampling=False, shuffle=True):
+    """ Creates a torch DataLoader from a PyhaDFDataset """
+    if weighted_sampling:
+        if dataset.samples[cfg.manual_id_col].any(lambda x: isinstance(x,dict)):
             raise NotImplementedError("Weighted sampling not implemented for overlapping targets")
         # Code used from:
         # https://www.kaggle.com/competitions/birdclef-2023/discussion/412808
         # Get Sample Weights
-        weights_list = train_dataset.get_sample_weights()
+        weights_list = dataset.get_sample_weights()
         sampler = WeightedRandomSampler(weights_list, len(weights_list))
-        train_dataloader = DataLoader(
-            train_dataset,
+        # if sampler function is "specified, shuffle must not be specified."
+        # https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader
+        return DataLoader(
+            dataset,
             cfg.train_batch_size,
             sampler=sampler,
             num_workers=cfg.jobs,
             worker_init_fn=set_torch_file_sharing
         )
-    else:
-        train_dataloader = DataLoader(
-            train_dataset,
-            cfg.train_batch_size,
-            shuffle=True,
-            num_workers=cfg.jobs,
-            worker_init_fn=set_torch_file_sharing
-        )
-
-    val_dataloader = DataLoader(
-        val_dataset,
-        cfg.validation_batch_size,
-        shuffle=False,
+    return DataLoader(
+        dataset,
+        batch_size,
+        shuffle=shuffle,
         num_workers=cfg.jobs,
+        worker_init_fn=set_torch_file_sharing
     )
-    if infer_dataset is None:
-        infer_dataloader = None
-    else:
-        infer_dataloader = DataLoader(
-                infer_dataset,
-                cfg.validation_batch_size,
-                shuffle=False,
-                num_workers=cfg.jobs,
-                worker_init_fn=set_torch_file_sharing
-            )
-    return train_dataloader, val_dataloader, infer_dataloader
 
 def main() -> None:
     """

pyha_analyzer/default_config.yml

@@ -7,6 +7,16 @@ infer_csv:
 # Optional, automatically generates class order if not given
 class_list:
 
+# Pseudo-labeling if running pyha_analyzer/pseudolabel.py
+pseudo_data_augs: true
+pseudo_threshold: 0.7
+
+# Notela params
+notela_knn: 4
+notela_lambda: 0.5
+notela_alpha: 1.0
+features_flattened: true
+
 # Dataframe column names
 offset_col: "OFFSET"
 duration_col: "DURATION"
@@ -81,7 +91,6 @@ sweep_id:
 early_stopping: false
 patience: 3
 min_valid_map_delta: 0.01
-
 # Data augmentation probabilities
 mixup_p: 0.4
 time_shift_p: 0