build script

.gitattributes

@@ -52,3 +52,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
+*.parquet.gzip filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,7 @@
+Pipfile
+Pipfile.lock
+
+data/dataset_audio_annotated_and_embedding_with_probs.parquet.gzip
+data/dataset_audio_test.parquet.gzip
+data/dataset_audio_train.parquet.gzip
+data/dataset_audio_validation.parquet.gzip

data/clip_metadata.py

@@ -0,0 +1,10 @@
+import pandas as pd
+
+_SPLIT = "validation"
+
+df = pd.read_parquet("data/dataset_audio_" + _SPLIT +".parquet.gzip")
+
+clipped_df = df.filter(["Probability", "Predicted Label", "Annotated Labels", "Probability Vector", "embedding_reduced"], 
+                       axis=1)
+
+clipped_df.to_parquet("data/dataset_audio_" + _SPLIT +"_clipped.parquet.gzip")

data/create_enriched_annotated_speechcommands.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# # Create embeddings with the transformer library
+# 
+# We use the Huggingface transformers library to create an embedding for a an audio dataset
+# 
+# 
+# 
+
+# ## tldr; Play as callable functions
+
+
+
+import datasets
+from transformers import AutoFeatureExtractor, AutoModel, ASTForAudioClassification
+import torch
+from renumics import spotlight
+import pandas as pd
+import umap
+import numpy as np
+
+_SPLIT = "train"
+
+def __set_device():
+    device = "cuda" if torch.cuda.is_available() else "cpu"   
+    if device == "cuda":
+        torch.cuda.empty_cache()
+    return device
+
+
+def extract_embeddings(model, feature_extractor):
+    """Utility to compute embeddings."""
+    device = model.device
+
+    def pp(batch):
+        audios = [element["array"] for element in batch["audio"]]
+        inputs = feature_extractor(raw_speech=audios, return_tensors="pt", padding=True).to(device)        
+        embeddings = model(**inputs).last_hidden_state[:, 0].cpu()
+        
+        return {"embedding": embeddings}
+        
+
+    return pp
+
+
+def huggingface_embedding(dataset, modelname, batched=True, batch_size=8):
+    # initialize huggingface model
+    feature_extractor = AutoFeatureExtractor.from_pretrained(modelname, padding=True)
+    model = AutoModel.from_pretrained(modelname, output_hidden_states=True)
+
+    #compute embedding  
+    device = __set_device()
+    extract_fn = extract_embeddings(model.to(device), feature_extractor)
+    updated_dataset = dataset.map(extract_fn, batched=batched, batch_size=batch_size)
+    
+    return updated_dataset
+
+
+
+
+
+
+def batch_probabilities(model, feature_extractor):
+    device = model.device
+    
+    def processing(batch):
+        audios = [element["array"] for element in batch["audio"]]
+        inputs = feature_extractor(raw_speech=audios, return_tensors="pt", padding=True, sampling_rate=16000).to(device)
+        outputs = model(**inputs)
+        return {"logits": outputs.logits}
+    return processing
+    
+
+def annotate_probabilities(dataset, modelname, batched=True, batch_size= 8):
+    model = ASTForAudioClassification.from_pretrained(modelname)
+    feature_extractor = AutoFeatureExtractor.from_pretrained(modelname, padding=True)
+    
+    device = __set_device()
+    calc_outputs = batch_probabilities (model.to(device), feature_extractor)
+    output_dataset = dataset.map(calc_outputs, batched = batched, batch_size = batch_size)
+    
+    return output_dataset
+
+
+
+
+
+
+def annotate_batch(model, dataset):
+    device = model.device
+    
+    def batch_annotation(batch):
+        logits = [torch.tensor(element) for element in batch["logits"]]
+        probabilities_per_class = [torch.nn.functional.softmax(logit, dim=-1) for logit in logits]
+        predicted_class_ids = [torch.argmax(logit).item() for logit in logits]
+        predicted_labels = [model.config.id2label[predicted_class_id] for predicted_class_id in predicted_class_ids]
+        # pre-trained model to different amount of classes 
+        # -> id2label only reflects "internal label", not actual dataset label
+        annotated_labels = [labels[element] for element in batch["label"]]
+        probabilities = []
+        for index, prob_per_class in enumerate(probabilities_per_class):
+            probabilities.append(prob_per_class[predicted_class_ids[index]].item())
+        return {"Probability": probabilities, "Predicted Label": predicted_labels, 
+                "Annotated Labels": annotated_labels, "Probability Vector": probabilities_per_class}
+
+    return batch_annotation
+
+def annotate_dataset(dataset, modelname, batched=True, batch_size=8):
+    model = ASTForAudioClassification.from_pretrained(modelname)
+    device = __set_device()
+    
+    annotate = annotate_batch(model.to(device), dataset)
+    annotated_dataset = dataset.map(annotate, batched=batched, batch_size=batch_size)
+ 
+    return annotated_dataset
+    
+
+
+
+
+# ## Step-by-step example on speech-commands
+# 
+# ### Load speech-commands from Huggingface hub
+
+# Use validation split to evaluate model's performance on unseen data
+
+
+
+dataset = datasets.load_dataset('speech_commands', 'v0.01', split=_SPLIT)
+
+
+labels = dataset.features["label"].names
+
+
+# Let's have a look at all of the labels that we want to predict
+
+print(labels)
+
+
+# ### Compute probabilities and annotate dataset
+
+# First, calculate logits per sample
+
+
+# calculate logits for each sample and annotate
+dataset_annotated = annotate_probabilities(dataset, "MIT/ast-finetuned-speech-commands-v2")
+
+
+# Now annotate labels and probabilities
+
+dataset_annotated_complete = annotate_dataset(dataset_annotated, "MIT/ast-finetuned-speech-commands-v2")
+
+
+# ### Compute embedding with vision transformer from Huggingface
+
+dataset_enriched = huggingface_embedding(dataset_annotated_complete, "MIT/ast-finetuned-speech-commands-v2")
+
+
+# ### Reduce embeddings for faster visualization
+
+embeddings = np.stack(np.array(dataset_enriched['embedding']))
+reducer = umap.UMAP()
+reduced_embedding = reducer.fit_transform(embeddings)
+dataset_enriched = dataset_enriched.add_column("embedding_reduced", list(reduced_embedding))
+
+
+print(dataset_enriched.features)
+
+
+df = dataset_enriched.to_pandas()
+
+
+df.to_parquet("data/dataset_audio_" + _SPLIT + ".parquet.gzip", compression='gzip')

data/dataset_audio_test_clipped.parquet.gzip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8b6ae3710263e5e83c9f6784e1945b15a97bde88a6b7d1b45587b0d6278345c
+size 698777

data/dataset_audio_train_clipped.parquet.gzip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8e208d54feef82c4a7e1f120787e4b1074cf7cad75035e3640714636965e84f
+size 8525172

data/dataset_audio_validation_clipped.parquet.gzip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:390eaf7ec5fdc8a832651b6255948aeba7291ae1b2afc5de73229aa25c48a73c
+size 1566541

speech_commands_enriched.py

@@ -22,6 +22,7 @@ import datasets
 
 from pathlib import Path
 
+import pandas as pd
 
 _CITATION = """
 @article{speechcommandsv2,
@@ -51,6 +52,7 @@ Version 0.01 of the data set (configuration `"v0.01"`) was released on August 3r
 In version 0.01 thirty different words were recoded: "Yes", "No", "Up", "Down", "Left",
 "Right", "On", "Off", "Stop", "Go", "Zero", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine",
 "Bed", "Bird", "Cat", "Dog", "Happy", "House", "Marvin", "Sheila", "Tree", "Wow".
+This version is not yet supported.
 
 
 In version 0.02 more words were added: "Backward", "Forward", "Follow", "Learn", "Visual".
@@ -130,17 +132,17 @@ class SpeechCommandsConfig(datasets.BuilderConfig):
 
 class SpeechCommands(datasets.GeneratorBasedBuilder):
     BUILDER_CONFIGS = [
-        SpeechCommandsConfig(
-            name="v0.01",
-            description=textwrap.dedent(
-                """\
-                Version 0.01 of the SpeechCommands dataset. Contains 30 words
-                (20 of them are auxiliary) and background noise.
-                """
-            ),
-            labels=LABELS_V1,
-            version=datasets.Version("0.1.0"),
-        ),
+        #SpeechCommandsConfig(
+        #    name="v0.01",
+        #    description=textwrap.dedent(
+        #        """\
+        #        Version 0.01 of the SpeechCommands dataset. Contains 30 words
+        #        (20 of them are auxiliary) and background noise.
+        #        """
+        #    ),
+        #    labels=LABELS_V1,
+        #    version=datasets.Version("0.1.0"),
+        #),
         SpeechCommandsConfig(
             name="v0.02",
             description=textwrap.dedent(
@@ -165,6 +167,12 @@ class SpeechCommands(datasets.GeneratorBasedBuilder):
                     "is_unknown": datasets.Value("bool"),
                     "speaker_id": datasets.Value("string"),
                     "utterance_id": datasets.Value("int8"),
+                    #enriched features:
+                    "Probability": datasets.Value("float64"),
+                    "Predicted Label": datasets.Value("string"),
+                    "Annotated Labels": datasets.Value("string"),
+                    "Probability Vector": datasets.Sequence(feature=datasets.Value("float64"), length=35),
+                    "embedding_reduced": datasets.Sequence(feature=datasets.Value("float32"), length=2),
                 }
             ),
             homepage=_URL,
@@ -182,35 +190,48 @@ class SpeechCommands(datasets.GeneratorBasedBuilder):
                 "test": _DL_URL.format(name=self.config.name, split="test"),
             }
         )
+        
+        metadata_paths = dl_manager.download(
+            {
+                "train": "data/dataset_audio_train_clipped.parquet.gzip",
+                "test": "data/dataset_audio_test_clipped.parquet.gzip",
+                "validation": "data/dataset_audio_validation_clipped.parquet.gzip"
+            }
+        )
 
         return [
             datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
                 gen_kwargs={
                     "archive_path": dl_manager.download_and_extract(archive_paths["train"]),
+                    "metadata": pd.read_parquet(metadata_paths["train"]),
                 },
             ),
             datasets.SplitGenerator(
                 name=datasets.Split.VALIDATION,
                 gen_kwargs={
                     "archive_path": dl_manager.download_and_extract(archive_paths["validation"]),
+                    "metadata": pd.read_parquet(metadata_paths["validation"]),
                 },
             ),
             datasets.SplitGenerator(
                 name=datasets.Split.TEST,
                 gen_kwargs={
                     "archive_path": dl_manager.download_and_extract(archive_paths["test"]),
+                    "metadata": pd.read_parquet(metadata_paths["test"]),
                 },
             ),
         ]
 
-    def _generate_examples(self, archive_path):
+    def _generate_examples(self, archive_path, metadata):
 
-        
+        # HINT: metadata should already be the split-specific metadata
 
         pathlist = Path(archive_path).glob('**/*.wav')
 
-        for path in pathlist:            
+        for path, row in zip(pathlist, metadata.iterrows()): 
+            
+            # row is a tuple containg an index and a pandas series    
 
             pathcomponents = str(path).split("/")
             word = pathcomponents[-2]
@@ -236,8 +257,16 @@ class SpeechCommands(datasets.GeneratorBasedBuilder):
                 "is_unknown": is_unknown,
                 "speaker_id": speaker_id,
                 "utterance_id": utterance_id,
+                #enriched features:
+                "Probability": row[1]["Probability"],
+                "Predicted Label": row[1]["Predicted Label"],
+                "Annotated Labels": row[1]["Annotated Labels"],
+                "Probability Vector": row[1]["Probability Vector"],
+                "embedding_reduced": row[1]["embedding_reduced"]
             }
 
-#for debugging
-#if __name__ == "__main__":
-#    ds = datasets.load_dataset("speech_commands_enriched.py", 'v0.01', split="train", streaming=False)
+#for debugging, comment out after
+if __name__ == "__main__":
+    datasets.builder.has_sufficient_disk_space = lambda needed_bytes, directory='.': True
+    ds = datasets.load_dataset("speech_commands_enriched.py", 'v0.02', split="train", 
+                               streaming=False)