Upload 2 files

app.py

@@ -4,65 +4,115 @@ import gradio as gr
 import os
 from openai import OpenAI
 import json
+import librosa
+import numpy as np
 import soundfile as sf
+import whisper
 
-# --- 1. Configurar el Cliente de OpenAI ---
+# --- 0. CONFIGURACIÓN INICIAL ---
 try:
     client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
     api_key_found = True
 except TypeError:
     api_key_found = False
 
-# --- 2. El NUEVO Prompt: Más Técnico y Preciso ---
+print("Cargando modelo de Whisper...")
+whisper_model = whisper.load_model("base")
+print("Modelo de Whisper cargado.")
+
+# --- NUEVO SÚPER-PROMPT ---
 SYSTEM_PROMPT = """
-Eres un lingüista computacional y experto en fonética inglesa, especializado en la evaluación de acentos para hablantes de inglés como segundo idioma (ESL).
-Tu tarea es realizar un análisis fonético detallado de un audio, comparando la pronunciación del hablante con un modelo de Inglés Americano General (General American English).
+Eres un examinador de inglés de Cambridge con un doctorado en fonética. Tu tarea es realizar una evaluación integral de la pronunciación y fluidez de un hablante no nativo.
+
+**Recibirás:**
+1.  La **frase de referencia** que el usuario intentaba decir.
+2.  La **transcripción literal** de su audio, generada por Whisper.
+3.  **Métricas de fluidez**: WPM (palabras por minuto) y número de pausas.
 
-Debes basar tu análisis en estos tres pilares:
-1.  **Precisión Fonética (Phonetic Accuracy):** Compara la transcripción de Whisper con la transcripción de referencia. Para cada palabra, analiza si los fonemas clave fueron producidos correctamente.
-2.  **Prosodia (Prosody):** Evalúa el ritmo, la entonación y el acento de la frase. ¿La entonación sube y baja de forma natural? ¿Se acentúan las palabras correctas?
-3.  **Vinculación (Linking/Liaison):** Observa si el hablante conecta las palabras de manera fluida (ej. "is a" suena como /ɪzə/).
+**Tu proceso de análisis debe ser el siguiente:**
 
-Tu respuesta DEBE ser un objeto JSON válido, sin texto adicional antes o después. La estructura es la siguiente:
+1.  **Análisis Palabra por Palabra**: Compara la "frase de referencia" con la "transcripción de Whisper". Para cada palabra en la frase de referencia, determina si fue:
+    * **Correcta (100%)**: Pronunciada de forma clara e inteligible.
+    * **Incorrecta (0-50%)**: Pronunciada de forma que cambia el significado o es difícil de entender.
+    * **Omitida (0%)**: No se dijo.
+2.  **Calcular Accuracy Total**: Calcula el promedio de la puntuación de todas las palabras para obtener una calificación global de 0 a 100.
+3.  **Evaluar Fluidez**: Usa las métricas de WPM y pausas para escribir un breve análisis sobre el ritmo y la cadencia del hablante. (Ej. WPM < 100 es lento, WPM > 140 es fluido).
+4.  **Asignar Nivel MCERL**: Basándote en el accuracy, la fluidez y la complejidad de los errores, asigna un nivel de Marco Común Europeo (A1, A2, B1, B2, C1).
+5.  **Generar Feedback Adaptativo**: Crea una respuesta en inglés para el usuario. La respuesta debe ser retadora pero comprensible según el nivel que le asignaste.
+
+**Tu respuesta DEBE ser únicamente un objeto JSON con esta estructura exacta:**
 {
-    "calificacion_general_100": integer,
-    "calificacion_precision_fonetica_100": integer,
-    "analisis_general": "string (Un resumen de dos o tres líneas sobre los puntos fuertes y las áreas de mejora principales del hablante.)",
-    "feedback_fonetico_por_palabra": [
-        {
-            "palabra": "string",
-            "ipa_correcta": "string (La transcripción fonética correcta en IPA, ej. /ˈreɪn.boʊ/)",
-            "error_detectado": "string (Describe el error fonético, ej. 'La vocal /eɪ/ se pronunció como /e/ de forma monoptonga.')",
-            "sugerencia": "string (Un consejo práctico para corregirlo, ej. 'Asegúrate de deslizar la lengua de la posición de 'e' a la de 'i' para crear el diptongo.')"
-        }
-    ]
+  "calificacion_general_100": integer,
+  "nivel_mcerl_estimado": "string (ej. B1)",
+  "analisis_por_palabra": [
+    {
+      "palabra": "string",
+      "accuracy": integer,
+      "feedback": "string (Feedback específico si hay un error, ej. 'La vocal 'a' sonó como 'e'.')"
+    }
+  ],
+  "feedback_general_html": "string (Un párrafo en HTML con tu análisis sobre fluidez, prosodia y consejos generales.)",
+  "respuesta_adaptada_al_usuario": "string (El feedback final para el usuario, escrito en un inglés apropiado para su nivel.)"
 }
 """
 
-# --- 3. La Función Principal (Actualizada para el nuevo JSON) ---
-def evaluate_pronunciation_openai(audio_input, user_transcript):
+
+# --- 1. FUNCIÓN DE EXTRACCIÓN DE CARACTERÍSTICAS (SIMPLIFICADA) ---
+def extract_audio_metrics(audio_path):
+    try:
+        y, sr = librosa.load(audio_path, sr=16000)
+        duration = librosa.get_duration(y=y, sr=sr)
+        if duration < 0.2: return {}
+
+        result = whisper_model.transcribe(audio_path, word_timestamps=True, fp16=False)
+        if not result["segments"] or not result["segments"][0]["words"]: return {"text": result.get("text", "")}
+        
+        words = result["segments"][0]["words"]
+        num_words = len(words)
+        wpm = (num_words / duration) * 60 if duration > 0 else 0
+        
+        pauses = 0
+        for i in range(len(words) - 1):
+            if words[i+1]['start'] - words[i]['end'] > 0.5:
+                pauses += 1
+
+        return {
+            "text": result.get("text", ""),
+            "wpm": round(wpm, 2),
+            "num_pauses": pauses
+        }
+    except Exception as e:
+        print(f"Error en extracción de métricas: {e}")
+        return {}
+
+
+# --- 2. FUNCIÓN PRINCIPAL DE EVALUACIÓN (TODO CON LA API) ---
+def evaluate_with_openai(audio_input, reference_transcript):
     if not api_key_found:
         raise gr.Error("Clave de API de OpenAI no encontrada.")
-    
-    if audio_input is None or not user_transcript:
-        # Devuelve valores por defecto para todos los outputs
-        return 0, 0, "Por favor, proporciona un audio y una transcripción.", "### Retroalimentación Detallada\nEsperando análisis..."
+    if audio_input is None or not reference_transcript:
+        return 0, "N/A", "Proporciona un audio y una transcripción.", "Esperando análisis...", "Esperando análisis..."
 
-    sr, waveform = audio_input
+    sr, y = audio_input
     temp_audio_path = "temp_audio.wav"
-    sf.write(temp_audio_path, waveform, sr)
+    sf.write(temp_audio_path, y, sr)
 
-    print("Transcribiendo audio...")
-    with open(temp_audio_path, "rb") as audio_file:
-        ai_transcript = client.audio.transcriptions.create(model="whisper-1", file=audio_file).text
-    
+    # 1. Extraer métricas básicas del audio
+    audio_metrics = extract_audio_metrics(temp_audio_path)
+    if not audio_metrics:
+        return 0, "Error", "No se pudo procesar el audio.", "Error", "Error"
+
+    # 2. Construir el prompt para la API
     user_prompt = f"""
-    Realiza el análisis fonético del audio proporcionado.
-    Frase de referencia (lo que el usuario intentaba decir): "{user_transcript}"
-    Transcripción generada por Whisper (lo que realmente se dijo): "{ai_transcript}"
+    **Frase de referencia:** "{reference_transcript}"
+    **Transcripción de Whisper:** "{audio_metrics.get('text', '')}"
+    **Métricas de fluidez:**
+    - WPM: {audio_metrics.get('wpm', 'N/A')}
+    - Pausas (>0.5s): {audio_metrics.get('num_pauses', 'N/A')}
     """
-    
-    print("Enviando a GPT-4o para evaluación fonética...")
+
+    # 3. Llamar a la API de OpenAI
+    print("Enviando a GPT-4o para evaluación completa...")
     response = client.chat.completions.create(
         model="gpt-4o",
         response_format={"type": "json_object"},
@@ -71,64 +121,63 @@ def evaluate_pronunciation_openai(audio_input, user_transcript):
             {"role": "user", "content": user_prompt}
         ]
     )
-    
+
+    # 4. Procesar y formatear la respuesta JSON
     try:
         result = json.loads(response.choices[0].message.content)
         
-        # Extraer datos del nuevo formato JSON
-        score_general = result.get("calificacion_general_100", 0)
-        score_phonetics = result.get("calificacion_precision_fonetica_100", 0)
-        analysis = result.get("analisis_general", "No se proporcionó análisis.")
-        feedback_list = result.get("feedback_fonetico_por_palabra", [])
-        
-        # Formatear el feedback detallado como Markdown para una mejor visualización
-        markdown_feedback = "### Retroalimentación Fonética Detallada\n---\n"
-        if not feedback_list:
-            markdown_feedback += "¡Excelente pronunciación! No se detectaron errores específicos."
-        else:
-            for item in feedback_list:
-                markdown_feedback += f"**Palabra:** `{item.get('palabra', 'N/A')}`\n"
-                markdown_feedback += f"- **IPA Correcta:** `{item.get('ipa_correcta', 'N/A')}`\n"
-                markdown_feedback += f"- **Error Detectado:** {item.get('error_detectado', 'N/A')}\n"
-                markdown_feedback += f"- **Sugerencia:** {item.get('sugerencia', 'N/A')}\n\n"
-        
-        return score_general, score_phonetics, analysis, markdown_feedback
+        # Formatear el análisis por palabra en Markdown
+        word_analysis_md = "### Análisis por Palabra\n| Palabra | Puntuación | Feedback |\n| :--- | :--- | :--- |\n"
+        for item in result.get("analisis_por_palabra", []):
+            word_analysis_md += f"| {item.get('palabra')} | {item.get('accuracy')}% | {item.get('feedback')} |\n"
+
+        return (
+            result.get("calificacion_general_100", 0),
+            result.get("nivel_mcerl_estimado", "N/A"),
+            gr.HTML(result.get("feedback_general_html", "")),
+            word_analysis_md,
+            result.get("respuesta_adaptada_al_usuario", "")
+        )
 
     except (json.JSONDecodeError, KeyError) as e:
-        print(f"Error al procesar la respuesta de la API: {e}")
-        error_message = "La respuesta de la API no tuvo el formato JSON esperado. Inténtalo de nuevo."
-        return 0, 0, error_message, f"### Error\n---\n{error_message}"
+        print(f"Error procesando la respuesta de la API: {e}")
+        error_msg = "La respuesta de la API no tuvo el formato esperado. Inténtalo de nuevo."
+        return 0, "Error", error_msg, error_msg, error_msg
 
 
-# --- 4. Definir y Lanzar la Interfaz de Gradio (Actualizada) ---
-description = """
-Usa la frase estándar para una evaluación completa o prueba con tus propias frases.
-Sube tu audio y la transcripción. La IA analizará tu pronunciación fonema por fonema.
-"""
+# --- 3. INTERFAZ DE GRADIO ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🤖 Evaluador de Pronunciación Impulsado por IA (v4)")
+    gr.Markdown("Graba tu voz diciendo la frase de referencia. La IA analizará cada palabra, tu fluidez, y te dará una calificación y feedback adaptado a tu nivel.")
 
-# IMPORTANTE: Graba un audio diciendo la frase de ejemplo y guárdalo
-# con este nombre en la misma carpeta que tu app.py
-audio_ejemplo_path = "mark_is_going_to_see_elephant.wav"
-frase_ejemplo_texto = "MARK IS GOING TO SEE ELEPHANT"
-
-demo = gr.Interface(
-    fn=evaluate_pronunciation_openai,
-    inputs=[
-        gr.Audio(type="numpy", label="Sube tu Audio (.wav o .mp3)"),
-        gr.Textbox(lines=3, label="Escribe la Transcripción de Referencia", value=frase_ejemplo_texto)
-    ],
-    outputs=[
-        gr.Number(label="Calificación General (0-100)"),
-        gr.Number(label="Precisión Fonética (0-100)"),
-        gr.Textbox(label="Análisis General"),
-        gr.Markdown(label="Feedback Detallado por Palabra") # CAMBIO: Markdown para mejor visualización
-    ],
-    title="🤖 Evaluador Fonético de Pronunciación (v2)",
-    description=description,
-    examples=[
-        [audio_ejemplo_path, frase_ejemplo_texto]
-    ]
-)
+    frase_ejemplo = "The rainbow is a division of white light into many beautiful colors."
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            audio_in = gr.Audio(sources=["microphone"], type="numpy", label="1. Graba tu voz aquí")
+            text_in = gr.Textbox(lines=3, label="2. Frase de Referencia", value=frase_ejemplo)
+            submit_btn = gr.Button("Evaluar Pronunciación", variant="primary")
+        
+        with gr.Column(scale=2):
+            gr.Markdown("### Resultados de la Evaluación")
+            with gr.Row():
+                score_out = gr.Number(label="Calificación General (0-100)", scale=1)
+                level_out = gr.Textbox(label="Nivel MCERL Estimado", scale=1)
+            
+            feedback_html_out = gr.HTML(label="Análisis General de Fluidez y Prosodia")
+            word_analysis_out = gr.Markdown(label="Detalle por Palabra")
+
+    gr.Markdown("--- \n ### Mensaje de tu Tutor de IA")
+    adaptive_response_out = gr.Textbox(label="Feedback Adaptado a tu Nivel", lines=5)
+
+    submit_btn.click(
+        fn=evaluate_with_openai,
+        inputs=[audio_in, text_in],
+        outputs=[score_out, level_out, feedback_html_out, word_analysis_out, adaptive_response_out]
+    )
 
 if __name__ == "__main__":
-    demo.launch()
+    if not api_key_found:
+        print("\nFATAL: Clave de API de OpenAI no encontrada.")
+    else:
+        demo.launch(debug=True)

requirements.txt

@@ -1,3 +1,7 @@
 gradio
 openai
-soundfile
+librosa
+numpy
+soundfile
+# Para Whisper con soporte de marcas de tiempo, se instala de forma especial:
+git+https://github.com/openai/whisper.git