Upload 3 files

app.py

@@ -0,0 +1,130 @@
+
+import gradio as gr
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchaudio
+import numpy as np
+import os
+
+# Import the model architecture from model.py
+# Make sure model.py exists and contains the AudioCNN class definition
+try:
+    from model import AudioCNN
+except ImportError:
+    print("Error: model.py not found. Please ensure the model architecture is defined in model.py.")
+    # Define a placeholder class to avoid NameError if model.py is missing
+    class AudioCNN(nn.Module):
+        def __init__(self, num_classes, input_shape):
+            super(AudioCNN, self).__init__()
+            print("Placeholder AudioCNN model used as model.py was not found.")
+            self.dummy_layer = nn.Linear(1, 1)
+        def forward(self, x):
+            return self.dummy_layer(x.view(x.size(0), -1)[:, :1])
+
+
+# Define the input shape and number of classes used during training
+# These values should match what was used in the training step
+num_classes = 2
+# Assuming the training was done with MFCC features of shape (batch_size, 1, 40, 156)
+# You might need to adjust this input_shape based on your actual training data
+input_shape = (1, 40, 156) # (channels, height, width) - Adjust if your training used different dimensions
+
+# Instantiate the model and load the trained state dictionary
+model = AudioCNN(num_classes, input_shape)
+model_save_path = "audio_cnn_model.pth"
+
+# Check if the model file exists before loading
+if os.path.exists(model_save_path):
+    try:
+        model.load_state_dict(torch.load(model_save_path, map_location=torch.device('cpu'))) # Map to CPU
+        model.eval() # Set the model to evaluation mode
+        print(f"Model state dictionary loaded from {model_save_path}")
+    except Exception as e:
+        print(f"Error loading model state dictionary: {e}")
+        model = None
+else:
+    print(f"Error: Model state dictionary not found at {model_save_path}. Please ensure the trained model is saved and available.")
+    model = None # Set model to None if loading fails
+
+
+# Define the prediction function
+def predict_audio(audio_file_path):
+    if model is None:
+        return "Model not loaded. Cannot make predictions."
+    if audio_file_path is None:
+        return "No audio file provided."
+
+    try:
+        # Load the audio file
+        waveform, sample_rate = torchaudio.load(audio_file_path)
+
+        # Ensure the audio is mono (single channel) and add batch dimension
+        if waveform.shape[0] > 1:
+            waveform = torch.mean(waveform, dim=0, keepdim=True).unsqueeze(0)
+        else:
+             waveform = waveform.unsqueeze(0).unsqueeze(0) # Add channel and batch dimension if missing
+
+
+        # Define the MFCC transform (using the same parameters as training)
+        mfcc_transform = torchaudio.transforms.MFCC(
+            sample_rate=sample_rate,
+            n_mfcc=40
+        )
+
+        # Apply the transform
+        # mfcc_features will have shape (batch_size, n_mfcc, sequence_length)
+        mfcc_features = mfcc_transform(waveform)
+
+        # Ensure the features have the correct shape (batch_size, 1, 40, sequence_length) for the CNN
+        # mfcc_features is currently (1, 40, sequence_length) from torchaudio after processing one audio
+        # Add channel dimension
+        mfcc_features = mfcc_features.unsqueeze(1)
+
+
+        # Pad or truncate the features to match the expected input_shape width
+        target_width = input_shape[2]
+        if mfcc_features.shape[3] < target_width:
+            # Pad with zeros
+            padding = target_width - mfcc_features.shape[3]
+            mfcc_features = torch.nn.functional.pad(mfcc_features, (0, padding))
+        elif mfcc_features.shape[3] > target_width:
+            # Truncate
+            mfcc_features = mfcc_features[:, :, :, :target_width]
+
+        # Run inference
+        with torch.no_grad():
+            outputs = model(mfcc_features)
+
+        # Get the predicted class index
+        _, predicted_index = torch.max(outputs.data, 1)
+        predicted_index = predicted_index.item()
+
+        # Interpret the prediction
+        # Assuming your labels were 0 and 1 during training.
+        # You'll need to know what 0 and 1 correspond to in your dataset.
+        label_map = {0: 'English', 1: 'Code-switched'} # Replace with your actual label mapping
+        predicted_label = label_map.get(predicted_index, "Unknown")
+
+        return predicted_label
+
+    except Exception as e:
+        return f"Error during prediction: {e}"
+
+
+# Create the Gradio interface
+if model is not None:
+    interface = gr.Interface(
+        fn=predict_audio,
+        inputs=gr.Audio(type="filepath"),
+        outputs=gr.Label(),
+        title="Audio Code-Switching Detector",
+        description="Upload an audio file to detect if it contains code-switching.",
+    )
+
+    # Launch the interface (for testing locally)
+    # interface.launch(debug=True)
+else:
+    print("Gradio interface not created due to model loading error.")
+
+# This script will be saved as app.py for Hugging Face Spaces deployment

audio_cnn_model.pth

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

requirements.txt

@@ -0,0 +1,8 @@
+
+gradio
+torch
+torchaudio
+datasets
+# Add any other libraries your model or data loading might need
+# e.g., scikit-learn if you used train_test_split in your final app code
+sklearn # Added based on previous usage of train_test_split