Update app.py

app.py

@@ -1,3 +1,4 @@
+#1
 # import os
 # import tensorflow as tf
 # import tensorflow_hub as hub
@@ -133,8 +134,6 @@
 
 
 
-
-
 import os
 import tensorflow as tf
 import tensorflow_hub as hub
@@ -142,24 +141,14 @@ import numpy as np
 import csv
 import requests
 import json
-import scipy
+import logging
 from scipy.io import wavfile
 from pydub import AudioSegment
-import gradio as gr
 import io
 from io import BytesIO
-import soundfile as sf
-import warnings
-import logging
-
-# Suppress specific warnings
-warnings.filterwarnings("ignore", category=scipy.io.wavfile.WavFileWarning)
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)  # Set logging level as needed
 
 # Load the model
-model = hub.load('https://tfhub.dev/google/yamnet/1')
+model = hub.load('Audio_Multiple_v1')
 
 def class_names_from_csv(class_map_csv_text):
     """Returns list of class names corresponding to score vector."""
@@ -176,7 +165,7 @@ class_names = class_names_from_csv(class_map_path)
 def ensure_sample_rate(original_sample_rate, waveform, desired_sample_rate=16000):
     if original_sample_rate != desired_sample_rate:  # Resample waveform if required
         desired_length = int(round(float(len(waveform)) / original_sample_rate * desired_sample_rate))
-        waveform = scipy.signal.resample(waveform, desired_length)
+        waveform = np.array(scipy.signal.resample(waveform, desired_length), dtype=np.float32)
     return desired_sample_rate, waveform
 
 def convert_mp3_to_wav(mp3_data):
@@ -184,54 +173,54 @@ def convert_mp3_to_wav(mp3_data):
     wav_buffer = io.BytesIO()
     audio.export(wav_buffer, format='wav')
     wav_buffer.seek(0)
-    return wav_buffer
+    return wav_buffer.getvalue()
 
 def process_audio_file(file_data, url):
     try:
         sample_rate, wav_data = wavfile.read(BytesIO(file_data))      
-    except Exception as e:
-        logging.error(f"Error reading WAV file from {url}: {e}")
-        return
+        
+        if wav_data.ndim > 1:                        
+            wav_data = np.mean(wav_data, axis=1)
+        sample_rate, wav_data = ensure_sample_rate(sample_rate, wav_data)
+
+        waveform = wav_data / tf.int16.max
+
+        scores, embeddings, spectrogram = model(waveform)      
+
+        scores_np = scores.numpy()
+        mean_scores = np.mean(scores, axis=0)
+
+        inferred_class = class_names[mean_scores.argmax()]    
+        
+        confidence_threshold = 0.60                 
+        confident_classes = set()
+
+        exclusion_list = ['Mechanisms','Domestic animals, pets', 'Animal', 'Silence', 'Alarm', 'Wind chime', 'Water', 'Livestock, farm animals, working animals', 'Wild animals', 'Bleat', 'Siren', 'Computer keyboard', 'Toot', 'Shatter', 'Bird','Caw', 'Independent music', 'Tender music', 'Ocean', 'House music', 'Middle Eastern music', 'Swing music', 'Soul music', 'Shofar', 'Motor vehicle (road)', 'White noise','Pink noise', 'Cacophony', 'Sidetone', 'Static', 'Outside, rural or natural', 'Outside, urban or manmade', 'Inside, public space', 'Inside, large room or hall', 'Inside, small room', 'Sound effect']
+        for frame_scores in scores_np:
+            for i, score in enumerate(frame_scores):
+                if score > confidence_threshold:
+                    class_name = class_names[i]
+
+                    if class_name =='Child speech, kid speaking':
+                        class_name='Child speech'
+                    elif class_name =='Vehicle horn, car horn, honking':
+                        class_name='Vehicle horn'
+                    elif class_name =='Railroad car, train wagon':
+                        class_name='Train/wagon'
+                    elif class_name=='Rail transport':
+                        class_name='Train/wagon'
+
+                    if class_name not in exclusion_list:
+                        confident_classes.add(class_name)
+
+        confident_classes = sorted(confident_classes)        
+        
+        answer_dict = {'file_name': url, 'class_names': confident_classes}
+        return answer_dict
     
-    if wav_data.ndim > 1:                        
-        wav_data = np.mean(wav_data, axis=1)
-    sample_rate, wav_data = ensure_sample_rate(sample_rate, wav_data)
-
-    waveform = wav_data / tf.int16.max
-
-    scores, embeddings, spectrogram = model(waveform)      
-
-    scores_np = scores.numpy()
-    mean_scores = np.mean(scores, axis=0)
-
-    inferred_class = class_names[mean_scores.argmax()]    
-    
-    confidence_threshold = 0.60                 
-    confident_classes = set()
-
-    exclusion_list = ['Mechanisms','Domestic animals, pets', 'Animal', 'Silence', 'Alarm', 'Wind chime', 'Water', 'Livestock, farm animals, working animals', 'Wild animals', 'Bleat', 'Siren', 'Computer keyboard', 'Toot', 'Shatter', 'Bird','Caw', 'Independent music', 'Tender music', 'Ocean', 'House music', 'Middle Eastern music', 'Swing music', 'Soul music', 'Shofar', 'Motor vehicle (road)', 'White noise','Pink noise', 'Cacophony', 'Sidetone', 'Static', 'Outside, rural or natural', 'Outside, urban or manmade', 'Inside, public space', 'Inside, large room or hall', 'Inside, small room', 'Sound effect']
-    for frame_scores in scores_np:
-        for i, score in enumerate(frame_scores):
-            if score > confidence_threshold:
-                class_name = class_names[i]
-
-                if class_name =='Child speech, kid speaking':
-                    class_name='Child speech'
-                elif class_name =='Vehicle horn, car horn, honking':
-                    class_name='Vehicle horn'
-                elif class_name =='Railroad car, train wagon':
-                    class_name='Train/wagon'
-                elif class_name=='Rail transport':
-                    class_name='Train/wagon'
-
-                if class_name not in exclusion_list:
-                    confident_classes.add(class_name)
-
-    confident_classes = sorted(confident_classes)        
-    
-    answer_dict= {}  
-    answer_dict.update({'file_name': url, 'class_names': confident_classes})  #os.path.basename(file_path
-    solutions.append(answer_dict)
+    except Exception as e:
+        logging.error(f"Error processing {url}: {e}")
+        return None
 
 def get_audio_data(url):
     response = requests.get(url)
@@ -250,30 +239,24 @@ def process_audio(params):
 
     solutions = []
     for audio_url in audio_files:
-        try:
-            audio_data = get_audio_data(audio_url)
+        audio_data = get_audio_data(audio_url)
 
-            if audio_url.endswith(".mp3"):            
-                wav_buffer = convert_mp3_to_wav(audio_data)
-                process_audio_file(wav_buffer.getvalue(), audio_url)
+        if audio_url.endswith(".mp3"):            
+            wav_data = convert_mp3_to_wav(audio_data)
+            result = process_audio_file(wav_data, audio_url)
 
-            elif audio_url.endswith(".wav"):           
-                process_audio_file(audio_data, audio_url)
-        except Exception as e:
-            logging.error(f"Error processing {audio_url}: {e}")
+        elif audio_url.endswith(".wav"):           
+            result = process_audio_file(audio_data, audio_url)
+        
+        if result:
+            solutions.append(result)
 
     result_url = f"{api}/{job_id}"
     response = requests.patch(result_url, json={"solutions": solutions})
 
-    return json.dumps({"solutions": solutions}, indent=4)
+    return {"solutions": solutions}
 
-def send_results_to_api(data, result_url):
-    headers = {"Content-Type": "application/json"}
-    response = requests.patch(result_url, json=data, headers=headers)
-    if response.status_code == 200:
-        return response.json()  # Return any response from the API if needed
-    else:
-        return {"error": f"Failed to send results to API: {response.status_code}"}
+import gradio as gr
 
 inputt = gr.Textbox(label="Parameters (JSON format) Eg. {'audio_files':['file1.mp3','file2.wav'], 'api':'https://api.example.com', 'job_id':'12345'}")
 outputs = gr.JSON()
@@ -288,6 +271,160 @@ application.launch()
 
 
 
+# import os
+# import tensorflow as tf
+# import tensorflow_hub as hub
+# import numpy as np
+# import csv
+# import requests
+# import json
+# import scipy
+# from scipy.io import wavfile
+# from pydub import AudioSegment
+# import gradio as gr
+# import io
+# from io import BytesIO
+# import soundfile as sf
+# import warnings
+# import logging
+
+# # Suppress specific warnings
+# warnings.filterwarnings("ignore", category=scipy.io.wavfile.WavFileWarning)
+
+# # Configure logging
+# logging.basicConfig(level=logging.INFO)  # Set logging level as needed
+
+# # Load the model
+# model = hub.load('https://tfhub.dev/google/yamnet/1')
+
+# def class_names_from_csv(class_map_csv_text):
+#     """Returns list of class names corresponding to score vector."""
+#     class_names = []
+#     with tf.io.gfile.GFile(class_map_csv_text) as csvfile:
+#         reader = csv.DictReader(csvfile)
+#         for row in reader:
+#             class_names.append(row['display_name'])
+#     return class_names
+
+# class_map_path = model.class_map_path().numpy()
+# class_names = class_names_from_csv(class_map_path)
+
+# def ensure_sample_rate(original_sample_rate, waveform, desired_sample_rate=16000):
+#     if original_sample_rate != desired_sample_rate:  # Resample waveform if required
+#         desired_length = int(round(float(len(waveform)) / original_sample_rate * desired_sample_rate))
+#         waveform = scipy.signal.resample(waveform, desired_length)
+#     return desired_sample_rate, waveform
+
+# def convert_mp3_to_wav(mp3_data):
+#     audio = AudioSegment.from_file(io.BytesIO(mp3_data), format="mp3")
+#     wav_buffer = io.BytesIO()
+#     audio.export(wav_buffer, format='wav')
+#     wav_buffer.seek(0)
+#     return wav_buffer
+
+# def process_audio_file(file_data, url):
+#     try:
+#         sample_rate, wav_data = wavfile.read(BytesIO(file_data))      
+#     except Exception as e:
+#         logging.error(f"Error reading WAV file from {url}: {e}")
+#         return
+    
+#     if wav_data.ndim > 1:                        
+#         wav_data = np.mean(wav_data, axis=1)
+#     sample_rate, wav_data = ensure_sample_rate(sample_rate, wav_data)
+
+#     waveform = wav_data / tf.int16.max
+
+#     scores, embeddings, spectrogram = model(waveform)      
+
+#     scores_np = scores.numpy()
+#     mean_scores = np.mean(scores, axis=0)
+
+#     inferred_class = class_names[mean_scores.argmax()]    
+    
+#     confidence_threshold = 0.60                 
+#     confident_classes = set()
+
+#     exclusion_list = ['Mechanisms','Domestic animals, pets', 'Animal', 'Silence', 'Alarm', 'Wind chime', 'Water', 'Livestock, farm animals, working animals', 'Wild animals', 'Bleat', 'Siren', 'Computer keyboard', 'Toot', 'Shatter', 'Bird','Caw', 'Independent music', 'Tender music', 'Ocean', 'House music', 'Middle Eastern music', 'Swing music', 'Soul music', 'Shofar', 'Motor vehicle (road)', 'White noise','Pink noise', 'Cacophony', 'Sidetone', 'Static', 'Outside, rural or natural', 'Outside, urban or manmade', 'Inside, public space', 'Inside, large room or hall', 'Inside, small room', 'Sound effect']
+#     for frame_scores in scores_np:
+#         for i, score in enumerate(frame_scores):
+#             if score > confidence_threshold:
+#                 class_name = class_names[i]
+
+#                 if class_name =='Child speech, kid speaking':
+#                     class_name='Child speech'
+#                 elif class_name =='Vehicle horn, car horn, honking':
+#                     class_name='Vehicle horn'
+#                 elif class_name =='Railroad car, train wagon':
+#                     class_name='Train/wagon'
+#                 elif class_name=='Rail transport':
+#                     class_name='Train/wagon'
+
+#                 if class_name not in exclusion_list:
+#                     confident_classes.add(class_name)
+
+#     confident_classes = sorted(confident_classes)        
+    
+#     answer_dict= {}  
+#     answer_dict.update({'file_name': url, 'class_names': confident_classes})  #os.path.basename(file_path
+#     solutions.append(answer_dict)
+#     return solutions
+
+# def get_audio_data(url):
+#     response = requests.get(url)
+#     response.raise_for_status()
+#     return response.content
+
+# def process_audio(params):
+#     try:
+#         params = json.loads(params)
+#     except json.JSONDecodeError as e:
+#         return {"error": f"Invalid JSON input: {e.msg} at line {e.lineno} column {e.colno}"}
+
+#     audio_files = params.get("audio_files", [])
+#     api = params.get("api", "")
+#     job_id = params.get("job_id", "")
+
+#     solutions = []
+#     for audio_url in audio_files:
+#         try:
+#             audio_data = get_audio_data(audio_url)
+
+#             if audio_url.endswith(".mp3"):            
+#                 wav_buffer = convert_mp3_to_wav(audio_data)
+#                 process_audio_file(wav_buffer.getvalue(), audio_url)
+
+#             elif audio_url.endswith(".wav"):           
+#                 process_audio_file(audio_data, audio_url)
+#         except Exception as e:
+#             logging.error(f"Error processing {audio_url}: {e}")
+
+#     result_url = f"{api}/{job_id}"
+#     response = requests.patch(result_url, json={"solutions": solutions})
+
+#     return json.dumps({"solutions": solutions}, indent=4)
+
+# def send_results_to_api(data, result_url):
+#     headers = {"Content-Type": "application/json"}
+#     response = requests.patch(result_url, json=data, headers=headers)
+#     if response.status_code == 200:
+#         return response.json()  # Return any response from the API if needed
+#     else:
+#         return {"error": f"Failed to send results to API: {response.status_code}"}
+
+# inputt = gr.Textbox(label="Parameters (JSON format) Eg. {'audio_files':['file1.mp3','file2.wav'], 'api':'https://api.example.com', 'job_id':'12345'}")
+# outputs = gr.JSON()
+
+# application = gr.Interface(fn=process_audio, inputs=inputt, outputs=outputs, title="Audio Classification with API Integration")
+# application.launch()
+
+
+
+
+
+
+
+
 # import os
 # import tensorflow as tf
 # import tensorflow_hub as hub