Update app.py

app.py

@@ -3,81 +3,77 @@ import tensorflow_hub as hub
 import numpy as np
 import matplotlib.pyplot as plt
 import gradio as gr
-import soundfile as sf
-from scipy.signal import resample  # Correct resampling method
+from scipy.signal import resample
 
-# Load YAMNet model from TensorFlow Hub
-yamnet_model_handle = "https://tfhub.dev/google/yamnet/1"
-yamnet_model = hub.load(yamnet_model_handle)
+# Load YAMNet model
+yamnet_model = hub.load("https://tfhub.dev/google/yamnet/1")
 
-# Load class labels
+# Load class names
 def load_class_map():
     class_map_path = tf.keras.utils.get_file(
         'yamnet_class_map.csv',
         'https://raw.githubusercontent.com/tensorflow/models/master/research/audioset/yamnet/yamnet_class_map.csv'
     )
     with open(class_map_path, 'r') as f:
-        class_names = [line.strip().split(',')[2] for line in f.readlines()[1:]]
-    return class_names
+        return [line.strip().split(',')[2] for line in f.readlines()[1:]]
 
 class_names = load_class_map()
 
-# Classification function
-def classify_audio(file_path):
+# Classification function for binary audio input
+def classify_audio(audio, sample_rate):
     try:
-        # Load audio file (WAV, MP3, etc.)
-        audio_data, sample_rate = sf.read(file_path)
+        # Convert stereo to mono
+        if len(audio.shape) > 1:
+            audio = np.mean(audio, axis=1)
 
-        # Convert stereo to mono if needed
-        if len(audio_data.shape) > 1:
-            audio_data = np.mean(audio_data, axis=1)
+        # Normalize
+        audio = audio / np.max(np.abs(audio))
 
-        # Normalize audio
-        audio_data = audio_data / np.max(np.abs(audio_data))
-
-        # Resample to 16kHz if necessary
-        target_rate = 16000
-        if sample_rate != target_rate:
-            duration = audio_data.shape[0] / sample_rate
-            new_length = int(duration * target_rate)
-            audio_data = resample(audio_data, new_length)
+        # Resample if needed
+        target_sr = 16000
+        if sample_rate != target_sr:
+            duration = audio.shape[0] / sample_rate
+            new_length = int(duration * target_sr)
+            audio = resample(audio, new_length)
+            sample_rate = target_sr
 
         # Convert to tensor
-        waveform = tf.convert_to_tensor(audio_data, dtype=tf.float32)
+        waveform = tf.convert_to_tensor(audio, dtype=tf.float32)
 
-        # Run YAMNet
+        # Predict
         scores, embeddings, spectrogram = yamnet_model(waveform)
         mean_scores = tf.reduce_mean(scores, axis=0).numpy()
         top_5 = np.argsort(mean_scores)[::-1][:5]
 
+        # Extract predictions
         top_prediction = class_names[top_5[0]]
-        top_scores = {class_names[i]: float(mean_scores[i]) for i in top_5}
+        top_scores = {class_names[i]: float(mean_scores[i]) for i in top_5]
 
         # Create waveform plot
         fig, ax = plt.subplots()
-        ax.plot(audio_data)
+        ax.plot(audio)
         ax.set_title("Waveform")
-        ax.set_xlabel("Time")
+        ax.set_xlabel("Time (samples)")
         ax.set_ylabel("Amplitude")
         plt.tight_layout()
 
         return top_prediction, top_scores, fig
 
     except Exception as e:
-        return f"Error processing audio: {e}", {}, None
+        return f"Error: {str(e)}", {}, None
 
-# Gradio interface
+# Gradio Interface (IMPORTANT: type="numpy" allows binary POSTs from n8n)
 interface = gr.Interface(
     fn=classify_audio,
-    inputs=gr.Audio(type="filepath", label="Upload .wav or .mp3 audio file"),
+    inputs=gr.Audio(source="upload", type="numpy", label="Upload .wav or .mp3"),
     outputs=[
         gr.Textbox(label="Top Prediction"),
-        gr.Label(label="Top 5 Classes with Scores"),
+        gr.Label(label="Top 5 Class Scores"),
         gr.Plot(label="Waveform")
     ],
     title="Audtheia YAMNet Audio Classifier",
-    description="Upload an environmental or animal sound to classify using the YAMNet model. Returns label predictions and waveform."
+    description="Classifies audio with YAMNet and returns predictions with waveform plot."
 )
 
 if __name__ == "__main__":
-    interface.launch()
+    interface.launch()