added annotations

.gitignore

@@ -4,4 +4,7 @@ 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/dataset_audio_validation.parquet.gzip
+
+*.ipynb*
+test.py

data/clip_metadata.py

@@ -4,7 +4,7 @@ _SPLIT = "train"
 
 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 = df.filter(["label_string", "probability", "probability_vector", "prediction",
+                "prediction_string", "embedding_reduced"], axis=1)
 
 clipped_df.to_parquet("data/dataset_audio_" + _SPLIT +"_clipped.parquet.gzip")

data/create_enriched_annotated_speechcommands.py

@@ -5,8 +5,6 @@
 # 
 # We use the Huggingface transformers library to create an embedding for a an audio dataset
 # 
-# 
-# 
 
 # ## tldr; Play as callable functions
 
@@ -15,12 +13,12 @@
 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"
+_MODELNAME = "MIT/ast-finetuned-speech-commands-v2"
 
 def __set_device():
     device = "cuda" if torch.cuda.is_available() else "cpu"   
@@ -28,56 +26,47 @@ def __set_device():
         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)
+def __permute_model2dataset_probabilities(model_probabilities):
+    """
+    Model and dataset int mapping is different. Therefore, we need to permute the model's 
+    logits to match up to the dataset's order.
+    Due to small size of vector do this on cpu
+    """
+    cpu_copy = model_probabilities.to("cpu").detach().numpy()
     
-    return updated_dataset
-
-
+    # only select model2dataset_truncated values as they map model ints to existing dataset ints
+    permuted_vector = np.empty(shape=(len(labels),))
+    # Problem: model output has more output classes than dataset
+    # Hence, only add those outputs that are mapped
+    for key in model2dataset_truncated:
+        dataset_int = model2dataset_truncated[key]
+        permuted_vector[dataset_int] = cpu_copy[key]
 
+    return permuted_vector
 
 
 
-def batch_probabilities(model, feature_extractor):
+def batch_probabilities_and_embeddings(model, feature_extractor, classifier):
     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}
+
+        embeddings = classifier(**inputs).last_hidden_state[:, 0].cpu()
+        return {"logits":torch.tensor([__permute_model2dataset_probabilities(logit) for logit in outputs.logits]), "embedding": embeddings}
     return processing
     
 
-def annotate_probabilities(dataset, modelname, batched=True, batch_size= 8):
+def annotate_probabilities_and_embeddings(dataset, modelname, batched=True, batch_size= 8):
+
     model = ASTForAudioClassification.from_pretrained(modelname)
     feature_extractor = AutoFeatureExtractor.from_pretrained(modelname, padding=True)
+    classifier = AutoModel.from_pretrained(modelname, output_hidden_states=True)
     
     device = __set_device()
-    calc_outputs = batch_probabilities (model.to(device), feature_extractor)
+    calc_outputs = batch_probabilities_and_embeddings(model.to(device), feature_extractor, classifier.to(device))
     output_dataset = dataset.map(calc_outputs, batched = batched, batch_size = batch_size)
     
     return output_dataset
@@ -94,15 +83,18 @@ def annotate_batch(model, dataset):
         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
+
+        # logits are already permuted to match dataset ordering -> no additional work needed
+
+        predicted_labels = [labels[predicted_class_id] for predicted_class_id in predicted_class_ids]
         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 {"label_string": annotated_labels, "probability": probabilities, 
+                "probability_vector": probabilities_per_class,
+                "prediction": predicted_class_ids,
+                "prediction_string": predicted_labels}
 
     return batch_annotation
 
@@ -131,6 +123,16 @@ dataset = datasets.load_dataset('speech_commands', 'v0.01', split=_SPLIT)
 
 
 labels = dataset.features["label"].names
+# use dict comprehension to build a dict that maps the dataset's string label to the dataset's int label
+label_dict = {label: i for label, i in zip(labels, range(len(labels)))}
+# {key: value for key, value in zip(keys, values)}
+model = ASTForAudioClassification.from_pretrained(_MODELNAME)
+# look up label from model int in the label dict and translate that label into the dataset int
+model2dataset_int_conversion = {i: label_dict[model.config.id2label[i]] if model.config.id2label[i] in label_dict.keys() 
+                                 else -1 for i in range(model.config.num_labels)}
+
+model2dataset_truncated = {key:value for key,value in model2dataset_int_conversion.items() if value != -1}
+
 
 
 # Let's have a look at all of the labels that we want to predict
@@ -138,23 +140,15 @@ labels = dataset.features["label"].names
 print(labels)
 
 
-# ### Compute probabilities and annotate dataset
-
-# First, calculate logits per sample
+# ### Compute probabilities and embeddings and annotate dataset
 
 
-# calculate logits for each sample and annotate
-dataset_annotated = annotate_probabilities(dataset, "MIT/ast-finetuned-speech-commands-v2")
+# calculate logits and embedding for each sample and annotate
+dataset_annotated = annotate_probabilities_and_embeddings(dataset, _MODELNAME)
 
 
 # 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")
+dataset_enriched = annotate_dataset(dataset_annotated, _MODELNAME)
 
 
 # ### Reduce embeddings for faster visualization
@@ -165,9 +159,6 @@ 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()
 
 

data/dataset_audio_test_clipped.parquet.gzip

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

data/dataset_audio_train_clipped.parquet.gzip

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

data/dataset_audio_validation_clipped.parquet.gzip

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

speech_commands_enriched.py

@@ -168,10 +168,11 @@ class SpeechCommands(datasets.GeneratorBasedBuilder):
                     "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),
+                    "label_string": datasets.Value("string"),
+                    "probability": datasets.Value("float64"),
+                    "probability_vector": datasets.Sequence(feature=datasets.Value("float64"), length=31),
+                    "prediction": datasets.ClassLabel(names=self.config.labels),
+                    "prediction_string":datasets.Value("string"),
                     "embedding_reduced": datasets.Sequence(feature=datasets.Value("float32"), length=2),
                 }
             ),
@@ -258,14 +259,15 @@ class SpeechCommands(datasets.GeneratorBasedBuilder):
                 "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"],
+                "label_string": row[1]["label_string"],
+                "probability": row[1]["probability"],
+                "probability_vector": row[1]["probability_vector"],
+                "prediction": row[1]["prediction"],
+                "prediction_string": row[1]["prediction_string"],
                 "embedding_reduced": row[1]["embedding_reduced"]
             }
 
 #for debugging, comment out after
-#if __name__ == "__main__":
-    #ds = datasets.load_dataset("speech_commands_enriched.py", 'v0.01', split="test", 
-    #                           streaming=False)
+if __name__ == "__main__":
+    ds = datasets.load_dataset("speech_commands_enriched.py", 'v0.01', split="test", 
+                               streaming=False)