Adding all files

app.py

@@ -0,0 +1,75 @@
+import gradio as gr
+import os
+import joblib
+from sound_classifier import SoundClassifier
+import numpy as np
+
+# Get list of available models and their friendly names
+MODELS_DIR = 'models'
+MODEL_NAMES = {
+    'lr_sound_classifier_model.joblib': 'Logistic Regression',
+    'nn_sound_classifier_model.joblib': 'Neural Network',
+    'rf_sound_classifier_model.joblib': 'Random Forest',
+    'svm_sound_classifier_model.joblib': 'Support Vector Machine'
+}
+
+model_files = [f for f in os.listdir(MODELS_DIR) if f.endswith('_model.joblib')]
+model_choices = {MODEL_NAMES[file]: file for file in model_files}
+
+def load_model(model_file):
+    """Load a saved model and its associated scaler and label encoder"""
+    model_path = os.path.join(MODELS_DIR, model_file)
+    saved_data = joblib.load(model_path)
+    return saved_data['model'], saved_data['scaler'], saved_data['label_encoder']
+
+def format_issue(issue_text):
+    """Format the issue text to be more readable"""
+    # Replace underscores with spaces and title case the text
+    formatted = issue_text.replace('_', ' ').title()
+    return formatted
+
+def predict_sound(audio_file, model_name):
+    """
+    Function to make predictions on uploaded audio files using the selected model
+    """
+    # Get the actual model filename from the friendly name
+    model_file = model_choices[model_name]
+    
+    # Load the selected model
+    model, scaler, le = load_model(model_file)
+    
+    # Initialize classifier for feature extraction only
+    classifier = SoundClassifier(data_dir='data')
+    
+    # Extract features and predict
+    features = classifier.extract_features(audio_file)
+    features = features.reshape(1, -1)
+    features_scaled = scaler.transform(features)
+    prediction = model.predict(features_scaled)
+    
+    # Get the predicted label and format it
+    predicted_label = le.inverse_transform(prediction)[0]
+    formatted_label = format_issue(predicted_label)
+    
+    return f"Predicted Issue: {formatted_label}"
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=predict_sound,
+    inputs=[
+        gr.Audio(type="filepath", label="Upload Sound File"),
+        gr.Dropdown(choices=list(model_choices.keys()), label="Select Model Type", value=list(model_choices.keys())[0])
+    ],
+    outputs=gr.Textbox(label="Prediction"),
+    title="Engine Sound Issue Classifier",
+    description="Upload an audio file of engine sound to identify potential issues. Choose from different machine learning models.",
+    examples=[
+        [os.path.join("test_data", "air_filter_sample_5.wav"), list(model_choices.keys())[0]],
+        [os.path.join("test_data", "cd_sample_16.wav"), list(model_choices.keys())[1]],
+        [os.path.join("test_data", "vl_sample_4.wav"), list(model_choices.keys())[2]]
+    ]
+)
+
+if __name__ == "__main__":
+    iface.launch()
+

models/lr_sound_classifier_model.joblib

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

models/nn_sound_classifier_model.joblib

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

models/rf_sound_classifier_model.joblib

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

models/svm_sound_classifier_model.joblib

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

requirements.txt

@@ -0,0 +1,12 @@
+numpy>=1.20.0
+librosa>=0.9.0
+scikit-learn>=0.24.0
+joblib>=1.0.0
+pandas>=1.3.0
+matplotlib>=3.4.0
+seaborn>=0.11.0
+scipy>=1.7.0
+gradio>=4.0.0
+onnx>=1.15.0
+skl2onnx>=1.14.0
+onnxruntime>=1.16.0

sound_classifier.py

@@ -0,0 +1,142 @@
+import os
+import numpy as np
+import librosa
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import SVC
+from sklearn.neural_network import MLPClassifier
+from sklearn.metrics import classification_report
+import joblib
+
+
+class SoundClassifier:
+    def __init__(self, data_dir, model_type='rf', sr=22050, duration=20):
+        self.data_dir = data_dir
+        self.sr = sr
+        self.duration = duration
+        self.model = None
+        self.le = LabelEncoder()
+        self.scaler = StandardScaler()
+        self.model_type = model_type
+
+    def extract_features(self, file_path):
+        # Load audio file
+        y, _ = librosa.load(file_path, sr=self.sr, duration=self.duration)
+
+        # Pad or truncate to fixed length
+        if len(y) < self.sr * self.duration:
+            y = np.pad(y, (0, self.sr * self.duration - len(y)))
+        else:
+            y = y[:self.sr * self.duration]
+
+        # Extract features
+        mfccs = librosa.feature.mfcc(y=y, sr=self.sr, n_mfcc=13)
+        spectral_centroid = librosa.feature.spectral_centroid(y=y, sr=self.sr)
+        spectral_rolloff = librosa.feature.spectral_rolloff(y=y, sr=self.sr)
+
+        # Compute statistics
+        features = np.concatenate([
+            mfccs.mean(axis=1),
+            mfccs.std(axis=1),
+            spectral_centroid.mean(axis=1),
+            spectral_rolloff.mean(axis=1)
+        ])
+
+        return features
+
+    def prepare_data(self):
+        X = []
+        y = []
+
+        # Iterate through each issue folder
+        for issue in os.listdir(self.data_dir):
+            issue_path = os.path.join(self.data_dir, issue)
+            if os.path.isdir(issue_path):
+                # Process each audio file in the folder
+                for audio_file in os.listdir(issue_path):
+                    if audio_file.endswith('.wav'):
+                        file_path = os.path.join(issue_path, audio_file)
+                        features = self.extract_features(file_path)
+                        X.append(features)
+                        y.append(issue)
+        print(len(X))
+        print(len(y))
+        X = np.array(X)
+        y = self.le.fit_transform(y)
+
+        return X, y
+
+    def train(self):
+        # Prepare data
+        X, y = self.prepare_data()
+
+        # Split data
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=0.2, random_state=42
+        )
+
+        # Scale features
+        X_train_scaled = self.scaler.fit_transform(X_train)
+        X_test_scaled = self.scaler.transform(X_test)
+
+        # Train model based on model_type
+        if self.model_type == 'rf':
+            self.model = RandomForestClassifier(n_estimators=100, random_state=42)
+        elif self.model_type == 'lr':
+            self.model = LogisticRegression(random_state=42, max_iter=1000)
+        elif self.model_type == 'svm':
+            self.model = SVC(kernel='rbf', random_state=42)
+        elif self.model_type == 'nn':
+            self.model = MLPClassifier(hidden_layer_sizes=(100, 50), max_iter=1000, random_state=42)
+        else:
+            raise ValueError("Invalid model type. Choose 'rf', 'lr', 'svm', or 'nn'.")
+
+        self.model.fit(X_train_scaled, y_train)
+
+        # Evaluate
+        y_pred = self.model.predict(X_test_scaled)
+        print(f"\nModel Performance ({self.model_type}):")
+        print(classification_report(y_test, y_pred,
+                                    labels=np.unique(y),
+                                    target_names=self.le.classes_[np.unique(y)]))
+
+        return self.model
+
+    def predict(self, audio_file):
+        # Extract features from new audio
+        features = self.extract_features(audio_file)
+
+        # Scale features
+        features_scaled = self.scaler.transform([features])
+
+        # Make prediction
+        prediction = self.model.predict(features_scaled)[0]
+
+        # Return the issue name
+        return self.le.inverse_transform([prediction])[0]
+
+    def save_model(self, model_path='sound_classifier_model.joblib'):
+        """Save the trained model, label encoder, and scaler"""
+        if self.model is None:
+            raise ValueError("Model hasn't been trained yet!")
+
+        model_data = {
+            'model': self.model,
+            'label_encoder': self.le,
+            'scaler': self.scaler,
+            'model_type': self.model_type
+        }
+        joblib.dump(model_data, model_path)
+
+    @classmethod
+    def load_model(cls, model_path='sound_classifier_model.joblib'):
+        """Load a trained model"""
+        classifier = cls(data_dir=None)  # Create instance without data dir
+        model_data = joblib.load(model_path)
+        classifier.model = model_data['model']
+        classifier.le = model_data['label_encoder']
+        classifier.scaler = model_data['scaler']
+        classifier.model_type = model_data['model_type']
+        return classifier