Update app.py

app.py

@@ -7,426 +7,329 @@ import tensorflow_text as tf_text
 import tensorflow_hub as tf_hub
 import numpy as np
 from PIL import Image
-from huggingface_hub import snapshot_download, HfFolder
+from huggingface_hub import snapshot_download
 from sklearn.metrics.pairwise import cosine_similarity
 import traceback
 import time
-import pandas as pd # Para formatear la salida en tabla
 
 # --- Configuración ---
 MODEL_REPO_ID = "google/cxr-foundation"
-MODEL_DOWNLOAD_DIR = './hf_cxr_foundation_space' # Directorio dentro del contenedor del Space
-# Umbrales
-SIMILARITY_DIFFERENCE_THRESHOLD = 0.0
-POSITIVE_SIMILARITY_THRESHOLD = 0.0
+MODEL_DOWNLOAD_DIR = './hf_cxr_foundation_space'
+SIMILARITY_DIFFERENCE_THRESHOLD = 0.1
+POSITIVE_SIMILARITY_THRESHOLD = 0.1
+
 print(f"Usando umbrales: Comp Δ={SIMILARITY_DIFFERENCE_THRESHOLD}, Simp τ={POSITIVE_SIMILARITY_THRESHOLD}")
 
-# --- Prompts ---
+# Prompts por defecto mejorados
 criteria_list_positive = [
-    "optimal centering", "optimal inspiration", "optimal penetration",
-    "complete field of view", "scapulae retracted", "sharp image", "artifact free"
+    "optimal centering mediastinum",
+    "deep inspiration",
+    "adequate penetration",
+    "complete lung fields",
+    "scapulae retracted outside lungs",
+    "sharp contrast",
+    "artifact-free image"
 ]
 criteria_list_negative = [
-    "poorly centered", "poor inspiration", "non-diagnostic exposure",
-    "cropped image", "scapulae overlying lungs", "blurred image", "obscuring artifact"
+    "poor centering",
+    "shallow inspiration",
+    "overexposed image",
+    "underexposed image",
+    "cropped lung fields",
+    "scapular overlay on lungs",
+    "blurred image with artifacts"
 ]
 
-# --- Funciones Auxiliares (Integradas o adaptadas) ---
-# @tf.function(input_signature=[tf.TensorSpec(shape=[None], dtype=tf.string)]) # Puede ayudar rendimiento
-def preprocess_text(text):
-    """Función interna del preprocesador BERT."""
-    return bert_preprocessor_global(text)
-
+# --- Funciones Auxiliares ---
 def bert_tokenize(text, preprocessor):
-    """Tokeniza texto usando el preprocesador BERT cargado globalmente."""
     if preprocessor is None:
-       raise ValueError("BERT preprocessor no está cargado.")
-    if not isinstance(text, str): text = str(text)
-
-    # Ejecutar el preprocesador
-    out = preprocessor(tf.constant([text.lower()]))
-
-    # Extraer y procesar IDs y máscaras
+        raise ValueError("BERT preprocessor no está cargado.")
+    text = str(text).lower()
+    out = preprocessor(tf.constant([text]))
     ids = out['input_word_ids'].numpy().astype(np.int32)
     masks = out['input_mask'].numpy().astype(np.float32)
     paddings = 1.0 - masks
-
-    # Reemplazar token [SEP] (102) por 0 y marcar como padding
+    # Ajustes para el token de fin
     end_token_idx = (ids == 102)
     ids[end_token_idx] = 0
     paddings[end_token_idx] = 1.0
-
-    # Asegurar las dimensiones (B, T, S) -> (1, 1, 128)
-    # El preprocesador puede devolver (1, 128), necesitamos (1, 1, 128)
-    if ids.ndim == 2: ids = np.expand_dims(ids, axis=1)
-    if paddings.ndim == 2: paddings = np.expand_dims(paddings, axis=1)
-
-    # Verificar formas finales
-    expected_shape = (1, 1, 128)
-    if ids.shape != expected_shape:
-         # Intentar reajustar si es necesario (puede pasar con algunas versiones)
-         if ids.shape == (1,128): ids = np.expand_dims(ids, axis=1)
-         else: raise ValueError(f"Shape incorrecta para ids: {ids.shape}, esperado {expected_shape}")
-    if paddings.shape != expected_shape:
-         if paddings.shape == (1,128): paddings = np.expand_dims(paddings, axis=1)
-         else: raise ValueError(f"Shape incorrecta para paddings: {paddings.shape}, esperado {expected_shape}")
-
+    # Asegurar forma (1,1,128)
+    if ids.ndim == 2: ids = np.expand_dims(ids, 1)
+    if paddings.ndim == 2: paddings = np.expand_dims(paddings, 1)
     return ids, paddings
 
 def png_to_tfexample(image_array: np.ndarray) -> tf.train.Example:
-    """Crea tf.train.Example desde NumPy array (escala de grises)."""
+    # (sin cambios, convierte array NumPy a tf.Example PNG)
     if image_array.ndim == 3 and image_array.shape[2] == 1:
-        image_array = np.squeeze(image_array, axis=2) # Asegurar 2D
+        image_array = np.squeeze(image_array, axis=2)
     elif image_array.ndim != 2:
-        raise ValueError(f'Array debe ser 2-D (escala de grises). Dimensiones actuales: {image_array.ndim}')
-
+        raise ValueError(f'Array debe ser 2-D. Dimensiones: {image_array.ndim}')
     image = image_array.astype(np.float32)
-    min_val = image.min()
-    max_val = image.max()
-
-    # Evitar división por cero si la imagen es constante
+    min_val, max_val = image.min(), image.max()
     if max_val <= min_val:
-        # Si es constante, tratar como uint8 si el rango original lo permitía,
-        # o simplemente ponerla a 0 si es float.
         if image_array.dtype == np.uint8 or (min_val >= 0 and max_val <= 255):
-             pixel_array = image.astype(np.uint8)
-             bitdepth = 8
-        else: # Caso flotante constante o fuera de rango uint8
-             pixel_array = np.zeros_like(image, dtype=np.uint16)
-             bitdepth = 16
+            pixel_array = image.astype(np.uint8); bitdepth = 8
+        else:
+            pixel_array = np.zeros_like(image, dtype=np.uint16); bitdepth = 16
     else:
-        image -= min_val # Mover mínimo a cero
+        image -= min_val
         current_max = max_val - min_val
-        # Escalar a 16-bit para mayor precisión si no era uint8 originalmente
         if image_array.dtype != np.uint8:
             image *= 65535 / current_max
-            pixel_array = image.astype(np.uint16)
-            bitdepth = 16
+            pixel_array = image.astype(np.uint16); bitdepth = 16
         else:
-            # Si era uint8, mantener el rango y tipo
-            # La resta del min ya la dejó en [0, current_max]
-            # Escalar a 255 si es necesario
             image *= 255 / current_max
-            pixel_array = image.astype(np.uint8)
-            bitdepth = 8
-
-    # Codificar como PNG
+            pixel_array = image.astype(np.uint8); bitdepth = 8
     output = io.BytesIO()
-    png.Writer(
-        width=pixel_array.shape[1],
-        height=pixel_array.shape[0],
-        greyscale=True,
-        bitdepth=bitdepth
-    ).write(output, pixel_array.tolist())
-    png_bytes = output.getvalue()
-
-    # Crear tf.train.Example
+    png.Writer(width=pixel_array.shape[1], height=pixel_array.shape[0],
+               greyscale=True, bitdepth=bitdepth).write(output, pixel_array.tolist())
     example = tf.train.Example()
     features = example.features.feature
-    features['image/encoded'].bytes_list.value.append(png_bytes)
+    features['image/encoded'].bytes_list.value.append(output.getvalue())
     features['image/format'].bytes_list.value.append(b'png')
     return example
 
 def generate_image_embedding(img_np, elixrc_infer, qformer_infer):
-    """Genera embedding final de imagen."""
     if elixrc_infer is None or qformer_infer is None:
         raise ValueError("Modelos ELIXR-C o QFormer no cargados.")
-
     try:
-        # 1. ELIXR-C
-        serialized_img_tf_example = png_to_tfexample(img_np).SerializeToString()
-        elixrc_output = elixrc_infer(input_example=tf.constant([serialized_img_tf_example]))
-        elixrc_embedding = elixrc_output['feature_maps_0'].numpy()
-        print(f"  Embedding ELIXR-C shape: {elixrc_embedding.shape}")
-
-        # 2. QFormer (Imagen)
-        qformer_input_img = {
-            'image_feature': elixrc_embedding.tolist(),
-            'ids': np.zeros((1, 1, 128), dtype=np.int32).tolist(), # Texto vacío
-            'paddings': np.ones((1, 1, 128), dtype=np.float32).tolist(), # Todo padding
+        serialized = png_to_tfexample(img_np).SerializeToString()
+        elixrc_out = elixrc_infer(input_example=tf.constant([serialized]))
+        elixr_emb = elixrc_out['feature_maps_0'].numpy()
+        q_in = {
+            'image_feature': elixr_emb.tolist(),
+            'ids': np.zeros((1,1,128),dtype=np.int32).tolist(),
+            'paddings': np.ones((1,1,128),dtype=np.float32).tolist(),
         }
-        qformer_output_img = qformer_infer(**qformer_input_img)
-        image_embedding = qformer_output_img['all_contrastive_img_emb'].numpy()
-
-        # Ajustar dimensiones si es necesario
-        if image_embedding.ndim > 2:
-            print(f"  Ajustando dimensiones embedding imagen (original: {image_embedding.shape})")
-            image_embedding = np.mean(
-                image_embedding,
-                axis=tuple(range(1, image_embedding.ndim - 1))
-            )
-            if image_embedding.ndim == 1:
-                image_embedding = np.expand_dims(image_embedding, axis=0)
-        elif image_embedding.ndim == 1:
-             image_embedding = np.expand_dims(image_embedding, axis=0) # Asegurar 2D
-
-        print(f"  Embedding final imagen shape: {image_embedding.shape}")
-        if image_embedding.ndim != 2:
-            raise ValueError(f"Embedding final de imagen no tiene 2 dimensiones: {image_embedding.shape}")
-        return image_embedding
-
+        q_out = qformer_infer(**q_in)
+        img_emb = q_out['all_contrastive_img_emb'].numpy()
+        if img_emb.ndim > 2:
+            img_emb = img_emb.mean(axis=tuple(range(1, img_emb.ndim-1)))
+        if img_emb.ndim == 1:
+            img_emb = img_emb[np.newaxis, :]
+        return img_emb
     except Exception as e:
-        print(f"Error generando embedding de imagen: {e}")
+        print(f"Error embedding imagen: {e}")
         traceback.print_exc()
-        raise # Re-lanzar la excepción para que Gradio la maneje
-
-def calculate_similarities_and_classify(image_embedding, bert_preprocessor, qformer_infer):
-    """Calcula similitudes y clasifica."""
-    if image_embedding is None: raise ValueError("Embedding de imagen es None.")
-    if bert_preprocessor is None: raise ValueError("Preprocesador BERT es None.")
-    if qformer_infer is None: raise ValueError("QFormer es None.")
-
-    detailed_results = {}
-    print("\n--- Calculando similitudes y clasificando ---")
-
-    for i in range(len(criteria_list_positive)):
-        positive_text = criteria_list_positive[i]
-        negative_text = criteria_list_negative[i]
-        criterion_name = positive_text # Usar prompt positivo como clave
-
-        print(f"Procesando criterio: \"{criterion_name}\"")
-        similarity_positive, similarity_negative, difference = None, None, None
-        classification_comp, classification_simp = "ERROR", "ERROR"
-
+        raise
+
+def calculate_similarities_and_classify(image_embedding, bert_preprocessor, qformer_infer,
+                                        criteria_positive, criteria_negative):
+    results = {}
+    for pos, neg in zip(criteria_positive, criteria_negative):
+        sim_pos = sim_neg = diff = None
+        comp = simp = "ERROR"
         try:
-            # 1. Embedding Texto Positivo
-            tokens_pos, paddings_pos = bert_tokenize(positive_text, bert_preprocessor)
-            qformer_input_text_pos = {
-                'image_feature': np.zeros([1, 8, 8, 1376], dtype=np.float32).tolist(), # Dummy
-                'ids': tokens_pos.tolist(), 'paddings': paddings_pos.tolist(),
-            }
-            text_embedding_pos = qformer_infer(**qformer_input_text_pos)['contrastive_txt_emb'].numpy()
-            if text_embedding_pos.ndim == 1: text_embedding_pos = np.expand_dims(text_embedding_pos, axis=0)
-
-            # 2. Embedding Texto Negativo
-            tokens_neg, paddings_neg = bert_tokenize(negative_text, bert_preprocessor)
-            qformer_input_text_neg = {
-                'image_feature': np.zeros([1, 8, 8, 1376], dtype=np.float32).tolist(), # Dummy
-                'ids': tokens_neg.tolist(), 'paddings': paddings_neg.tolist(),
-            }
-            text_embedding_neg = qformer_infer(**qformer_input_text_neg)['contrastive_txt_emb'].numpy()
-            if text_embedding_neg.ndim == 1: text_embedding_neg = np.expand_dims(text_embedding_neg, axis=0)
-
-            # Verificar compatibilidad de dimensiones para similitud
-            if image_embedding.shape[1] != text_embedding_pos.shape[1]:
-                 raise ValueError(f"Dimensión incompatible: Imagen ({image_embedding.shape[1]}) vs Texto Pos ({text_embedding_pos.shape[1]})")
-            if image_embedding.shape[1] != text_embedding_neg.shape[1]:
-                 raise ValueError(f"Dimensión incompatible: Imagen ({image_embedding.shape[1]}) vs Texto Neg ({text_embedding_neg.shape[1]})")
-
-            # 3. Calcular Similitudes
-            similarity_positive = cosine_similarity(image_embedding, text_embedding_pos)[0][0]
-            similarity_negative = cosine_similarity(image_embedding, text_embedding_neg)[0][0]
-            print(f"  Sim (+)={similarity_positive:.4f}, Sim (-)={similarity_negative:.4f}")
-
-            # 4. Clasificar
-            difference = similarity_positive - similarity_negative
-            classification_comp = "PASS" if difference > SIMILARITY_DIFFERENCE_THRESHOLD else "FAIL"
-            classification_simp = "PASS" if similarity_positive > POSITIVE_SIMILARITY_THRESHOLD else "FAIL"
-            print(f"  Diff={difference:.4f} -> Comp: {classification_comp}, Simp: {classification_simp}")
-
+            # Embedding texto positivo
+            ids_p, pad_p = bert_tokenize(pos, bert_preprocessor)
+            inp_p = {'image_feature': np.zeros([1,8,8,1376],dtype=np.float32).tolist(),
+                     'ids': ids_p.tolist(), 'paddings': pad_p.tolist()}
+            txt_p = qformer_infer(**inp_p)['contrastive_txt_emb'].numpy()
+            # Embedding texto negativo
+            ids_n, pad_n = bert_tokenize(neg, bert_preprocessor)
+            inp_n = {'image_feature': np.zeros([1,8,8,1376],dtype=np.float32).tolist(),
+                     'ids': ids_n.tolist(), 'paddings': pad_n.tolist()}
+            txt_n = qformer_infer(**inp_n)['contrastive_txt_emb'].numpy()
+
+            sim_pos = float(cosine_similarity(image_embedding, txt_p.reshape(1,-1))[0][0])
+            sim_neg = float(cosine_similarity(image_embedding, txt_n.reshape(1,-1))[0][0])
+            diff = sim_pos - sim_neg
+            comp = "PASS" if diff > SIMILARITY_DIFFERENCE_THRESHOLD else "FAIL"
+            simp = "PASS" if sim_pos > POSITIVE_SIMILARITY_THRESHOLD else "FAIL"
         except Exception as e:
-            print(f"  ERROR procesando criterio '{criterion_name}': {e}")
-            traceback.print_exc()
-            # Mantener clasificaciones como "ERROR"
-
-        # Guardar resultados
-        detailed_results[criterion_name] = {
-            'positive_prompt': positive_text,
-            'negative_prompt': negative_text,
-            'similarity_positive': float(similarity_positive) if similarity_positive is not None else None,
-            'similarity_negative': float(similarity_negative) if similarity_negative is not None else None,
-            'difference': float(difference) if difference is not None else None,
-            'classification_comparative': classification_comp,
-            'classification_simplified': classification_simp
+            print(f"Error en criterio '{pos}': {e}")
+        results[pos] = {
+            'positive_prompt': pos,
+            'negative_prompt': neg,
+            'sim_pos': sim_pos,
+            'sim_neg': sim_neg,
+            'difference': diff,
+            'comp': comp,
+            'simp': simp
         }
-    return detailed_results
+    return results
 
 # --- Carga Global de Modelos ---
-# Se ejecuta UNA VEZ al iniciar la aplicación Gradio/Space
-print("--- Iniciando carga global de modelos ---")
+print("--- Iniciando carga de modelos ---")
 start_time = time.time()
 models_loaded = False
-bert_preprocessor_global = None
-elixrc_infer_global = None
-qformer_infer_global = None
-
+bert_preproc = elixrc = qformer = None
 try:
-    # Verificar autenticación HF (útil si se usan modelos privados, aunque no es el caso aquí)
-    # if HfFolder.get_token() is None:
-    #     print("Advertencia: No se encontró token de Hugging Face.")
-    # else:
-    #     print("Token de Hugging Face encontrado.")
-
-    # Crear directorio si no existe
+    hf_token = os.environ.get("HF_TOKEN")
     os.makedirs(MODEL_DOWNLOAD_DIR, exist_ok=True)
-    print(f"Descargando/verificando modelos en: {MODEL_DOWNLOAD_DIR}")
     snapshot_download(repo_id=MODEL_REPO_ID, local_dir=MODEL_DOWNLOAD_DIR,
-                      allow_patterns=['elixr-c-v2-pooled/*', 'pax-elixr-b-text/*'],
-                      local_dir_use_symlinks=False) # Evitar symlinks
-    print("Modelos descargados/verificados.")
-
-    # Cargar Preprocesador BERT desde TF Hub
-    print("Cargando Preprocesador BERT...")
-    # Usar handle explícito puede ser más robusto en algunos entornos
-    bert_preprocess_handle = "https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3"
-    bert_preprocessor_global = tf_hub.KerasLayer(bert_preprocess_handle)
-    print("Preprocesador BERT cargado.")
-
-    # Cargar ELIXR-C
-    print("Cargando ELIXR-C...")
-    elixrc_model_path = os.path.join(MODEL_DOWNLOAD_DIR, 'elixr-c-v2-pooled')
-    elixrc_model = tf.saved_model.load(elixrc_model_path)
-    elixrc_infer_global = elixrc_model.signatures['serving_default']
-    print("Modelo ELIXR-C cargado.")
-
-    # Cargar QFormer (ELIXR-B Text)
-    print("Cargando QFormer (ELIXR-B Text)...")
-    qformer_model_path = os.path.join(MODEL_DOWNLOAD_DIR, 'pax-elixr-b-text')
-    qformer_model = tf.saved_model.load(qformer_model_path)
-    qformer_infer_global = qformer_model.signatures['serving_default']
-    print("Modelo QFormer cargado.")
-
+                      allow_patterns=['elixr-c-v2-pooled/*','pax-elixr-b-text/*'],
+                      local_dir_use_symlinks=False, token=hf_token)
+    bert_preproc = tf_hub.KerasLayer("https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3")
+    elixr = tf.saved_model.load(os.path.join(MODEL_DOWNLOAD_DIR,'elixr-c-v2-pooled')).signatures['serving_default']
+    qformer = tf.saved_model.load(os.path.join(MODEL_DOWNLOAD_DIR,'pax-elixr-b-text')).signatures['serving_default']
     models_loaded = True
-    end_time = time.time()
-    print(f"--- Modelos cargados globalmente con éxito en {end_time - start_time:.2f} segundos ---")
-
+    print(f"Modelos cargados en {time.time()-start_time:.2f}s")
 except Exception as e:
-    models_loaded = False
-    print(f"--- ERROR CRÍTICO DURANTE LA CARGA GLOBAL DE MODELOS ---")
-    print(e)
+    print("ERROR cargando modelos:", e)
     traceback.print_exc()
-    # Gradio se iniciará, pero la función de análisis fallará.
 
-# --- Función Principal de Procesamiento para Gradio ---
-def assess_quality(image_pil):
-    """Función que Gradio llamará con la imagen de entrada."""
+# --- Función Principal para Gradio ---
+def assess_quality_and_update_ui(image_pil, pos_input, neg_input):
     if not models_loaded:
-        raise gr.Error("Error: Los modelos no se pudieron cargar. La aplicación no puede procesar imágenes.")
+        raise gr.Error("No se pudieron cargar los modelos.")
     if image_pil is None:
-        # Devolver resultados vacíos o un mensaje de error si no hay imagen
-         return pd.DataFrame(), "N/A", None # Dataframe vacío, Label vacío, JSON vacío
-
-    print("\n--- Iniciando evaluación para nueva imagen ---")
-    start_process_time = time.time()
-
-    try:
-        # 1. Convertir PIL Image a NumPy array (escala de grises)
-        # Gradio con type="pil" ya la entrega como objeto PIL
-        img_np = np.array(image_pil.convert('L'))
-        print(f"Imagen convertida a NumPy. Shape: {img_np.shape}, Tipo: {img_np.dtype}")
-
-        # 2. Generar Embedding de Imagen
-        print("Generando embedding de imagen...")
-        image_embedding = generate_image_embedding(img_np, elixrc_infer_global, qformer_infer_global)
-        print("Embedding de imagen generado.")
-
-        # 3. Calcular Similitudes y Clasificar
-        print("Calculando similitudes y clasificando criterios...")
-        detailed_results = calculate_similarities_and_classify(image_embedding, bert_preprocessor_global, qformer_infer_global)
-        print("Clasificación completada.")
-
-        # 4. Formatear Resultados para Gradio
-        output_data = []
-        passed_count = 0
-        total_count = 0
-        for criterion, details in detailed_results.items():
-            total_count += 1
-            sim_pos_str = f"{details['similarity_positive']:.4f}" if details['similarity_positive'] is not None else "N/A"
-            sim_neg_str = f"{details['similarity_negative']:.4f}" if details['similarity_negative'] is not None else "N/A"
-            diff_str = f"{details['difference']:.4f}" if details['difference'] is not None else "N/A"
-            assessment_comp = details['classification_comparative']
-            assessment_simp = details['classification_simplified']
-            output_data.append([
-                criterion,
-                sim_pos_str,
-                sim_neg_str,
-                diff_str,
-                assessment_comp,
-                assessment_simp
-            ])
-            if assessment_comp == "PASS":
-                passed_count += 1
-
-        # Crear DataFrame
-        df_results = pd.DataFrame(output_data, columns=[
-            "Criterion", "Sim (+)", "Sim (-)", "Difference", "Assessment (Comp)", "Assessment (Simp)"
-        ])
-
-        # Calcular etiqueta de calidad general
-        overall_quality = "Error"
-        if total_count > 0:
-            pass_rate = passed_count / total_count
-            if pass_rate >= 0.85: overall_quality = "Excellent"
-            elif pass_rate >= 0.70: overall_quality = "Good"
-            elif pass_rate >= 0.50: overall_quality = "Fair"
-            else: overall_quality = "Poor"
-        quality_label = f"{overall_quality} ({passed_count}/{total_count} criteria passed)"
-
-        end_process_time = time.time()
-        print(f"--- Evaluación completada en {end_process_time - start_process_time:.2f} segundos ---")
-
-        # Devolver DataFrame, Etiqueta y JSON
-        return df_results, quality_label, detailed_results
-
-    except Exception as e:
-        print(f"Error durante el procesamiento de la imagen en Gradio: {e}")
-        traceback.print_exc()
-        # Lanzar un gr.Error para mostrarlo en la UI de Gradio
-        raise gr.Error(f"Error procesando la imagen: {str(e)}")
-
+        # devuelve: welcome visible, results oculto, imagen None, etiqueta N/A, html vacío, json vacío
+        return (
+            gr.update(visible=True),
+            gr.update(visible=False),
+            None,
+            "N/A",
+            "",
+            {}
+        )
+    # Parsear listas de prompts
+    pos_list = [l.strip() for l in pos_input.splitlines() if l.strip()]
+    neg_list = [l.strip() for l in neg_input.splitlines() if l.strip()]
+    if len(pos_list) != len(neg_list):
+        raise gr.Error("El número de prompts positivos y negativos debe coincidir.")
+    # Embedding imagen
+    img_np = np.array(image_pil.convert('L'))
+    emb = generate_image_embedding(img_np, elixr, qformer)
+    # Calcular similitudes
+    details = calculate_similarities_and_classify(emb, bert_preproc, qformer, pos_list, neg_list)
+    # Generar HTML
+    passed = total = 0
+    rows = ""
+    for crit, d in details.items():
+        total += 1
+        if d['comp']=="PASS': passed+=1
+        c_style = "color:#22c55e;font-weight:bold;" if d['comp']=="PASS" else "color:#ef4444;font-weight:bold;"
+        s_style = "color:#22c55e;font-weight:bold;" if d['simp']=="PASS" else "color:#ef4444;font-weight:bold;"
+        rows += (
+            f"<tr>"
+            f"<td>{crit}</td>"
+            f"<td>{d['sim_pos']:.4f}</td>"
+            f"<td>{d['sim_neg']:.4f}</td>"
+            f"<td>{d['difference']:.4f}</td>"
+            f"<td style='{c_style}'>{d['comp']}</td>"
+            f"<td style='{s_style}'>{d['simp']}</td>"
+            f"</tr>"
+        )
+    html = f"""
+    <table style="width:100%;border-collapse:collapse;">
+      <thead style="background:#f2f2f2;">
+        <tr>
+          <th>Criterion</th><th>Sim (+)</th><th>Sim (-)</th><th>Diff</th>
+          <th>Assessment (Comp)</th><th>Assessment (Simp)</th>
+        </tr>
+      </thead>
+      <tbody>{rows}</tbody>
+    </table>
+    """
+    # Etiqueta general
+    pass_rate = passed/total if total>0 else 0
+    if pass_rate>=0.85: overall="Excellent"
+    elif pass_rate>=0.70: overall="Good"
+    elif pass_rate>=0.50: overall="Fair"
+    else: overall="Poor"
+    quality_label = f"{overall} ({passed}/{total} passed)"
+    # Devolver actualizaciones UI
+    return (
+        gr.update(visible=False),
+        gr.update(visible=True),
+        image_pil,
+        quality_label,
+        html,
+        details
+    )
 
-# --- Definir la Interfaz Gradio ---
-css = """
-#quality-label label {
-    font-size: 1.1em;
-    font-weight: bold;
-}
-"""
-with gr.Blocks(css=css) as demo:
-    gr.Markdown(
-        """
-        #  Chest X-ray Technical Quality Assessment
-        Upload a chest X-ray image (PNG, JPG, etc.) to evaluate its technical quality based on 7 standard criteria
-        using the ELIXR model family (comparative strategy: Positive vs Negative prompts).
-        **Note:** Model loading on startup might take a minute. Processing an image can take 10-30 seconds depending on server load.
-        """
+def reset_ui():
+    return (
+        gr.update(visible=True),
+        gr.update(visible=False),
+        None,       # limpia input_image
+        None,       # limpia output_image
+        "N/A",      # etiqueta calidad
+        "",         # HTML
+        {}          # JSON
     )
+
+# --- Definir Tema ---
+dark_theme = gr.themes.Default(
+    primary_hue=gr.themes.colors.blue,
+    secondary_hue=gr.themes.colors.blue,
+    neutral_hue=gr.themes.colors.gray,
+    font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"],
+    font_mono=[gr.themes.GoogleFont("JetBrains Mono"), "ui-monospace", "Consolas", "monospace"],
+).set(
+    body_background_fill="#111827",
+    background_fill_primary="#1f2937",
+    background_fill_secondary="#374151",
+    block_background_fill="#1f2937",
+    body_text_color="#d1d5db",
+    block_label_text_color="#d1d5db",
+    block_title_text_color="#ffffff",
+    border_color_accent="#374151",
+    border_color_primary="#4b5563",
+    button_primary_background_fill="*primary_600",
+    button_primary_text_color="#ffffff",
+    button_secondary_background_fill="*neutral_700",
+    button_secondary_text_color="#ffffff",
+    input_background_fill="#374151",
+    input_border_color="#4b5563",
+    shadow_drop="rgba(0,0,0,0.2) 0px 2px 4px",
+    block_shadow="rgba(0,0,0,0.2) 0px 2px 5px",
+)
+
+# --- Interfaz Gradio ---
+with gr.Blocks(theme=dark_theme, title="CXR Quality Assessment") as demo:
+    # Cabecera
+    gr.Markdown("""
+    # <span style="color: #e5e7eb;">CXR Quality Assessment</span>  
+    <p style="color: #9ca3af;">Evalúa la calidad técnica de radiografías de tórax con AI</p>
+    """)
+    # Prompts editables
     with gr.Row():
-        with gr.Column(scale=1):
-            input_image = gr.Image(type="pil", label="Upload Chest X-ray")
-            submit_button = gr.Button("Assess Quality", variant="primary")
-            # Añadir ejemplos si tienes imágenes de ejemplo
-            # Asegúrate de que la carpeta 'examples' exista y contenga las imágenes
-            # gr.Examples(
-            #     examples=[os.path.join("examples", "sample_cxr.png")], # Lista de rutas a ejemplos
-            #     inputs=input_image
-            # )
+        positive_prompts_input = gr.Textarea(
+            label="Prompts Positivos (uno por línea)",
+            value="\n".join(criteria_list_positive),
+            lines=7
+        )
+        negative_prompts_input = gr.Textarea(
+            label="Prompts Negativos (uno por línea)",
+            value="\n".join(criteria_list_negative),
+            lines=7
+        )
+    # Contenido principal
+    with gr.Row(equal_height=False):
+        with gr.Column(scale=1, min_width=300):
+            gr.Markdown("### 1. Carga de Imagen")
+            input_image = gr.Image(type="pil", label="Sube tu CXR", height=300)
+            with gr.Row():
+                analyze_btn = gr.Button("Analizar", variant="primary")
+                reset_btn   = gr.Button("Reset",   variant="secondary")
+            gr.Markdown("<p style='color:#9ca3af; font-size:0.9em;'>La carga de modelos tarda ~1 min; el análisis ~15–40 s.</p>")
         with gr.Column(scale=2):
-            output_label = gr.Label(label="Overall Quality Estimate", elem_id="quality-label")
-            # --- LÍNEA MODIFICADA ---
-            output_dataframe = gr.DataFrame(
-                headers=["Criterion", "Sim (+)", "Sim (-)", "Difference", "Assessment (Comp)", "Assessment (Simp)"],
-                label="Detailed Quality Assessment",
-                wrap=True
-                # height=350 <-- ELIMINADO
-                )
-            # --- FIN LÍNEA MODIFICADA ---
-            output_json = gr.JSON(label="Raw Results (for debugging)")
-            
-    # Conectar el botón a la función de procesamiento
-    submit_button.click(
-        fn=assess_quality,
-        inputs=input_image,
-        outputs=[output_dataframe, output_label, output_json]
+            with gr.Column(visible=True) as welcome_block:
+                gr.Markdown("### ¡Bienvenido! Sube una radiografía y haz clic en «Analizar».")
+            with gr.Column(visible=False) as results_block:
+                gr.Markdown("### 2. Resultados")
+                with gr.Row():
+                    output_image = gr.Image(type="pil", label="Imagen Analizada", interactive=False)
+                    with gr.Column():
+                        gr.Markdown("#### Calidad Global")
+                        output_label = gr.Label(value="N/A")
+                gr.Markdown("#### Evaluación Detallada")
+                output_html = gr.HTML()
+                with gr.Accordion("Ver JSON (debug)", open=False):
+                    output_json = gr.JSON()
+    # Conexiones
+    analyze_btn.click(
+        fn=assess_quality_and_update_ui,
+        inputs=[input_image, positive_prompts_input, negative_prompts_input],
+        outputs=[welcome_block, results_block, output_image, output_label, output_html, output_json]
+    )
+    reset_btn.click(
+        fn=reset_ui,
+        inputs=None,
+        outputs=[welcome_block, results_block, input_image, output_image, output_label, output_html, output_json]
     )
 
-# --- Iniciar la Aplicación Gradio ---
-# Al desplegar en Spaces, Gradio se encarga de esto automáticamente.
-# Para ejecutar localmente: demo.launch()
-# Para Spaces, es mejor dejar que HF maneje el launch.
-# demo.launch(share=True) # Para obtener un link público temporal si corres localmente
 if __name__ == "__main__":
-     # share=True solo si quieres un enlace público temporal desde local
-     # server_name="0.0.0.0" para permitir conexiones de red local
-     # server_port=7860 es el puerto estándar de HF Spaces
-     demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch(server_name="0.0.0.0", server_port=7860)