Added Technische Umsetzung.

Implemented FeatureExtraction from Studienarbeit.

Author: schuler-henry

chapter/TechnischeUmsetzung.tex

@@ -5,7 +5,7 @@ \section{Technische Umsetzung}\label{sec:TechnischeUmsetzung}
 Folglich findet auch die Implementierung der Signalvorverarbeitung, sowie der \ac{LPC} Berechnung mit Hilfe der Sprache Python statt.
 
 Um Programmierfehler zu vermeiden, sowie die Effizienz des Codes zu erhöhen, werden Funktionen aus verschiedenen Bibliotheken verwendet.
-Als Basis wird die Bibliothek \textKlasse{numpy} verwendet, welche Funktionen für die Bearbeitung von Arrays und Matrizen bereitstellt. 
+Als Basis wird die Bibliothek \textKlasse{numpy} verwendet, welche Funktionen für die Bearbeitung von Arrays und Matrizen bereitstellt, sowie die Bibliothek \textKlasse{librosa} für Audio spezifische Funktionen wie das Laden von WAV Dateien.
 
 \subsection{Klasse AudioPreprocessor}
 Die Klasse \textKlasse{AudioPreprocessor} (vgl. Quellcode~\ref{code:AudioPreprocessor}) beinhaltet die Funktionen für die Schritte der Signalvorverarbeitung (vgl. Kapitel~\ref{sec:Signalvorverarbeitung}).
@@ -15,3 +15,11 @@ \subsection{Klasse AudioPreprocessor}
 Die passende Fensterfunktion wird dabei ebenfalls durch die  \textKlasse{numpy} Bibliothek bereitgestellt (vgl. Zeile~\ref{line:windowFunction}).
 
 \subsection{Klasse FeatureExtractor}
+Mit Blick auf die an diese Arbeit folgende Studienarbeit wird für die Implementierung der Koeffizientenberechnung ein Ansatz gewählt, der eine einfache Erweiterung des Programms um verschiedene andere Verfahren wie etwa \ac{MFCC} ermöglicht.
+Dazu wird das Design Pattern Strategie in abgewandelter Form verwendet, wobei zunächst ein Interface für die Berechnungsverfahren erstellt werden muss (vgl. Quellcode~\ref{code:ExtractorInterface}).
+Dieses definiert die Funktion \textFunktion{calculateFeatures}, welche in den abgeleiteten Klassen implementiert wird.
+Die Klasse \textKlasse{LPCExtractor} (vgl. Quellcode~\ref{code:LPCExtractor}) nutzt hierfür die von der Bibliothek \textKlasse{librosa} bereitgestellt Funktion \textFunktion{lpc} um für die übergebenen Frames die zugehörigen \ac{LPC} Koeffizienten zu berechnen und anschließend zurückzugeben.
+Der \ac{LPC} Koeffizienten nullter Ordnung wird dabei von der Funktion standardmäßig mit der Zahl eins befüllt und ist kein Teil der berechneten \ac{LPC}-Ordnung, weshalb dieser manuell entfernt werden muss (vgl. Z.~\ref{line:removeLPC0}).
+
+Die Klasse \textKlasse{FeatureExtractor} (vgl. Quellcode~\ref{code:FeatureExtractor}) implementiert die Funktion \textFunktion{ex\-tract\-\_features}, welcher über den Parameter \textVariable{feature\_list} eine genaue Anweisung über die zu berechnenden Koeffizienten übergeben werden kann (vgl. Z.~\ref{line:extract_features}).
+Dabei kann im Speziellen eine Angabe zu der Art der Koeffizienten, der Anzahl an zu berechnenden Koeffizienten, sowie der zusätzlich zu berechnenden Ableitungs-Ordnungen übergeben werden (vgl. Z.~\ref{line:feature_list_info}).

chapter/Validierung.tex

@@ -1 +1 @@
-\section{Validierung}\label{sec:Validierung}
+\section{Validierung}\label{sec:Validierung}

code/preprocessing/AudioPreprocessor.py renamed to code/AudioPreprocessor/AudioPreprocessor.py

@@ -1,4 +1,4 @@
-from utils.utils import Utils
+import librosa
 import numpy as np
 import noisereduce as nr
 
@@ -118,7 +118,7 @@ def load_preprocessed_frames(filepath=None, y=None, sr=None):
             raise ValueError("Either filepath or y and sr must be given.")
 
         if y is None or sr is None:
-            y, sr = Utils.load_file(filepath)
+            y, sr = librosa.load(filepath)
 
         y = AudioPreprocessor.remove_noise(y=y, sr=sr)
         y = AudioPreprocessor.remove_silence(y=y)

code/preprocessing/__pycache__/AudioPreprocessor.cpython-310.pyc renamed to code/AudioPreprocessor/__pycache__/AudioPreprocessor.cpython-310.pyc

@@ -0,0 +1,3 @@
+class ExtractorInterface:    
+    def calculateFeatures(self, frames, sr, order):
+        pass

code/FeatureExtractor/ExtractorInterface.py

@@ -0,0 +1,47 @@
+from FeatureExtractor.LPCExtractor import LPCExtractor
+
+import librosa
+import numpy as np
+from enum import Enum
+
+class Feature(Enum):
+    LPC = 0
+
+class FeatureExtractor:
+    def __init__(self, frames, sr):
+        self.frames = frames
+        self.sr = sr
+        self.extractors = [
+            LPCExtractor()
+        ]
+        self.last_feature_count = 0
+
+    def extract_features(self, feature_list): #(*@\label{line:extract_features}@*)
+        """_summary_
+
+        Args:
+            feature_list ((Feature, int, int[])[]): 2D List of Features (enum) + order (int) + deltas (int[]) lists to extract #(*@\label{line:feature_list_info}@*)
+
+        Returns:
+            NDArray[]: Array of requested features for each frame
+        """
+        feature_set = None
+        
+        for feature_info in feature_list:
+            features = self.extractors[feature_info[0].value].calculateFeatures(self.frames, self.sr, feature_info[1])
+            if feature_set is None:
+                feature_set = np.array(features)
+            else:
+                np.concatenate((feature_set, np.array(features)), axis=1)
+            
+            for delta in feature_info[2]:
+                delta_features = librosa.feature.delta(np.array(features), order=delta, mode='nearest')
+                np.concatenate((feature_set, delta_features), axis=1)
+        
+        feature_set = feature_set.tolist()
+        self.last_feature_count = len(feature_set[0])
+        
+        return feature_set
+    
+    def get_last_feature_count(self):
+        return self.last_feature_count

code/FeatureExtractor/FeatureExtractor.py

@@ -0,0 +1,12 @@
+from FeatureExtractor.ExtractorInterface import ExtractorInterface
+
+import librosa
+
+class LPCExtractor(ExtractorInterface):
+    def calculateFeatures(self, frames, sr, order):
+        lpc_coefficients = []
+        
+        for frame in frames:
+            lpc_coefficients.append(librosa.lpc(y=frame, order=order)[1:]) #(*@\label{line:removeLPC0}@*)
+            
+        return lpc_coefficients

code/FeatureExtractor/LPCExtractor.py

@@ -1,10 +1,34 @@
-from preprocessing.AudioPreprocessor import AudioPreprocessor
-from feature_extraction.LPCExtractor import LPCExtractor
+from AudioPreprocessor.AudioPreprocessor import AudioPreprocessor
+from FeatureExtractor.FeatureExtractor import FeatureExtractor, Feature
+
+import librosa
+import numpy as np
+
+def unison_shuffled_copies(a, b):
+    assert len(a) == len(b)
+    p = np.random.permutation(len(a))
+    return a[p], b[p]
 
 def main():
-    frames = AudioPreprocessor.load_preprocessed_frames("C:\\Users\\SCU8BH\\Documents\\T3000\\Studienarbeit\\Data\\50_speakers_audio_data\\Speaker_0003\\Speaker_0003_00000.wav")
-    lpccs = LPCExtractor.get_lpcc_from_frames(frames=frames, order=12)
-    print(len(lpccs))
+    filePath = "C:\\Users\\SCU8BH\\Documents\\T3000\\Studienarbeit\\Data\\50_speakers_audio_data\\Speaker_0003\\Speaker_0003_00000.wav"
+    
+    # Load audio file
+    y, sr = librosa.load(filePath)
+
+    # Preprocess audio file
+    y = AudioPreprocessor.remove_noise(y=y, sr=sr)
+    y = AudioPreprocessor.remove_silence(y=y)
+    # frame-duration: 0.2 s, overlap: 0.1 s
+    frames = AudioPreprocessor.create_frames(y=y, frame_size=int(sr / 5), overlap=int(sr / 10))
+    windowed_frames = AudioPreprocessor.window_frames(frames=frames)
+
+    # Extract features
+    feature_extractor = FeatureExtractor(windowed_frames, sr)
+    # Create LPC features with 13 coefficients per frame and no derivatives
+    extraction_pattern = [
+        [Feature.LPC, 13, []]
+    ]
+    features = feature_extractor.extract_features(extraction_pattern)
 
 if __name__ == "__main__":
     main()