nkululeko 0.91.3__tar.gz → 0.92.1__tar.gz

{nkululeko-0.91.3 → nkululeko-0.92.1}/CHANGELOG.md

@@ -1,6 +1,14 @@
 Changelog
 =========
 
+Version 0.92.1
+--------------
+* added a speaker plot to pyannote results 
+
+Version 0.92.0
+--------------
+* added first version of automatic speaker prediction/segmentation
+
 Version 0.91.3
 --------------
 * some additions for robustness

{nkululeko-0.91.3/nkululeko.egg-info → nkululeko-0.92.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nkululeko
-Version: 0.91.3
+Version: 0.92.1
 Summary: Machine learning audio prediction experiments based on templates
 Home-page: https://github.com/felixbur/nkululeko
 Author: Felix Burkhardt
@@ -355,6 +355,14 @@ F. Burkhardt, Johannes Wagner, Hagen Wierstorf, Florian Eyben and Björn Schulle
 Changelog
 =========
 
+Version 0.92.1
+--------------
+* added a speaker plot to pyannote results 
+
+Version 0.92.0
+--------------
+* added first version of automatic speaker prediction/segmentation
+
 Version 0.91.3
 --------------
 * some additions for robustness

nkululeko-0.92.1/nkululeko/autopredict/ap_sid.py

@@ -0,0 +1,48 @@
+""""
+A predictor for sid - Speaker ID.
+"""
+
+import numpy as np
+from pyannote.audio import Pipeline
+import torch
+
+from nkululeko.feature_extractor import FeatureExtractor
+import nkululeko.glob_conf as glob_conf
+from nkululeko.utils.util import Util
+
+
+class SIDPredictor:
+    """SIDPredictor.
+
+    predicting speaker id.
+    """
+
+    def __init__(self, df):
+        self.df = df
+        self.util = Util("sidPredictor")
+        hf_token = self.util.config_val("Model", "hf_token", None)
+        if hf_token is None:
+            self.util.error(
+                "speaker id prediction needs huggingface token: [MODEL][hf_token]"
+            )
+        self.pipeline = Pipeline.from_pretrained(
+            "pyannote/speaker-diarization-3.1",
+            use_auth_token=hf_token,
+        )
+        device = self.util.config_val("Model", "device", "cpu")
+        self.pipeline.to(torch.device(device))
+
+    def predict(self, split_selection):
+        self.util.debug(f"estimating speaker id for {split_selection} samples")
+        return_df = self.df.copy()
+        # @todo
+        # 1) concat all audio files
+        # 2) get segmentations with pyannote
+        # 3) map pyannote segments with orginal ones and assign speaker id
+
+        return return_df
+
+    def concat_files(self, df):
+        pass
+        # todo
+        # please use https://audeering.github.io/audiofile/usage.html#read-a-file

{nkululeko-0.91.3 → nkululeko-0.92.1}/nkululeko/constants.py

@@ -1,2 +1,2 @@
-VERSION="0.91.3"
+VERSION="0.92.1"
 SAMPLING_RATE = 16000

{nkululeko-0.91.3 → nkululeko-0.92.1}/nkululeko/experiment.py

@@ -439,7 +439,12 @@ class Experiment:
             )
         targets = self.util.config_val_list("PREDICT", "targets", ["gender"])
         for target in targets:
-            if target == "gender":
+            if target == "speaker":
+                from nkululeko.autopredict.ap_sid import SIDPredictor
+
+                predictor = SIDPredictor(df)
+                df = predictor.predict(sample_selection)
+            elif target == "gender":
                 from nkululeko.autopredict.ap_gender import GenderPredictor
 
                 predictor = GenderPredictor(df)

{nkululeko-0.91.3 → nkululeko-0.92.1}/nkululeko/plots.py

@@ -4,14 +4,14 @@ import ast
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
-import seaborn as sns
 from scipy import stats
+import seaborn as sns
 from sklearn.manifold import TSNE
 
 import nkululeko.glob_conf as glob_conf
-import nkululeko.utils.stats as su
 from nkululeko.reporting.defines import Header
 from nkululeko.reporting.report_item import ReportItem
+import nkululeko.utils.stats as su
 from nkululeko.utils.util import Util
 
 
@@ -30,8 +30,6 @@ class Plots:
             df_speaker["samplenum"] = df_speaker.shape[0]
             df_speakers = pd.concat([df_speakers, df_speaker.head(1)])
         # plot the distribution of samples per speaker
-        # one up because of the runs
-        fig_dir = self.util.get_path("fig_dir") + "../"
         self.util.debug("plotting samples per speaker")
         if "gender" in df_speakers:
             filename = "samples_value_counts"
@@ -319,6 +317,31 @@ class Plots:
         img_path = f"{fig_dir}{filename}_{sample_selection}.{self.format}"
         plt.savefig(img_path)
         plt.close(fig)
+        self.util.debug(f"plotted durations to {img_path}")
+        glob_conf.report.add_item(
+            ReportItem(
+                Header.HEADER_EXPLORE,
+                caption,
+                title,
+                img_path,
+            )
+        )
+
+    def plot_speakers(self, df, sample_selection):
+        filename = "speakers"
+        caption = "speakers"
+        # one up because of the runs
+        fig_dir = self.util.get_path("fig_dir") + "../"
+        sns.set_style("whitegrid")  # Set style for chart
+        ax = df["speaker"].value_counts().plot(kind="pie")
+        title = f"Speaker distr. for {sample_selection} {df.shape[0]}."
+        ax.set_title(title)
+        fig = ax.figure
+        # plt.tight_layout()
+        img_path = f"{fig_dir}{filename}_{sample_selection}.{self.format}"
+        plt.savefig(img_path)
+        plt.close(fig)
+        self.util.debug(f"plotted speakers to {img_path}")
         glob_conf.report.add_item(
             ReportItem(
                 Header.HEADER_EXPLORE,

{nkululeko-0.91.3 → nkululeko-0.92.1}/nkululeko/predict.py

@@ -2,7 +2,7 @@
 # use some model and add automatically predicted labels to train and test splits
 # then save as a new dataset
 
-"""This script is used to call the nkululeko PREDICT framework. 
+r"""This script is used to call the nkululeko PREDICT framework.
 
 It loads a configuration file, creates a new experiment,
 and performs automatic prediction on the train and test datasets. The predicted labels are added to the datasets and

{nkululeko-0.91.3 → nkululeko-0.92.1}/nkululeko/segment.py

@@ -1,5 +1,4 @@
-"""
-Segments the samples in the dataset into chunks based on voice activity detection using SILERO VAD [1].
+"""Segments the samples in the dataset into chunks based on voice activity detection using SILERO VAD [1].
 
 The segmentation results are saved to a file, and the distributions of the original and
 segmented durations are plotted.
@@ -15,7 +14,7 @@ Example:
 
 References:
     [1] https://github.com/snakers4/silero-vad
-    
+    [2] https://github.com/pyannote/pyannote-audio
 """
 
 import argparse
@@ -64,7 +63,7 @@ def main():
     # segment
     segmented_file = util.config_val("SEGMENT", "result", "segmented.csv")
 
-    segmenter = util.config_val("SEGMENT", "method", "silero")
+    method = util.config_val("SEGMENT", "method", "silero")
     sample_selection = util.config_val("SEGMENT", "sample_selection", "all")
     if sample_selection == "all":
         df = pd.concat([expr.df_train, expr.df_test])
@@ -77,18 +76,21 @@ def main():
             f"unknown segmentation selection specifier {sample_selection},"
             " should be [all | train | test]"
         )
-    util.debug(f"segmenting {sample_selection}: {df.shape[0]} samples with {segmenter}")
-    if segmenter == "silero":
+    util.debug(f"segmenting {sample_selection}: {df.shape[0]} samples with {method}")
+    if method == "silero":
         from nkululeko.segmenting.seg_silero import Silero_segmenter
 
         segmenter = Silero_segmenter()
         df_seg = segmenter.segment_dataframe(df)
+    elif method == "pyannote":
+        from nkululeko.segmenting.seg_pyannote import Pyannote_segmenter
 
+        segmenter = Pyannote_segmenter(config)
+        df_seg = segmenter.segment_dataframe(df)
     else:
-        util.error(f"unkown segmenter: {segmenter}")
+        util.error(f"unknown segmenter: {method}")
 
     def calc_dur(x):
-
         starts = x[1]
         ends = x[2]
         return (ends - starts).total_seconds()
@@ -108,6 +110,9 @@ def main():
     plots.plot_durations(
         df_seg, "segmented_durations", sample_selection, caption="Segmented durations"
     )
+    if method == "pyannote":
+        plots.plot_speakers(df_seg, sample_selection)
+
     print("")
     # remove encoded labels
     target = util.config_val("DATA", "target", None)
@@ -115,8 +120,6 @@ def main():
         df_seg = df_seg.drop(columns=[target])
         df_seg = df_seg.rename(columns={"class_label": target})
     # save file
-    # dataname = "_".join(expr.datasets.keys())
-    # name = f"{dataname}{segment_target}"
     df_seg.to_csv(f"{expr.data_dir}/{segmented_file}")
     util.debug(
         f"saved {segmented_file} to {expr.data_dir}, {num_after} samples (was"

nkululeko-0.92.1/nkululeko/segmenting/seg_pyannote.py

@@ -0,0 +1,129 @@
+"""seg_pyannote.py.
+
+Segment a dataset with the Pyannote segmenter.
+Also adds speaker ids to the segments.
+
+"""
+
+import pandas as pd
+from pyannote.audio import Pipeline
+import torch
+from tqdm import tqdm
+
+import audformat
+from audformat import segmented_index
+
+from nkululeko.utils.util import Util
+
+
+SAMPLING_RATE = 16000
+
+
+class Pyannote_segmenter:
+    def __init__(self, not_testing=True):
+        # initialize the VAD model
+        torch.set_num_threads(1)
+        self.no_testing = not_testing
+        self.util = Util("pyannote_segmenter")
+        hf_token = self.util.config_val("MODEL", "hf_token", None)
+        if hf_token is None:
+            self.util.error(
+                "speaker id prediction needs huggingface token: [MODEL][hf_token]"
+            )
+        self.pipeline = Pipeline.from_pretrained(
+            "pyannote/speaker-diarization-3.1",
+            use_auth_token=hf_token,
+        )
+        device = self.util.config_val("MODEL", "device", "cpu")
+        if device == "cpu":
+            self.util.warn(
+                "running pyannote on CPU can be really slow, consider using a GPU"
+            )
+        self.pipeline.to(torch.device(device))
+
+    def get_segmentation_simple(self, file):
+
+        annotation = self.pipeline(file[0])
+
+        speakers, starts, ends, files = [], [], [], []
+        # print the result
+        for turn, _, speaker in annotation.itertracks(yield_label=True):
+            start = turn.start
+            end = turn.end
+            speakers.append(speaker)
+            starts.append(start)
+            files.append(file[0])
+            ends.append(end)
+        seg_index = segmented_index(files, starts, ends)
+        return seg_index, speakers
+
+    def get_segmentation(self, file, min_length, max_length):
+        annotation = self.pipeline(file)
+        files, starts, ends, speakers = [], [], [], []
+        for turn, _, speaker in annotation.itertracks(yield_label=True):
+            start = turn.start
+            end = turn.end
+            new_end = end
+            handled = False
+            while end - start > max_length:
+                new_end = start + max_length
+                if end - new_end < min_length:
+                    new_end = end
+                files.append(file[0])
+                starts.append(start)
+                ends.append(new_end)
+                speakers.append(speaker)
+                start += max_length
+                handled = True
+            if not handled and end - start > min_length:
+                files.append(file[0])
+                starts.append(start)
+                ends.append(end)
+                speakers.append(speaker)
+        seg_index = segmented_index(files, starts, ends)
+        return seg_index, speakers
+
+    def segment_dataframe(self, df):
+        dfs = []
+        max_length = eval(self.util.config_val("SEGMENT", "max_length", "False"))
+        if max_length:
+            if self.no_testing:
+                min_length = float(self.util.config_val("SEGMENT", "min_length", 2))
+            else:
+                min_length = 2
+            self.util.debug(f"segmenting with max length: {max_length+min_length}")
+        for file, values in tqdm(df.iterrows()):
+            if max_length:
+                index, speakers = self.get_segmentation(file, min_length, max_length)
+            else:
+                index, speakers = self.get_segmentation_simple(file)
+            df = pd.DataFrame(
+                values.to_dict(),
+                index,
+            )
+            df["speaker"] = speakers
+            dfs.append(df)
+        return audformat.utils.concat(dfs)
+
+
+def main():
+    files = pd.Series(["test_wavs/very_long.wav"])
+    df_sample = pd.DataFrame(index=files)
+    df_sample["target"] = "anger"
+    df_sample.index = audformat.utils.to_segmented_index(
+        df_sample.index, allow_nat=False
+    )
+    segmenter = Pyannote_segmenter(not_testing=False)
+    df_seg = segmenter.segment_dataframe(df_sample)
+
+    def calc_dur(x):
+        starts = x[1]
+        ends = x[2]
+        return (ends - starts).total_seconds()
+
+    df_seg["duration"] = df_seg.index.to_series().map(lambda x: calc_dur(x))
+    print(df_seg.head(100))
+
+
+if __name__ == "__main__":
+    main()

{nkululeko-0.91.3 → nkululeko-0.92.1/nkululeko.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nkululeko
-Version: 0.91.3
+Version: 0.92.1
 Summary: Machine learning audio prediction experiments based on templates
 Home-page: https://github.com/felixbur/nkululeko
 Author: Felix Burkhardt
@@ -355,6 +355,14 @@ F. Burkhardt, Johannes Wagner, Hagen Wierstorf, Florian Eyben and Björn Schulle
 Changelog
 =========
 
+Version 0.92.1
+--------------
+* added a speaker plot to pyannote results 
+
+Version 0.92.0
+--------------
+* added first version of automatic speaker prediction/segmentation
+
 Version 0.91.3
 --------------
 * some additions for robustness

{nkululeko-0.91.3 → nkululeko-0.92.1}/nkululeko.egg-info/SOURCES.txt

@@ -163,6 +163,7 @@ nkululeko/reporting/reporter.py
 nkululeko/reporting/result.py
 nkululeko/segmenting/__init__.py
 nkululeko/segmenting/seg_inaspeechsegmenter.py
+nkululeko/segmenting/seg_pyannote.py
 nkululeko/segmenting/seg_silero.py
 nkululeko/utils/__init__.py
 nkululeko/utils/files.py

nkululeko-0.91.3/nkululeko/autopredict/ap_sid.py

@@ -1,43 +0,0 @@
-""""
-A predictor for sid - Speaker ID.
-"""
-
-from pyannote.audio import Pipeline
-
-
-import numpy as np
-
-import nkululeko.glob_conf as glob_conf
-from nkululeko.feature_extractor import FeatureExtractor
-from nkululeko.utils.util import Util
-
-
-class SIDPredictor:
-    """SIDPredictor.
-
-    predicting speaker id.
-    """
-
-    def __init__(self, df):
-        self.df = df
-        self.util = Util("sidPredictor")
-        self.pipeline = Pipeline.from_pretrained(
-            "pyannote/speaker-diarization-3.1",
-            use_auth_token="HUGGINGFACE_ACCESS_TOKEN_GOES_HERE",
-        )
-
-    def predict(self, split_selection):
-        self.util.debug(f"estimating PESQ for {split_selection} samples")
-        return_df = self.df.copy()
-        feats_name = "_".join(ast.literal_eval(glob_conf.config["DATA"]["databases"]))
-        self.feature_extractor = FeatureExtractor(
-            self.df, ["squim"], feats_name, split_selection
-        )
-        result_df = self.feature_extractor.extract()
-        # replace missing values by 0
-        result_df = result_df.fillna(0)
-        result_df = result_df.replace(np.nan, 0)
-        result_df.replace([np.inf, -np.inf], 0, inplace=True)
-        pred_vals = result_df.pesq * 100
-        return_df["pesq_pred"] = pred_vals.astype("int") / 100
-        return return_df