Update app.py

app.py

@@ -106,6 +106,36 @@ def clear_audio_input(audio):
 Monitor
 ''' 
 
+def process_audio_monitor(audio_tuple, target_sr=16000, target_duration=1.0):
+    data = []
+    target_length = int(target_sr * target_duration)
+
+    wav_buffer = io.BytesIO()
+    sf.write(wav_buffer, audio_tuple[1], audio_tuple[0], format='wav')
+    
+    wav_buffer.seek(0)
+    audio_data, sample_rate = sf.read(wav_buffer)
+
+    audio_data = audio_data.astype(np.float32)
+    
+    if len(audio_data.shape) > 1:
+        audio_data = np.mean(audio_data, axis=1) 
+
+    if sample_rate != target_sr:
+        audio_data = librosa.resample(audio_data, orig_sr=sample_rate, target_sr=target_sr)
+
+    audio_data, _ = librosa.effects.trim(audio_data)
+
+    if len(audio_data) > target_length:
+        for i in range(0, len(audio_data), target_length):
+            segment = audio_data[i:i + target_length]
+            if len(segment) == target_length:
+                data.append(segment)
+    else:
+        data.append(audio_data)
+
+    return data
+
 #Sacamos extractor de características:
 FEATURE_EXTRACTOR = Wav2Vec2FeatureExtractor.from_pretrained("ntu-spml/distilhubert")
 #Y nuestro modelo:
@@ -130,41 +160,33 @@ def preprocess_audio_monitor(audio_segments):
 
 #Función de predicción en streaming:
 def predict_audio_stream(audio_data, sample_rate):
-    
-    audio_segments = process_audio(audio_data)
-    inputs = preprocess_audio_monitor(audio_segments)
+    audio_segments = process_audio_monitor(audio_data)
 
+    inputs = preprocess_audio_monitor(audio_segments)
+    
     with torch.no_grad():
         outputs = model_monitor(**inputs)
-
+    
     logits = outputs.logits
     probabilities = torch.nn.functional.softmax(logits, dim=-1).numpy()
     crying_probabilities = probabilities[:, 1]
     avg_crying_probability = crying_probabilities.mean()
-
-    if avg_crying_probability < 0.15:
-        return "Está llorando", avg_crying_probability 
-    else:
-        return "No está llorando", avg_crying_probability 
-        
-#Función que realiza la predicción
-def continuous_prediction_with_status(audio, sample_rate=16000,duration=3):
-    audio_segments = []
-    start_time = time.time()
-
-    max_samples = sample_rate * duration
-    audio_data = audio[:max_samples]
     
-    result = predict_audio_stream(audio_data, sample_rate)
-    
-    return result
-
-def capture_and_predict(audio, sample_rate=16000, duration=5):
-    max_samples = sample_rate * duration
-    audio_data = audio[:max_samples]
+    if avg_crying_probability < 0.25:
+        
+        inputs = preprocess_audio(audio_segments)
+        with torch.no_grad():
+            outputs = model(**inputs)
+        logits = outputs.logits
+        probabilities = torch.nn.functional.softmax(logits, dim=-1).numpy()
+        predicted_classes = probabilities.argmax(axis=1)
+        most_common_predicted_label = Counter(predicted_classes).most_common(1)[0][0]
+        replace_dict = {0: 'Hambre', 1: 'Problemas para respirar', 2: 'Dolor', 3: 'Cansancio/Incomodidad'}
+        most_common_predicted_label = replace_dict[most_common_predicted_label]
     
-    result, probabilidad = predict_audio_stream(audio_data, sample_rate)
-    return f"Predicción: {result}, Probabilidad: {probabilidad:.2f}", probabilidad
+        return "Está llorando", 1-avg_crying_probability, most_common_predicted_label
+    else:
+        return "No está llorando", 1-avg_crying_probability, ""
 
 #Función que se encarga de indicarle al usuario si se ha pasado el umbral:
 def update_status_to_predicting(audio, visual_threshold):
@@ -177,7 +199,29 @@ def update_status_to_predicting(audio, visual_threshold):
         return f"Esperando... Decibelios: {db_level}"
     else:
         return f"Prediciendo... Decibelios: {db_level}"
+        time.sleep(5)
 
+#Función que realiza la predicción
+def capture_and_predict(audio,visual_threshold, sample_rate=16000, duration=5):
+    
+    sample_rate, audio_data = audio
+    audio_data = np.array(audio_data, dtype=np.float32)
+    db_level = compute_db(audio_data)
+    
+    if db_level > visual_threshold:
+        max_samples = sample_rate * duration
+        audio_data = audio[:max_samples]
+        if len(audio_data) != 0:
+            result, probabilidad, result_2 = predict_audio_stream(audio_data, sample_rate)
+            if result == "Está llorando":
+                return f"{result}, por {result_2}"
+                time.sleep(10)
+            else:
+                return "No está llorando"
+                time.sleep(5)
+    else:
+        time.sleep(1)
+        
 '''
 Asistente
 '''
@@ -345,7 +389,7 @@ with gr.Blocks(theme = my_theme) as demo:
 
         audio_stream = gr.Audio(sources=["microphone"], streaming=True)
 
-        threshold_db = gr.Slider(minimum=0, maximum=200, step=1, value=20, label="Umbral de dB para activar la predicción")
+        threshold_db = gr.Slider(minimum=0, maximum=200, step=1, value=50, label="Umbral de dB para activar la predicción")
 
         status_label = gr.Textbox(value="Esperando...", label="Estado")
         prediction_label = gr.Textbox(label="Predicción")
@@ -359,7 +403,7 @@ with gr.Blocks(theme = my_theme) as demo:
         # Captura el audio y realiza la predicción si se supera el umbral
         audio_stream.stream(
             fn=capture_and_predict,
-            inputs=audio_stream,
+            inputs=[audio_stream,threshold_db],
             outputs=prediction_label
         )