Update app.py

app.py

@@ -15,17 +15,26 @@ from collections import Counter
 from scipy.stats import kurtosis
 from huggingface_hub import InferenceClient
 import os
+import time
 
+'''
+Predictor
+'''
+
+#Obtenemos el token para traernos el modelo:
 access_token_mod_1 = os.getenv('HF_Access_Personal')
 
-# Cargar el procesador y modelo
+#Cargamos procesador y modelo:
 processor = ASTFeatureExtractor.from_pretrained("MIT/ast-finetuned-audioset-10-10-0.4593")
 model = AutoModelForAudioClassification.from_pretrained("Robertomarting/tmp_trainer",token=access_token_mod_1)
 
+#Definimos una función para eliminar segmentos de audio con un determinado porcentaje de ruido blanco:
 def is_white_noise(audio, threshold=0.75):
     kurt = kurtosis(audio)
     return np.abs(kurt) < 0.1 and np.mean(np.abs(audio)) < threshold
 
+#Función de procesado de audio, permite particionar en fragmentos de 1 segundo, hacer un trim, volverlo mono si está en estéreo, resamplearlo
+#al sampling rate que admite el modelo, etc.
 def process_audio(audio_tuple, target_sr=16000, target_duration=1.0):
     data = []
     target_length = int(target_sr * target_duration)
@@ -57,6 +66,7 @@ def process_audio(audio_tuple, target_sr=16000, target_duration=1.0):
 
     return data
 
+#Se aplica al extractor de características del modelo:
 def preprocess_audio(audio_segments):
     inputs = processor(
         audio_segments,
@@ -64,32 +74,26 @@ def preprocess_audio(audio_segments):
         sampling_rate=processor.sampling_rate,
         max_length=int(processor.sampling_rate * 1),
         truncation=True,
-        return_tensors="pt"  # Directamente retorna tensores de PyTorch
+        return_tensors="pt"
     )
     return inputs
 
+#Se hace la predicción para cada audio:
 def predict_audio(audio):
-    # Procesar el audio y obtener las listas de numpy
-    audio_segments = process_audio(audio)
     
-    # Preprocesar el audio (aplica directamente al array numpy)
+    audio_segments = process_audio(audio)    
+    
     inputs = preprocess_audio(audio_segments)
 
-    # Realizar las predicciones
     with torch.no_grad():
         outputs = model(**inputs)
 
-    # Obtener los logits de las predicciones
     logits = outputs.logits
-
-    # Convertir logits a probabilidades
     probabilities = torch.nn.functional.softmax(logits, dim=-1).numpy()
     predicted_classes = probabilities.argmax(axis=1)
 
-    # Obtener la etiqueta más común
     most_common_predicted_label = Counter(predicted_classes).most_common(1)[0][0]
-    
-    # Mapear etiquetas numéricas a etiquetas de texto
+
     replace_dict = {0: 'Hambre', 1: 'Problemas para respirar', 2: 'Dolor', 3: 'Cansancio/Incomodidad'}
     most_common_predicted_label = replace_dict[most_common_predicted_label]
 
@@ -98,10 +102,93 @@ def predict_audio(audio):
 def clear_audio_input(audio):
     return ""
 
+'''
+Monitor
+''' 
+
+#Sacamos extractor de características:
+FEATURE_EXTRACTOR = Wav2Vec2FeatureExtractor.from_pretrained("ntu-spml/distilhubert")
+#Y nuestro modelo:
+model_monitor = HubertForSequenceClassification.from_pretrained("A-POR-LOS-8000/distilhubert-finetuned-cry-detector")
+
+#Calculamos decibelios de lo que llega al gradio:
+def compute_db(audio_data):
+    rms = np.sqrt(np.mean(np.square(audio_data)))
+    db = 20 * np.log10(rms + 1e-6)
+    return db
+
+#Función de extracción de características para el monitor:
+def preprocess_audio_monitor(audio_segments):
+    inputs = FEATURE_EXTRACTOR(
+        audio_segments,
+        padding=True,
+        sampling_rate=16000,
+        max_length=int(16000*1),
+        return_tensors="pt"
+    )
+    return inputs
+
+#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)
+
+    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]
+    
+    result, probabilidad = predict_audio_stream(audio_data, sample_rate)
+    return f"Predicción: {result}, Probabilidad: {probabilidad:.2f}", probabilidad
+
+#Función que se encarga de indicarle al usuario si se ha pasado el umbral:
+def update_status_to_predicting(audio, visual_threshold):
+    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:
+        return f"Esperando... Decibelios: {db_level}"
+    else:
+        return f"Prediciendo... Decibelios: {db_level}"
+
+'''
+Asistente
+'''
+
+#Traemos el token:
 access_token = os.getenv('HF_ACCESS_TOKEN')
 
+#Generamos el cliente:
 client = InferenceClient("mistralai/Mistral-Nemo-Instruct-2407", token=access_token)
 
+#Generamos una función de respuesta:
 def respond(
     message,
     history: list[tuple[str, str]],
@@ -133,6 +220,11 @@ def respond(
         response += token
         yield response
 
+'''
+Interfaz
+'''
+
+#Generamos un theme con parámetros personalizados:
 my_theme = gr.themes.Soft(
     primary_hue="emerald",
     secondary_hue="green",
@@ -150,54 +242,19 @@ my_theme = gr.themes.Soft(
     shadow_spread='*button_shadow_active'
 )
 
-# Función para mostrar la página 1
+#Función para mostrar la página del Predictor
 def mostrar_pagina_1():
     return gr.update(visible=False), gr.update(visible=True)
 
-# Función para mostrar la página 2
+#Función para mostrar la página del Monitor
 def mostrar_pagina_2():
     return gr.update(visible=False), gr.update(visible=True)
 
-# Función para regresar a la pantalla inicial
+#Función para regresar a la pantalla inicial
 def redirigir_a_pantalla_inicial():
     return gr.update(visible=True), gr.update(visible=False)
 
-### Monitor
-
-#processor = Wav2Vec2FeatureExtractor.from_pretrained("ntu-spml/distilhubert")
-
-#monitor_model = HubertForSequenceClassification.from_pretrained("A-POR-LOS-8000/distilhubert-finetuned-cry-detector",use_auth_token=access_token_mod_1)
-
-pipeline_monitor = pipeline(model="Robertomarting/tmp_trainer",token=access_token_mod_1,feature_extractor=processor)
-
-def predict_monitor(stream, new_chunk):
-    sr, y = new_chunk
-    y = y.astype(np.float32)
-    y /= np.max(np.abs(y))
-
-    if stream is not None:
-        stream = np.concatenate([stream, y])
-    else:
-        stream = y
-    return stream, pipeline_monitor(stream) 
-    
-my_theme = gr.themes.Soft(
-    primary_hue="emerald",
-    secondary_hue="green",
-    neutral_hue="slate",
-    text_size="sm",
-    spacing_size="sm",
-    font=[gr.themes.GoogleFont('Nunito'), 'ui-sans-serif', 'system-ui', 'sans-serif'],
-    font_mono=[gr.themes.GoogleFont('Nunito'), 'ui-monospace', 'Consolas', 'monospace'],
-).set(
-    body_background_fill='*neutral_50',
-    body_text_color='*neutral_600',
-    body_text_size='*text_sm',
-    embed_radius='*radius_md',
-    shadow_drop='*shadow_spread',
-    shadow_spread='*button_shadow_active'
-)
-
+#Generamos el gradio:
 with gr.Blocks(theme = my_theme) as demo:
 
     with gr.Column() as pantalla_inicial:
@@ -261,7 +318,7 @@ with gr.Blocks(theme = my_theme) as demo:
 
             with gr.Column():
                 gr.Markdown("<h2>Assistant</h2>")
-                system_message = "You are a Chatbot specialized in baby health and care."
+                system_message = "Eres un chatbot especializado en el cuidado y la salud de los bebés. Estás dispuesto a ayudar amablemente a cualquier padre que tenga dudas o preocupaciones sobre su hijo o hija."
                 max_tokens = 512
                 temperature = 0.7
                 top_p = 0.95
@@ -282,23 +339,30 @@ with gr.Blocks(theme = my_theme) as demo:
         boton_volver_inicio_1.click(redirigir_a_pantalla_inicial, inputs=None, outputs=[pantalla_inicial, pagina_1])
 
     with gr.Column(visible=False) as pagina_2:
+        
         gr.Markdown("<h2>Monitor</h2>")
-        gr.Markdown("# Detección en tiempo real del llanto del bebé con Pipeline")
+        gr.Markdown("<h4 style='text-align: center; font-size: 1.5em'>Detección en tiempo real del llanto del bebé</h4>")
 
-        # Componente de audio en streaming
-        audio_input = gr.Audio(sources=["microphone"], streaming=True, label="Habla cerca del micrófono")
-        
-        # Salida del texto donde se muestra la predicción
-        output_text = gr.Textbox(label="Resultado de la predicción")
-        
-        # Vincular la predicción en streaming con el audio
-        audio_input.stream(fn=lambda audio: predict_monitor(audio, audio_classifier),
-                           inputs=audio_input,
-                           outputs=output_text)
+        audio_stream = gr.Audio(sources=["microphone"], streaming=True)
 
-        boton_volver_inicio_2 = gr.Button("Volver a la pantalla inicial")
-        boton_volver_inicio_2.click(redirigir_a_pantalla_inicial, inputs=None, outputs=[pantalla_inicial, pagina_2])
+        threshold_db = gr.Slider(minimum=0, maximum=200, step=1, value=20, label="Umbral de dB para activar la predicción")
 
+        status_label = gr.Textbox(value="Esperando...", label="Estado")
+        prediction_label = gr.Textbox(label="Predicción")
+    
+        audio_stream.stream(
+        fn=update_status_to_predicting,
+        inputs=[audio_stream, threshold_db],
+        outputs=status_label
+        )
+    
+        # Captura el audio y realiza la predicción si se supera el umbral
+        audio_stream.stream(
+            fn=capture_and_predict,
+            inputs=audio_stream,
+            outputs=prediction_label
+        )
+        
     boton_pagina_1.click(mostrar_pagina_1, inputs=None, outputs=[pantalla_inicial, pagina_1])
     boton_pagina_2.click(mostrar_pagina_2, inputs=None, outputs=[pantalla_inicial, pagina_2])