Update app.py

app.py

@@ -3,100 +3,153 @@ import gradio as gr
 import torch
 from PIL import Image
 from transformers import AutoProcessor, AutoModelForVision2Seq
-import requests
+import requests, base64, re
+from io import BytesIO
 
-# Configuración
+# Configuración del modelo
 LOCAL_MODEL_ID = "lmms-lab/llava-onevision-1.5-8b-instruct"
-API_MODEL_ID = "lmms-lab/llava-onevision-1.5-8b-instruct"
-HF_API_URL = f"https://api-inference.huggingface.co/models/{API_MODEL_ID}"
+HF_API_URL = f"https://api-inference.huggingface.co/models/{LOCAL_MODEL_ID}"
 HF_API_KEY = os.getenv("API_KEY")
 
-# Inicializa modelo local (si hay GPU)
 model, processor = None, None
 use_local = False
 
 try:
-    print("⏳ Intentando cargar modelo local...")
-    processor = AutoProcessor.from_pretrained(LOCAL_MODEL_ID)
+    print("⏳ Cargando modelo local...")
+    processor = AutoProcessor.from_pretrained(LOCAL_MODEL_ID, trust_remote_code=True)
     model = AutoModelForVision2Seq.from_pretrained(
         LOCAL_MODEL_ID,
+        trust_remote_code=True,
         torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
         device_map="auto"
     )
     use_local = True
     print("✅ Modelo local cargado correctamente.")
 except Exception as e:
-    print(f"⚠️ No se pudo cargar el modelo local: {e}")
-    print("➡️ Se usará la API de Hugging Face para inferencia remota.")
+    print(f"⚠️ No se pudo cargar localmente: {e}")
+    print("➡️ Se usará la API de Hugging Face.")
 
-# Función principal
+# ---------- Utilidades ----------
+def extract_macros(text):
+    def find_value(keyword):
+        m = re.search(rf"{keyword}[^0-9]*([0-9]+)", text.lower())
+        return int(m.group(1)) if m else 0
+    p, c, f = find_value("prote"), find_value("carb"), find_value("gras")
+    kcal = p * 4 + c * 4 + f * 9 if any([p, c, f]) else 0
+    return {"protein": p, "carbs": c, "fat": f, "kcal": kcal}
+
+def build_macro_card(macros):
+    if not any(macros.values()):
+        return "<div class='card'>⚖️ No se pudieron estimar los macros.</div>"
+
+    def bar_html(value, color):
+        width = min(value, 100)
+        return f"""
+        <div class='bar-bg'>
+            <div class='bar-fill' style='width:{width}%; background:{color};'></div>
+        </div>
+        """
+
+    return f"""
+    <div class='card'>
+      <h2>🍽️ Estimación Nutricional</h2>
+      <div class='macro'><span>💪 Proteínas</span><span>{macros['protein']} g</span></div>
+      {bar_html(macros['protein'], '#b25eff')}
+      <div class='macro'><span>🥔 Carbohidratos</span><span>{macros['carbs']} g</span></div>
+      {bar_html(macros['carbs'], '#00f0ff')}
+      <div class='macro'><span>🥑 Grasas</span><span>{macros['fat']} g</span></div>
+      {bar_html(macros['fat'], '#ff5efb')}
+      <div class='macro kcal'><span>🔥 Calorías Totales</span><span>{macros['kcal']} kcal</span></div>
+    </div>
+    """
+
+# ---------- Lógica principal ----------
 def analyze_food(image, text_prompt=""):
     if image is None:
-        return "Por favor, subí una imagen del plato."
-
+        return "<div class='card'>Subí una imagen del plato 🍽️</div>"
     if not text_prompt.strip():
-        text_prompt = (
-            "Analiza esta comida. Describe los alimentos, "
-            "y estima las calorías, proteínas, carbohidratos y grasas totales."
-        )
+        text_prompt = "Describe esta comida y estima calorías, proteínas, carbohidratos y grasas."
 
     try:
         if use_local:
-            # Procesamiento local
             inputs = processor(text=text_prompt, images=image, return_tensors="pt").to(model.device)
-            output = model.generate(**inputs, max_new_tokens=300)
-            answer = processor.decode(output[0], skip_special_tokens=True)
-            return answer
-
+            out = model.generate(**inputs, max_new_tokens=400)
+            answer = processor.decode(out[0], skip_special_tokens=True)
         else:
-            # Fallback: usar API de Hugging Face
+            buffered = BytesIO()
+            image.save(buffered, format="JPEG")
+            img_b64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
             headers = {"Authorization": f"Bearer {HF_API_KEY}"}
-            data = {
-                "inputs": {"image": image, "text": text_prompt},
-                "parameters": {"max_new_tokens": 300},
-            }
-            response = requests.post(HF_API_URL, headers=headers, json=data)
-            if response.status_code != 200:
-                return f"❌ Error remoto ({response.status_code}): {response.text}"
-            result = response.json()
-            if isinstance(result, dict) and "error" in result:
-                return f"⚠️ Error remoto: {result['error']}"
-            return str(result)
+            data = {"inputs": {"text": text_prompt, "image": f"data:image/jpeg;base64,{img_b64}"}}
+            r = requests.post(HF_API_URL, headers=headers, json=data)
+            answer = str(r.json())
+
+        macros = extract_macros(answer)
+        card = build_macro_card(macros)
+        return f"<div class='desc'>{answer}</div>{card}"
 
     except Exception as e:
-        return f"⚠️ Ocurrió un error al procesar la imagen: {e}"
+        return f"<div class='card error'>⚠️ Error: {e}</div>"
 
-# Interfaz Gradio
+# ---------- Interfaz ----------
 def build_interface():
-    with gr.Blocks() as demo:
+    with gr.Blocks(css="""
+/* --- DARK NEON THEME --- */
+body {
+  background: radial-gradient(circle at 20% 20%, #0d001f, #000);
+  color: #fff;
+  font-family: 'Inter', sans-serif;
+}
+.gradio-container {background: transparent !important;}
+.card {
+  backdrop-filter: blur(12px);
+  background: rgba(30, 0, 60, 0.3);
+  border: 1px solid rgba(200, 100, 255, 0.2);
+  border-radius: 16px;
+  padding: 1.2em;
+  margin-top: 1em;
+  box-shadow: 0 0 25px rgba(180, 0, 255, 0.15);
+}
+h1,h2 {color:#c18fff;}
+.bar-bg {
+  width:100%; height:8px; border-radius:6px;
+  background:rgba(255,255,255,0.1); margin:4px 0 12px 0;
+  overflow:hidden;
+}
+.bar-fill {height:100%; border-radius:6px; transition:width 1s ease;}
+.macro {display:flex; justify-content:space-between; font-size:0.95em;}
+.kcal {font-weight:600; color:#ffb3ff;}
+.desc {
+  background:rgba(255,255,255,0.05);
+  padding:1em; border-radius:10px; line-height:1.5em;
+  box-shadow:inset 0 0 20px rgba(180,0,255,0.1);
+}
+button {
+  background:linear-gradient(90deg,#b25eff,#00f0ff);
+  color:#fff; border:none; border-radius:12px;
+  font-weight:600; transition:opacity .2s;
+}
+button:hover {opacity:0.8;}
+""") as demo:
         gr.Markdown(
             """
-            # 🍽️ NasFit Vision AI  
-            Subí una foto de tu comida y NasFit IA estimará su contenido nutricional.  
-            Basado en **LLaVA-OneVision-1.5**, modelo multimodal open source con análisis visual avanzado.  
-            *(El sistema usa GPU local si está disponible, o la API de Hugging Face si no lo está.)*
+            <h1>💜 NasFit Vision AI</h1>
+            <p>Analiza tus comidas con IA y obtené tu ficha nutricional instantánea.</p>
             """
         )
 
         with gr.Row():
             with gr.Column(scale=1):
-                image_input = gr.Image(label="📸 Imagen del plato", type="pil")
-                text_input = gr.Textbox(
-                    label="💬 Instrucción (opcional)",
-                    placeholder="Ejemplo: Cuántas proteínas tiene este plato?",
-                )
-                analyze_btn = gr.Button("🔍 Analizar comida")
-
+                img = gr.Image(label="📸 Imagen del plato", type="pil")
+                txt = gr.Textbox(label="💬 Instrucción (opcional)",
+                                 placeholder="Ej: ¿Cuántas calorías tiene este plato?")
+                btn = gr.Button("🔍 Analizar", variant="primary")
             with gr.Column(scale=1):
-                output_text = gr.Textbox(
-                    label="🧠 Resultado del análisis",
-                    placeholder="Aquí aparecerá la descripción nutricional...",
-                    lines=8
-                )
+                out = gr.HTML(label="🧠 Resultado")
 
-        analyze_btn.click(fn=analyze_food, inputs=[image_input, text_input], outputs=output_text)
-    return demo
+        btn.click(analyze_food, [img, txt], out)
 
+    return demo
 
 if __name__ == "__main__":
     demo = build_interface()