Upload app.py

app.py

@@ -8,6 +8,7 @@ import librosa
 import numpy as np
 import soundfile as sf
 import whisper
+import pandas as pd
 
 # --- 0. CONFIGURACIÓN INICIAL ---
 try:
@@ -16,136 +17,168 @@ try:
 except TypeError:
     api_key_found = False
 
-print("Cargando modelo de Whisper...")
-whisper_model = whisper.load_model("base", device="cpu") # Especificar CPU puede ayudar en algunos sistemas
-print("Modelo de Whisper cargado.")
+print("Loading Whisper model...")
+whisper_model = whisper.load_model("base", device="cpu")
+print("Whisper model loaded.")
 
-
-# --- CAMBIO CLAVE: El nuevo súper-prompt ---
+# --- PROMPT DEL EXAMINADOR EXPERTO ---
 SYSTEM_PROMPT = """
-Eres "Echo", un tutor de inglés y experto en fonética con la personalidad amigable y paciente de un coach de idiomas. Tu objetivo es doble: mantener una conversación natural y proporcionar un análisis técnico impecable de la pronunciación del usuario.
-
-**Tu proceso de análisis es un riguroso examen en 4 pasos:**
-
-**Paso 1: Transcripción Fonética (IPA)**
-Para cada palabra de la **frase de referencia**, obtén su transcripción fonética estándar en IPA (Alfabeto Fonético Internacional) bajo el modelo de Inglés Americano General.
+You are an expert English language examiner specializing in phonetics and accent reduction for ESL learners. Your task is to provide a detailed, diagnostic assessment of a student's spoken English based on a reference sentence and detailed word-level audio analysis.
 
-**Paso 2: Descomposición en Fonemas**
-Descompón la transcripción IPA de cada palabra en sus fonemas constituyentes.
+**Input You Will Receive:**
+You will be given a JSON object containing:
+1.  `reference_transcript`: The correct sentence the student was supposed to say.
+2.  `spoken_words`: A list of words detected by Whisper, each with:
+    - `word`: The word as transcribed by Whisper.
+    - `start`: The start time of the word in seconds.
+    - `end`: The end time of the word in seconds.
+    - `energy`: A numeric value (RMS) indicating the pronunciation's energy/loudness.
 
-**Paso 3: Diagnóstico de Errores por Inferencia**
-Compara la **transcripción de Whisper** con la **frase de referencia**. Si Whisper transcribió una palabra de forma diferente (ej. "tink" en lugar de "think"), infiere qué fonema fue probablemente el incorrecto. Por ejemplo, un error en "think" a menudo implica que el fonema /θ/ se pronunció como /t/. Asigna un estado a cada fonema: 'Correcto' o 'A Mejorar'.
+**Your Analysis and Output:**
+Your entire response MUST be in English. You must return a single, valid JSON object with the following structure. Do not include any text outside of this JSON object.
 
-**Paso 4: Generar la Respuesta Conversacional**
-Después del análisis técnico, crea una respuesta corta, amigable y humana que se relacione con el tema de la frase. Finaliza con una pregunta abierta para invitar al usuario a seguir hablando. (ej. "¡Excelente! Veo que hablamos de colores. ¿Cuál es tu color favorito y por qué?").
-
-**Formato de Salida Obligatorio:**
-Tu respuesta DEBE ser un objeto JSON válido, sin texto, explicaciones o comentarios adicionales fuera del JSON. La estructura debe ser la siguiente:
+**JSON Output Structure:**
 {
-  "analisis_fonetico": [
+  "overall_score_100": integer,
+  "cefr_level": "string (A1, A2, B1, B2, C1, or C2)",
+  "holistic_feedback": {
+    "strengths": "string (A paragraph in English summarizing the student's strong points in pronunciation, rhythm, and clarity.)",
+    "areas_for_improvement": "string (A paragraph in English detailing the main patterns of error and what to focus on.)"
+  },
+  "word_by_word_analysis": [
     {
-      "palabra": "string",
-      "ipa_correcta": "string (ej. /ˈreɪn.boʊ/)",
-      "fonemas": [
-        {
-          "fonema": "string (ej. /r/)",
-          "estado": "string (Debe ser 'Correcto' o 'A Mejorar')",
-          "feedback": "string (Solo si el estado es 'A Mejorar', da un consejo técnico conciso, ej. 'La punta de la lengua debe vibrar cerca del paladar sin tocarlo.')"
-        }
-      ]
+      "reference_word": "string (The word from the correct sentence)",
+      "spoken_word": "string (The word Whisper transcribed, or 'OMITTED')",
+      "word_score_100": integer,
+      "correct_ipa": "string (The correct IPA transcription)",
+      "feedback": "string (Specific phonetic feedback for this word. If correct, simply state 'Excellent pronunciation.')"
     }
-  ],
-  "calificacion_general_100": integer,
-  "respuesta_conversacional": "string (Tu respuesta corta, amigable y con una pregunta abierta.)"
+  ]
 }
 """
 
-# --- La función de extracción de métricas se mantiene igual ---
-def extract_audio_metrics(audio_path):
+# --- 1. EXTRACCIÓN DETALLADA DE CARACTERÍSTICAS (WHISPER + LIBROSA) ---
+def extract_word_level_features(audio_path):
+    """
+    This function uses Whisper to get word timestamps and Librosa to get
+    features for each word's audio segment.
+    """
     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)
-        return {"text": result.get("text", "")}
-    except Exception as e:
-        print(f"Error en extracción de métricas: {e}")
-        return {}
+        if not result["segments"] or not result["segments"][0]["words"]:
+            return []
 
+        word_segments = result["segments"][0]["words"]
+        
+        features_list = []
+        for segment in word_segments:
+            start_sample = int(segment['start'] * sr)
+            end_sample = int(segment['end'] * sr)
+            word_audio = y[start_sample:end_sample]
+            
+            # Calculate Root Mean Square (RMS) energy for the word
+            rms_energy = np.mean(librosa.feature.rms(y=word_audio))
+            
+            features_list.append({
+                "word": segment['word'].strip(),
+                "start": round(segment['start'], 2),
+                "end": round(segment['end'], 2),
+                "energy": round(rms_energy, 4)
+            })
+        return features_list
+    except Exception as e:
+        print(f"Error during feature extraction: {e}")
+        return []
 
-# --- CAMBIO CLAVE: La función principal ahora procesa el nuevo JSON ---
-def evaluate_pronunciation(audio_input, reference_transcript):
-    if not api_key_found: raise gr.Error("Clave de API de OpenAI no encontrada.")
+# --- 2. FUNCIÓN PRINCIPAL DE EVALUACIÓN ---
+def run_evaluation(audio_input, reference_transcript):
+    if not api_key_found: raise gr.Error("OpenAI API key not found.")
     if audio_input is None or not reference_transcript:
-        return "Por favor, proporciona un audio y una transcripción.", 0, None
+        return 0, "N/A", "Please provide both an audio file and the reference text.", None
 
     sr, y = audio_input
     temp_audio_path = "temp_audio.wav"
     sf.write(temp_audio_path, y, sr)
 
-    audio_metrics = extract_audio_metrics(temp_audio_path)
-    if not audio_metrics: return "Error al procesar el audio.", 0, None
-
-    user_prompt = f"""
-    **Frase de referencia:** "{reference_transcript}"
-    **Transcripción de Whisper:** "{audio_metrics.get('text', '(Silencio detectado)')}"
-    """
+    # Step 1: Extract detailed features using Whisper and Librosa
+    word_features = extract_word_level_features(temp_audio_path)
+    if not word_features:
+        return 0, "N/A", "Could not process the audio. Please try recording again.", None
 
-    print("Enviando a GPT-4o para análisis fonético y conversacional...")
+    # Step 2: Construct the detailed prompt for the OpenAI API
+    prompt_data = {
+        "reference_transcript": reference_transcript,
+        "spoken_words": word_features
+    }
+    
+    print("Sending detailed data to GPT-4o for analysis...")
     response = client.chat.completions.create(
         model="gpt-4o",
         response_format={"type": "json_object"},
         messages=[
             {"role": "system", "content": SYSTEM_PROMPT},
-            {"role": "user", "content": user_prompt}
+            {"role": "user", "content": json.dumps(prompt_data)}
         ]
     )
 
+    # Step 3: Process the API response and format it for display
     try:
         result = json.loads(response.choices[0].message.content)
         
-        # Extraer los datos del nuevo formato JSON
-        conversational_reply = result.get("respuesta_conversacional", "¡Buen intento! Inténtalo de nuevo.")
-        overall_score = result.get("calificacion_general_100", 0)
-        phonetic_analysis = result.get("analisis_fonetico", {})
-
-        return conversational_reply, overall_score, phonetic_analysis
+        # Format the detailed report for Gradio
+        holistic_feedback_md = f"### Strengths\n{result['holistic_feedback']['strengths']}\n\n"
+        holistic_feedback_md += f"### Areas for Improvement\n{result['holistic_feedback']['areas_for_improvement']}"
+        
+        # Create a pandas DataFrame for better display
+        word_analysis_df = pd.DataFrame(result['word_by_word_analysis'])
+        
+        return (
+            result.get("overall_score_100", 0),
+            result.get("cefr_level", "N/A"),
+            holistic_feedback_md,
+            gr.DataFrame(value=word_analysis_df, headers=["Reference Word", "Spoken Word", "Score", "Correct IPA", "Feedback"], interactive=False)
+        )
 
     except (json.JSONDecodeError, KeyError) as e:
-        print(f"Error procesando la respuesta de la API: {e}")
-        error_msg = "Lo siento, la respuesta de la API no tuvo el formato esperado. Por favor, intenta de nuevo."
-        return error_msg, 0, {"error": str(e)}
+        print(f"Error processing API response: {e}")
+        error_msg = "The API response was not in the expected format. Please try again."
+        return 0, "Error", error_msg, None
 
 
-# --- CAMBIO CLAVE: Nueva interfaz de Gradio más limpia ---
+# --- 3. INTERFAZ DE GRADIO ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🎤 Echo: Tu Tutor de Pronunciación (v5)")
-    gr.Markdown("Graba tu voz diciendo la frase de referencia. Recibirás una respuesta conversacional y un análisis técnico detallado de tu pronunciación.")
+    gr.Markdown("# 🇬🇧 Expert Pronunciation Assessment")
+    gr.Markdown("Record yourself saying the reference sentence. Our AI examiner will provide a detailed diagnostic report on your performance.")
 
     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 mi Pronunciación", variant="primary")
+            audio_in = gr.Audio(sources=["microphone"], type="numpy", label="1. Record Your Voice")
+            text_in = gr.Textbox(lines=3, label="2. Reference Sentence", value=frase_ejemplo)
+            submit_btn = gr.Button("Get Assessment", variant="primary")
         
         with gr.Column(scale=2):
-            gr.Markdown("### Respuesta de tu Tutor")
-            tutor_reply_out = gr.Textbox(label="Echo dice:", lines=4, interactive=False)
-            score_out = gr.Number(label="Calificación General (0-100)", interactive=False)
+            gr.Markdown("### Assessment Summary")
+            with gr.Row():
+                score_out = gr.Number(label="Overall Score (0-100)", interactive=False)
+                level_out = gr.Textbox(label="Estimated CEFR Level", interactive=False)
+            
+            holistic_feedback_out = gr.Markdown(label="Examiner's Feedback")
     
-    with gr.Accordion("Ver Análisis Fonético Detallado", open=False):
-        phonetic_analysis_out = gr.JSON(label="Desglose Técnico por Palabra y Fonema")
+    gr.Markdown("--- \n ### Detailed Word-by-Word Analysis")
+    word_analysis_out = gr.DataFrame(headers=["Reference Word", "Spoken Word", "Score", "Correct IPA", "Feedback"], label="Phonetic Breakdown")
 
     submit_btn.click(
-        fn=evaluate_pronunciation,
+        fn=run_evaluation,
         inputs=[audio_in, text_in],
-        outputs=[tutor_reply_out, score_out, phonetic_analysis_out]
+        outputs=[score_out, level_out, holistic_feedback_out, word_analysis_out]
     )
 
 if __name__ == "__main__":
     if not api_key_found:
-        print("\nFATAL: Clave de API de OpenAI no encontrada.")
+        print("\nFATAL: OpenAI API key not found. Please set the OPENAI_API_KEY environment variable.")
     else:
         demo.launch(debug=True)