nkululeko 0.93.12__tar.gz → 0.93.13__tar.gz

{nkululeko-0.93.12 → nkululeko-0.93.13}/CHANGELOG.md

@@ -1,6 +1,10 @@
 Changelog
 =========
 
+Version 0.93.13 (24-01-27)
+--------------------------
+* plot: replaced "class_label" by target name for continuous distributions
+
 Version 0.93.12
 ---------------
 * bugfix: map_continuous_to_cat crashed on empty data

nkululeko-0.93.13/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.2
+Name: nkululeko
+Version: 0.93.13
+Summary: Machine learning audio prediction experiments based on templates
+Home-page: https://github.com/felixbur/nkululeko
+Author: Felix Burkhardt
+Author-email: fxburk@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: audeer
+Requires-Dist: audformat
+Requires-Dist: audinterface
+Requires-Dist: audiofile
+Requires-Dist: audiomentations
+Requires-Dist: audmetric
+Requires-Dist: audonnx
+Requires-Dist: confidence_intervals
+Requires-Dist: datasets
+Requires-Dist: imageio
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: opensmile
+Requires-Dist: pandas
+Requires-Dist: praat-parselmouth
+Requires-Dist: scikit_learn
+Requires-Dist: scipy
+Requires-Dist: seaborn
+Requires-Dist: sounddevice
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: transformers
+Requires-Dist: umap-learn
+Requires-Dist: xgboost
+Requires-Dist: pylatex

nkululeko-0.93.13/data/aesdd/process_database.py

@@ -0,0 +1,50 @@
+import argparse
+from pathlib import Path
+
+import pandas as pd
+
+emotion_map = {
+    "a": "anger",
+    "d": "disgust",
+    "h": "happiness",
+    "f": "fear",
+    "s": "sadness",
+}
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data_dir", type=str, default="AESDD", help="Path of AESDD directory")
+    parser.add_argument("--out_dir", type=str, default=".")
+    args = parser.parse_args()
+
+    data_dir = Path(args.data_dir)
+    out_dir = Path(args.out_dir)
+
+    paths = list(data_dir.glob("**/*.wav"))
+    files = [file for file in paths  if file.stem != "s05 (3)"]
+    names = [file.stem for file in files]
+    emotion = [emotion_map[file.stem[0]] for file in files]
+    speaker = [str(int(x[x.find("(") + 1: x.find(")")])) for x in names]
+    gender = [["female", "male"][int(v) % 2] for v in speaker]
+    language =["greek" for file in files]
+
+    # convert to df
+    df = pd.DataFrame({"file": files, "speaker": speaker, "emotion": emotion, "gender": gender})
+
+    # print distribution per emotion
+    # print(df.groupby("emotion").count()['file'])
+
+    # allocate speaker 5 for test set
+    train_df = df[df["speaker"] != "5"]
+    test_df = df.drop(train_df.index)
+
+    # save to CSV
+    df.to_csv(out_dir / "aesdd.csv", index=False)
+    train_df.to_csv(out_dir / "aesdd_train.csv", index=False)
+    test_df.to_csv(out_dir / "aesdd_test.csv", index=False)
+
+    print(f"Total: {len(df)}, Train: {len(train_df)}, Test: {len(test_df)}")
+    
+if __name__ == "__main__":
+    main()

nkululeko-0.93.13/data/ased/process_database.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# @filename: process_database.py
+# @description: Process the ASED database 
+
+
+import argparse
+import shutil
+from importlib.resources import path
+from pathlib import Path
+
+import pandas as pd
+from joblib import delayed
+
+emotion_map = {
+    "a": "anger",
+    "h": "happiness",
+    "n": "neutral",
+    "f": "fear",
+    "s": "sadness",
+}
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        usage="python3 process_database.py database output"
+    )
+    parser.add_argument("--data_dir", type=str, default="ASED_V1", help="Path to the ASED database")
+    parser.add_argument("--out_dir", type=str, default=".", help="Path to the output directory")
+    args = parser.parse_args()
+
+    data_dir = Path(args.data_dir)
+    out_dir = Path(args.out_dir)
+
+    paths = list(data_dir.glob("**/*.wav"))
+    emotions = [emotion_map[path.stem[0].lower()] for path in paths]
+    genders = [["female", "male"][int(p.stem[9:11]) - 1] for p in paths]
+    spekaers = [p.stem[-2:] for p in paths]
+    languages = ["amharic" for p in paths]
+
+    # convert to df
+    df = pd.DataFrame({"file": paths, "emotion": emotions, "gender": genders, "speaker": spekaers, "language": languages})
+
+    # allocate speakers >= 55 for test
+    df_test = df[df["speaker"] > "55"]
+    df_train = df.drop(df_test.index)
+
+
+    # save to csv
+    df_train.to_csv(out_dir / "ased_train.csv", index=False)
+    df_test.to_csv(out_dir / "ased_test.csv", index=False)
+    df.to_csv(out_dir / "ased.csv", index=False)
+
+
+if __name__ == "__main__":
+    main()
+    

nkululeko-0.93.13/data/asvp-esd/process_database.py

@@ -0,0 +1,79 @@
+# process_database --> ASVP-ESD
+
+import argparse
+import os
+from pathlib import Path
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+
+emotion_map = {
+    '01': 'boredom',
+    '02': 'neutral',
+    '03': 'happy',
+    '04': 'sad',
+    '05': 'anger',
+    '06': 'fear',
+    '07': 'disgust',
+    '08': 'surprise',
+    '09': 'excited',
+    '10': 'pleasure',
+    '11': 'pain',
+    '12': 'disapointed',
+    '13': 'others',
+}
+
+
+vocal_map = {
+    "01" : "speech",
+    "02" : "non_speech",
+}
+
+language_map = {
+    "00" : "chinese",
+    "01" : "english",
+    "02" : "french",
+    "03" : "russian",
+    "04" : "other1",
+    "05" : "other2",
+}
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--data_dir', type=Path,
+        default=Path('./ASVP-ESD-Update'))
+    parser.add_argument('--output_dir', type=Path, default=Path('./'))
+    args = parser.parse_args()
+
+    # Read the database
+    input_dir = args.data_dir
+    output_dir = args.output_dir
+
+    # list of all the WAV files in the database
+    wav_list = list(input_dir.glob('Audio/**/*.wav'))
+
+    # file = [p for p in wav_list if os.path.getsize(p) >= 40000]
+    file = [p for p in wav_list]
+
+    # Vocal channel (01 = speech, 02 = non speech).
+    vocal = [vocal_map[p.stem.split('-')[1]] for p in file]
+
+    # emotion
+    emotion = [emotion_map[p.stem.split('-')[2]] for p in file]
+
+    # language --> not all data have language
+    # language = [language_map[p.stem.split('-')[8]] for p in wav_list]
+
+    # save to pandas dataframe
+    df = pd.DataFrame(data={'file': file, 'vocal': vocal, 'emotion': emotion})
+
+    # split to train, test sets using scikit-learn
+
+    train, test = train_test_split(df, test_size=0.2, random_state=42)
+
+    # save to csv
+    train.to_csv('asvp_train.csv', index=False)
+    test.to_csv('asvp_test.csv', index=False)
+
+if __name__ == '__main__':
+    main()

nkululeko-0.93.13/data/baved/process_database.py

@@ -0,0 +1,63 @@
+# process_database --> BAVED
+# modified from https://github.com/Strong-AI-Lab/emotion/blob/master/datasets/BAVED/process.py
+
+import argparse
+from html import parser
+from pathlib import Path
+
+import pandas as pd
+
+emotion_level = ["low", "normal", "high"]
+word_map = [
+    "اعجبني",
+    "لم يعجبني",
+    "هذا",
+    "الفيلم",
+    "رائع",
+    "مقول",
+    "سيئ",
+]
+
+gender_map = {
+    "M": "male",
+    "F": "female"
+}
+
+
+def main():  
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--data_dir', type=str, default='BAVED')
+    parser.add_argument('--output_dir', type=str, default='.')
+    args = parser.parse_args()
+
+    data_dir = Path(args.data_dir)
+    output_dir = Path(args.output_dir)
+
+    # read data
+    paths = list(data_dir.glob('?/*.wav'))
+    emo_levels = [emotion_level[int(p.stem.split('-')[4])] for p in paths]
+    speakers = [p.stem.split('-')[0] for p in paths]
+    genders = [gender_map[p.stem.split('-')[1].upper()] for p in paths]
+    ages = [int(p.stem.split('-')[2]) for p in paths]
+    words = [word_map[int(p.stem.split('-')[3])] for p in paths]
+    languages = ["arabic" for p in paths]
+
+    # convert to dataframe
+    df = pd.DataFrame({"file": paths, "emotion_level": emo_levels,
+                      "speakers": speakers, "gender": genders, "age": ages,
+                       "word": words, "language": languages})
+
+    # allocate speaker 50, 46, 102 , 55, 51
+    test_speakers = ['46', '4', '54', '47', '51']
+    df_test = df[df['speakers'].isin(test_speakers)]
+    df_train = df.drop(df_test.index)
+
+    # save to CSV
+    df.to_csv(output_dir / 'baved.csv', index=False)
+    df_train.to_csv(output_dir / 'baved_train.csv', index=False)
+    df_test.to_csv(output_dir / 'baved_test.csv', index=False)
+
+    print(f"BAVED: {len(df)} samples, {len(df_train)} train, {len(df_test)} test")
+
+if __name__ == '__main__':
+    main()

nkululeko-0.93.13/data/cafe/process_database.py

@@ -0,0 +1,50 @@
+# process_database.py --> CaFE
+# modified from https://github.com/Strong-AI-Lab/emotion/blob/master/datasets/CaFE/process.py
+
+import argparse
+from pathlib import Path
+
+import pandas as pd
+
+emotion_map = {
+    "C": "anger",
+    "D": "disgust",
+    "J": "happiness",
+    "N": "neutral",
+    "P": "fear",
+    "S": "surprise",
+    "T": "sadness",
+}
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data_dir", type=str, default="CaFE")
+    parser.add_argument("--output_dir", type=str, default=".")
+    args = parser.parse_args()
+    
+    data_dir = Path(args.data_dir)
+    output_dir = Path(args.output_dir)
+
+    paths = list(data_dir.glob("**/*.wav"))
+    files = [file for file in paths]
+    emotion = [emotion_map[file.stem[3]] for file in files]
+    speaker = [file.stem[:2] for file in files]
+    language = ["french" for file in files]
+    country = ["canada" for file in files]
+    gender = [["female", "male"][int(v) % 2] for v in speaker]
+    
+    # convert to df
+    df = pd.DataFrame({"file": files, "speaker": speaker, "emotion": emotion, "language": language, "country": country})
+
+    # allocate the last two speakers (11, 12) for test
+    train_df = df[(df["speaker"] != "11") & (df["speaker"] != "12")]
+    test_df = df.drop(train_df.index)
+
+    # save to CSV
+    df.to_csv(output_dir / "cafe.csv", index=False)
+    train_df.to_csv(output_dir / "cafe_train.csv", index=False)
+    test_df.to_csv(output_dir / "cafe_test.csv", index=False)
+
+
+if __name__ == "__main__":
+    main()

nkululeko-0.93.13/data/clac/process_database.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+# process_database.py --> CLAC
+# need to install openpyxl: pip install openpyxl
+
+import argparse
+
+import pandas as pd
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data_dir", help="input dir", default="CLAC-Dataset")
+    parser.add_argument("--out_dir", help="output dir", default=".")
+    args = parser.parse_args()
+
+    # Read metadata from excel file
+    metadata = pd.read_excel(args.data_dir + "/metadata.xlsx", index_col=0)
+
+    # rename columns
+    metadata.rename(
+        columns={
+            "speakerID": "speaker",
+            "worker_country": "country",
+            "worker_region": "region",
+            "age (years)": "age",
+        },
+        inplace=True,
+    )
+
+    # remove "education (years)" column
+    metadata.drop(columns=["education (years)"], inplace=True)
+
+    # add file with WAV extension
+    metadata["file"] = metadata["speaker"] + ".wav"
+
+    # print(metadata.head())
+    print(metadata.head())
+
+    # print length of metadata
+    print(f"Length of metadata: {len(metadata)}, saved as metadata.csv")
+
+    # save to csv file
+    metadata.to_csv(args.out_dir + "/clac.csv")
+
+
+if __name__ == "__main__":
+    main()

nkululeko-0.93.13/data/cmu-mosei/process_database.py

@@ -0,0 +1,53 @@
+# process_database.py -> CMU-MOSEI database
+# input file:
+# - label_paths: CMU_MOSEI_Labels.csv
+# - db_paths: CMU-MOSEI
+
+import argparse
+import os
+
+import pandas as pd
+
+
+def preprocess(data_dirs, name, split_df, out_path):
+    meta_data = []
+    for ix, row in split_df.iterrows():
+        # get wav file path
+        # print(row['file'])
+        filename = row['file'] + '_' + str(row['index']) + '.wav'
+        file = os.path.join(data_dirs, 'Audio', 'Segmented_Audio',
+                            name, filename)
+        
+        sentiment = str(row['label2a'])
+        for r in (("0", "negative"), ("1", "positive")):
+            sentiment = sentiment.replace(*r)
+        
+        emotion = str(row['label6'])
+        for r in (("0", "hap"), ("1", "sad"), ("2", "ang"), ("3", "sur"), ("4", "dis"), ("5", "fea")):
+            emotion = emotion.replace(*r)
+        
+        meta_data.append({
+                'file': file,
+                'sentiment': sentiment,
+                'emotion': emotion,
+                })
+        
+        # write to csv
+    meta_data_df = pd.DataFrame(meta_data)
+    meta_data_df.to_csv(out_path, index=False)    
+    print(f'Wrote {name} partition with {len(meta_data)} samples to {out_path}.')
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--data_dir', type=str, default='./CMU-MOSEI',
+                        help='Path to CMU-MOSEI directory.')
+    args = parser.parse_args()
+    label_path = 'CMU_MOSEI_Labels.csv'
+    data = pd.read_csv(label_path)
+    for i, split_name in enumerate(['train', 'dev', 'test']):
+        print(f'Processing {split_name} (split == {i}).')
+        split_df = data[data['split'] == i]
+        preprocess(args.data_dir, split_name, split_df, 
+                   f'mosei_{split_name}.csv')
+
+    

nkululeko-0.93.13/data/demos/process_database.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+# process_database.py --> DEMoS
+
+import argparse
+from pathlib import Path
+
+import pandas as pd
+
+emotion_map = {
+    "rab": "anger",
+    "tri": "sadness",
+    "gio": "happiness",
+    "pau": "fear",
+    "dis": "disgust",
+    "col": "guilt",
+    "sor": "surprise",
+    "neu": "neutral",
+}
+
+gender_map = {
+    "f": "female",
+    "m": "male"
+}
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--data_dir', type=str, default='DEMoS', help='Path to the database file')
+    parser.add_argument('--output_dir', type=str, default='.', help='Path to the output directory')
+    args = parser.parse_args()
+
+    data_dir = Path(args.data_dir)
+    output_dir = Path(args.output_dir)
+
+    if not output_dir.exists():
+        output_dir.mkdir()
+
+    paths = list(data_dir.glob('**/*.wav'))
+    # emotions = [emotion_map[p.stem.split('_')[3][:3]] if p.parts[1] == 'DEMOS' else emotion_map[p.stem.split('_')[2][:3]] for p in paths]
+
+    emotions = [emotion_map[p.stem.split('_')[-1][:3]] for p in paths]
+    genders = [gender_map[p.stem.split('_')[-3]] for p in paths]
+    speakers = [p.stem.split('_')[-2] for p in paths]
+    languages = ["italian" for p in paths]
+    prototypicality = [p.stem[:2] if p.stem[:2] in {"NP", "PR"} else "neutral" for p in paths]
+
+
+    # convert to df
+    df = pd.DataFrame({"file": paths, "emotion": emotions, "gender": genders, "speaker": speakers, "language": languages, "prototypicality": prototypicality})
+
+    # split train and test based in speaker independent and balanced emotion
+    # allocate speakers >= 55 for test
+    df_test = df[df["speaker"] > "57"]  #python3.9 newer 
+    # df_test = df[df["speaker"].astype(int) > 57]
+    df_train = df.drop(df_test.index)
+
+    # save to csv
+    df.to_csv(output_dir / "demos.csv", index=False)
+    df_train.to_csv(output_dir / "demos_train.csv", index=False)
+    df_test.to_csv(output_dir / "demos_test.csv", index=False)
+
+    print(f"Total: {len(df)}, Train: {len(df_train)}, Test: {len(df_test)}")
+
+
+if __name__ == "__main__":
+    main()
+

nkululeko-0.93.13/data/ekorpus/process_database.py

@@ -0,0 +1,54 @@
+# process_database.py --> ekorpus
+# modified from https://github.com/Strong-AI-Lab/emotion/blob/master/datasets/EESC/process.py
+# need to install textgrid: pip install textgrid
+
+import argparse
+from pathlib import Path
+
+import pandas as pd
+import textgrid
+from sklearn.model_selection import train_test_split
+from tqdm import tqdm
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--data_dir', type=str, default='EKORPUS')
+    parser.add_argument('--output_dir', type=str, default='.')
+    args = parser.parse_args()
+
+    data_dir = Path(args.data_dir)
+    output_dir = Path(args.output_dir)
+
+    paths = list(data_dir.glob('*.wav'))
+
+    labels = {}
+    sentences = {}
+    for path in tqdm(
+        data_dir.glob("*.TextGrid"), desc="Processing annotations", total=len(paths)
+    ):
+        grid = textgrid.TextGrid.fromFile(path)
+        labels[path.stem] = grid.getFirst("emotion")[0].mark
+        sentences[path.stem] = grid.getFirst("sentence")[0].mark
+
+    emotion = labels.values()
+    language = ['estonian' for _ in range(len(paths))]
+
+    df = pd.DataFrame(
+        {"file": paths, "emotion": emotion, "language": language})
+
+    # split for training and test
+    df_train, df_test = train_test_split(
+        df, test_size=0.2, random_state=42, stratify=df['emotion'])
+
+
+    # save to CSV
+    df.to_csv(output_dir / 'ekorpus.csv', index=False)
+    df_train.to_csv(output_dir / 'ekorpus_train.csv', index=False)
+    df_test.to_csv(output_dir / 'ekorpus_test.csv', index=False)
+
+    print(f"EKORPUS: {len(df)} samples, {len(df_train)} train, {len(df_test)} test")
+
+
+if __name__ == '__main__':
+    main()

nkululeko-0.93.13/data/emns/process_database.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# process_database.py --> EMNS
+
+import argparse
+from pathlib import Path
+
+import pandas as pd
+from sklearn.model_selection import train_test_split
+
+emotion_map = {
+    'Sarcastic': 'sarcastic',
+    'Excited': 'happiness',         # merge excited with happiness
+    'Neutral': 'neutral',
+    'Surprised': 'surprise',
+    'Disgust': 'disgust',
+    'Sad': 'sadness',
+    'Angry': 'anger',
+    'Happy': 'happiness'
+}
+
+def main():
+    parser = argparse.ArgumentParser(description='Process database')    
+    parser.add_argument('--data_dir', type=str, default='EMNS', help='data directory')
+    parser.add_argument('--metadata_file', type=str, default='EMNS/metadata.csv', help='metadata file')
+    parser.add_argument('--output_dir', type=str, default='.', help='data file')
+    args = parser.parse_args()
+
+    data_dir = Path(args.data_dir)
+    metadata_file = Path(args.metadata_file)
+    output_dir = Path(args.output_dir)
+
+    if not output_dir.exists():
+        output_dir.mkdir()
+
+    df = pd.read_csv(metadata_file, delimiter='|')
+
+    # male all lowercase
+    df = df.rename(columns={'audio_recording': 'file', 'user_id': 'speaker'})
+
+    # remove wavs path from file names
+    df['file'] = df['file'].str.replace('wavs/', '')
+    
+    # make gender lowercase
+    df['gender'] = df['gender'].str.lower()
+
+    # map emotions
+    df['emotion'] = df['emotion'].map(emotion_map)
+
+    # split into train and test based on emotion
+    train, test = train_test_split(df, test_size=0.2, stratify=df['emotion'])
+
+    # save to csv
+    train.to_csv(output_dir / 'emns_train_webm.csv', index=False)
+    test.to_csv(output_dir / 'emns_test_webm.csv', index=False)
+
+    # save to csv with WAV extension
+    train['file'] = train['file'].str.replace('.webm', '.wav')
+    train.to_csv(output_dir / 'emns_train.csv', index=False)
+    test['file'] = test['file'].str.replace('.webm', '.wav')
+    test.to_csv(output_dir / 'emns_test.csv', index=False)
+
+    print(f"Total: {len(df)}, Train: {len(train)}, Test: {len(test)}")
+
+
+if __name__ == '__main__':
+    main()

nkululeko-0.93.13/data/emofilm/convert_to_16k.py

@@ -0,0 +1,38 @@
+# python code to convert wav fils from 44.1kHz to 16kHz
+# arguments: input_dir, output_dir
+# sox must be installed
+
+import argparse
+import os
+import subprocess
+
+parser = argparse.ArgumentParser()
+parser.add_argument('-i', '--input_dir', type=str, default='./EmoFilm/wav_corpus')
+parser.add_argument('-o', '--output_dir', type=str, default='./EmoFilm/wav_corpus_16k')
+args = parser.parse_args()
+
+source_dir = args.input_dir
+target_dir = args.output_dir
+
+# create the target directory if it does not exist
+if not os.path.exists(target_dir):
+    os.makedirs(target_dir)
+
+# Define the target sample rate
+target_sr = 16000
+
+# Loop over all audio files in the source directory
+for root, dirs, files in os.walk(source_dir):
+    for file in files:
+        if file.endswith(('.wav', '.mp3')):
+            # print(file)
+            print(f"Resampling {os.path.join(root, file)} to 16kHz")
+
+            # Define the input and output file paths
+            input_path = os.path.join(root, file)
+            # obtain the basename
+            basename = os.path.basename(input_path)
+            output_path = os.path.join(target_dir, basename[:-4] + '_16k.wav')
+            
+            # Use sox to resample the audio file
+            subprocess.run(['sox', input_path, '-r', str(target_sr), output_path, 'gain', '1'])