Update app.py

app.py

@@ -1,267 +1,168 @@
 import gradio as gr
-import numpy as np
-import os
-from dotenv import load_dotenv
-import pandas as pd
-from transformers import Blip2Processor, Blip2ForConditionalGeneration
 import torch
-import time
-
-# Carrega variáveis de ambiente
-load_dotenv()
-API_KEY = os.getenv('NUTRITION_API_KEY', '')
+from transformers import Blip2Processor, Blip2ForConditionalGeneration
+import pandas as pd
+from PIL import Image
+import numpy as np
 
-# Carrega o modelo BLIP2
-model_name = "Salesforce/blip2-opt-2.7b"
-processor = Blip2Processor.from_pretrained(model_name)
-model = Blip2ForConditionalGeneration.from_pretrained(model_name, torch_dtype=torch.float16, device_map="auto")
+# Inicializa o modelo BLIP2
+device = "cuda" if torch.cuda.is_available() else "cpu"
+processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b")
+model = Blip2ForConditionalGeneration.from_pretrained(
+    "Salesforce/blip2-opt-2.7b",
+    torch_dtype=torch.float16 if device == "cuda" else torch.float32,
+    device_map="auto"
+)
 
-def identify_foods(image):
-    """Identifica alimentos na imagem usando BLIP2"""
-    prompt = "Liste todos os alimentos visíveis nesta imagem de refeição."
-    inputs = processor(image, text=prompt, return_tensors="pt").to(model.device)
-    
-    outputs = model.generate(
-        **inputs,
-        max_new_tokens=100,
-        do_sample=False,
-        num_beams=5,
-        temperature=1.0,
-        top_p=0.9,
-    )
-    
-    return processor.decode(outputs[0], skip_special_tokens=True)
+# Base de dados nutricional
+NUTRITION_DB = {
+    "arroz": {"calorias": 130, "proteinas": 2.7, "carboidratos": 28, "gorduras": 0.3},
+    "feijão": {"calorias": 77, "proteinas": 5.2, "carboidratos": 13.6, "gorduras": 0.5},
+    "frango": {"calorias": 165, "proteinas": 31, "carboidratos": 0, "gorduras": 3.6},
+    "salada": {"calorias": 15, "proteinas": 1.4, "carboidratos": 2.9, "gorduras": 0.2},
+    "batata": {"calorias": 93, "proteinas": 2.5, "carboidratos": 21, "gorduras": 0.1},
+    "carne": {"calorias": 250, "proteinas": 26, "carboidratos": 0, "gorduras": 17},
+    "peixe": {"calorias": 206, "proteinas": 22, "carboidratos": 0, "gorduras": 12},
+    "macarrão": {"calorias": 158, "proteinas": 5.8, "carboidratos": 31, "gorduras": 1.2},
+    "ovo": {"calorias": 155, "proteinas": 13, "carboidratos": 1.1, "gorduras": 11},
+}
 
-def analyze_nutrition(image, progress=gr.Progress()):
-    """Análise nutricional da imagem"""
+def analyze_image(image, progress=gr.Progress()):
+    """Analisa a imagem usando BLIP2 e retorna descrição dos alimentos"""
     try:
-        # Status inicial
-        progress(0, desc="Iniciando análise...")
-        yield "Iniciando análise...", None, None, None, None, "processing"
-        time.sleep(1)  # Simula processamento
+        progress(0.2, desc="Processando imagem...")
         
-        # Identificação dos alimentos
-        progress(0.2, desc="Identificando alimentos...")
-        identified_foods = identify_foods(image)
-        yield f"🔄 Identificando alimentos...\n\n{identified_foods}", None, None, None, None, "processing"
-        time.sleep(1)
+        # Garante que a imagem está no formato correto
+        if isinstance(image, str):
+            image = Image.open(image)
+        elif isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+            
+        # Gera prompt específico para identificação de alimentos
+        prompt = "Identifique e liste todos os alimentos visíveis nesta imagem de refeição. Forneça uma lista detalhada."
         
-        # Análise nutricional
-        progress(0.4, desc="Calculando valores nutricionais...")
-        nutrients = {
-            "calorias": 450,
-            "proteinas": 25,
-            "carboidratos": 55,
-            "gorduras": 15,
-            "fibras": 8
-        }
+        progress(0.4, desc="Analisando alimentos...")
+        inputs = processor(image, text=prompt, return_tensors="pt").to(device)
         
-        # Dados do gráfico
-        plot_data = pd.DataFrame({
-            'Nutriente': ['Proteínas', 'Carboidratos', 'Gorduras'],
-            'Quantidade': [nutrients['proteinas'], nutrients['carboidratos'], nutrients['gorduras']]
-        })
+        progress(0.6, desc="Gerando descrição...")
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_new_tokens=100,
+                num_beams=5,
+                temperature=1.0,
+                top_p=0.9,
+            )
+            
+        food_description = processor.decode(outputs[0], skip_special_tokens=True)
+        progress(0.8, desc="Calculando nutrientes...")
         
-        # Tabela nutricional
-        table_data = [
-            ["Calorias", f"{nutrients['calorias']:.1f} kcal"],
-            ["Proteínas", f"{nutrients['proteinas']:.1f}g"],
-            ["Carboidratos", f"{nutrients['carboidratos']:.1f}g"],
-            ["Gorduras", f"{nutrients['gorduras']:.1f}g"],
-            ["Fibras", f"{nutrients['fibras']:.1f}g"]
-        ]
+        # Identifica alimentos conhecidos na descrição
+        found_foods = []
+        for food in NUTRITION_DB.keys():
+            if food in food_description.lower():
+                found_foods.append(food)
         
-        progress(0.6, desc="Gerando análise...")
-        yield (
-            f"🔄 Gerando análise...\n\n{identified_foods}",
-            table_data,
-            plot_data,
-            "🔄 Analisando valores...",
-            "🔄 Preparando recomendações...",
-            "processing"
-        )
-        time.sleep(1)
+        if not found_foods:
+            return None, None, None, "Não foi possível identificar alimentos conhecidos na imagem."
         
-        # Análise
-        analysis = []
-        if nutrients['calorias'] > 800:
-            analysis.append("⚠️ Alto valor calórico")
-        if nutrients['proteinas'] < 15:
-            analysis.append("⚠️ Baixo teor de proteínas")
-        if nutrients['fibras'] < 6:
-            analysis.append("⚠️ Baixo teor de fibras")
+        # Calcula nutrientes totais
+        total_nutrients = {
+            "calorias": 0,
+            "proteinas": 0,
+            "carboidratos": 0,
+            "gorduras": 0
+        }
         
-        analysis_text = "\n".join(analysis) if analysis else "✅ Valores nutricionais adequados"
+        # Soma nutrientes de cada alimento encontrado
+        for food in found_foods:
+            for nutrient, value in NUTRITION_DB[food].items():
+                total_nutrients[nutrient] += value
         
-        progress(0.8, desc="Gerando recomendações...")
-        # Recomendações
-        recommendations = []
-        if "Alto valor calórico" in analysis_text:
-            recommendations.append("• Considere reduzir as porções")
-        if "Baixo teor de proteínas" in analysis_text:
-            recommendations.append("• Adicione mais fontes de proteína como frango, peixe ou leguminosas")
-        if "Baixo teor de fibras" in analysis_text:
-            recommendations.append("• Inclua mais vegetais e grãos integrais")
-            
-        recommendations_text = "\n".join(recommendations) if recommendations else "• Continue mantendo uma alimentação equilibrada!"
+        # Prepara dados para visualização
+        nutrients_table = [
+            ["Calorias", f"{total_nutrients['calorias']:.1f} kcal"],
+            ["Proteínas", f"{total_nutrients['proteinas']:.1f}g"],
+            ["Carboidratos", f"{total_nutrients['carboidratos']:.1f}g"],
+            ["Gorduras", f"{total_nutrients['gorduras']:.1f}g"]
+        ]
         
-        progress(1.0, desc="Concluído!")
-        # Resultado final
-        yield (
-            f"### 🍽️ Alimentos Identificados\n{identified_foods}",
-            table_data,
-            plot_data,
-            f"### 📊 Análise\n{analysis_text}",
-            f"### 💡 Recomendações\n{recommendations_text}",
-            "success"
-        )
+        # Dados para o gráfico
+        plot_data = pd.DataFrame({
+            'Nutriente': ['Proteínas', 'Carboidratos', 'Gorduras'],
+            'Quantidade': [
+                total_nutrients['proteinas'],
+                total_nutrients['carboidratos'],
+                total_nutrients['gorduras']
+            ]
+        })
         
-    except Exception as e:
-        yield (
-            "❌ Erro na identificação",
-            None,
-            None,
-            "❌ Erro na análise",
-            f"Erro: {str(e)}",
-            "error"
-        )
+        # Gera análise
+        analysis = f"""### Alimentos Identificados:
+{food_description}
 
-css = """
-.container { max-width: 1200px; margin: auto; padding: 20px; }
-.header { text-align: center; margin-bottom: 30px; }
-.result-box {
-    border: 1px solid #ddd;
-    border-radius: 8px;
-    padding: 15px;
-    margin: 10px 0;
-    background-color: #fff;
-}
-.processing {
-    display: flex;
-    justify-content: center;
-    align-items: center;
-    padding: 20px;
-    background: #f7f7f7;
-    border-radius: 8px;
-    margin: 10px 0;
-}
-.status-progress {
-    padding: 10px;
-    margin: 10px 0;
-    border-radius: 4px;
-    font-weight: bold;
-}
-.status-error { background: #fee; color: #c00; }
-.status-success { background: #efe; color: #0c0; }
-.status-processing { background: #eef; color: #00c; }
+### Alimentos na Base de Dados:
+{', '.join(found_foods)}
+
+### Análise Nutricional:
+- Valor Calórico: {total_nutrients['calorias']:.1f} kcal
+- Proporção de Macronutrientes:
+  • Proteínas: {total_nutrients['proteinas']:.1f}g
+  • Carboidratos: {total_nutrients['carboidratos']:.1f}g
+  • Gorduras: {total_nutrients['gorduras']:.1f}g
 """
+        
+        progress(1.0, desc="Concluído!")
+        return analysis, nutrients_table, plot_data, None
+        
+    except Exception as e:
+        return None, None, None, f"Erro na análise: {str(e)}"
 
 # Interface Gradio
-with gr.Blocks(theme=gr.themes.Soft(), css=css) as iface:
-    # Cabeçalho
-    with gr.Row(elem_classes="header"):
-        gr.Markdown("""
-        # 🍽️ Análise Nutricional com IA
-        Faça upload da foto do seu prato para análise nutricional detalhada
-        """)
+with gr.Blocks(theme=gr.themes.Soft()) as iface:
+    gr.Markdown("# 🍽️ Análise Nutricional com IA")
     
-    # Container Principal
     with gr.Row():
-        # Coluna da Esquerda - Input
-        with gr.Column(scale=2):
-            gr.Markdown("### 📸 Foto do Prato")
+        with gr.Column(scale=1):
+            # Input
             image_input = gr.Image(
                 type="pil",
-                sources=["upload", "webcam"],
-                height=400,
-                label=""
+                label="Foto do Prato",
+                sources=["upload", "webcam"]
             )
-            with gr.Row():
-                analyze_btn = gr.Button("🔍 Analisar Prato", variant="primary", size="lg")
-                clear_btn = gr.Button("🔄 Limpar", size="lg")
+            analyze_btn = gr.Button("Analisar", variant="primary")
             
-            with gr.Accordion("📝 Dicas", open=False):
-                gr.Markdown("""
-                - Use fotos bem iluminadas
-                - Fotografe de cima para baixo
-                - Certifique-se que todos os alimentos estão visíveis
-                - Evite sombras ou reflexos fortes
-                """)
-        
-        # Coluna da Direita - Resultados
-        with gr.Column(scale=3):
-            # Status
-            status = gr.Markdown(elem_classes="status-progress", visible=False)
+        with gr.Column(scale=2):
+            # Output
+            error_output = gr.Markdown(visible=False)
             
-            with gr.Tabs() as tabs:
-                # Tab de Identificação
-                with gr.Tab("🔍 Identificação"):
-                    with gr.Group(elem_classes="result-box"):
-                        foods_detected = gr.Markdown()
-                
-                # Tab de Nutrientes
-                with gr.Tab("📊 Nutrição"):
-                    with gr.Group(elem_classes="result-box"):
-                        nutri_table = gr.Dataframe(
-                            headers=["Nutriente", "Quantidade"],
-                            label="Informação Nutricional",
-                            wrap=True
-                        )
-                        macro_plot = gr.BarPlot(
-                            title="Distribuição de Macronutrientes (g)",
-                            x="Nutriente",
-                            y="Quantidade",
-                            height=300,
-                            tooltip=["Nutriente", "Quantidade"]
-                        )
+            with gr.Tabs():
+                with gr.Tab("Análise"):
+                    analysis_output = gr.Markdown()
                 
-                # Tab de Análise
-                with gr.Tab("💡 Análise"):
-                    with gr.Group(elem_classes="result-box"):
-                        analysis_output = gr.Markdown()
-                        gr.Markdown("---")
-                        recommendations_output = gr.Markdown()
-    
-    # Event handlers
-    def clear_outputs():
-        return {
-            foods_detected: None,
-            nutri_table: None,
-            macro_plot: None,
-            analysis_output: None,
-            recommendations_output: None,
-            status: gr.Markdown(visible=False)
-        }
+                with gr.Tab("Nutrientes"):
+                    nutrients_table = gr.Dataframe(
+                        headers=["Nutriente", "Quantidade"],
+                        label="Informação Nutricional"
+                    )
+                    nutrients_plot = gr.BarPlot(
+                        x="Nutriente",
+                        y="Quantidade",
+                        title="Macronutrientes (g)",
+                        height=300
+                    )
     
+    # Eventos
     analyze_btn.click(
-        fn=analyze_nutrition,
+        fn=analyze_image,
         inputs=[image_input],
         outputs=[
-            foods_detected,
-            nutri_table,
-            macro_plot,
             analysis_output,
-            recommendations_output,
-            status
-        ]
-    )
-    
-    clear_btn.click(
-        fn=clear_outputs,
-        outputs=[
-            foods_detected,
-            nutri_table,
-            macro_plot,
-            analysis_output,
-            recommendations_output,
-            status
+            nutrients_table,
+            nutrients_plot,
+            error_output
         ]
     )
 
-# Inicia a interface
 if __name__ == "__main__":
-    if not API_KEY:
-        print("⚠️  Atenção: API Key não encontrada!")
-        print("Configure a variável de ambiente NUTRITION_API_KEY no arquivo .env")
-    
-    iface.launch(share=False)
+    iface.launch()