Update app.py

app.py

@@ -1,171 +1,166 @@
 import gradio as gr
 import torch
-from transformers import AutoModelForCausalLM, AutoProcessor
+from transformers import (
+    Blip2Processor, Blip2ForConditionalGeneration,
+    AutoProcessor, AutoModelForCausalLM, AutoModelForVision2Seq
+)
 from PIL import Image
-import pandas as pd
 import numpy as np
 
-# Carrega o modelo Emu3-Gen
-model = AutoModelForCausalLM.from_pretrained("BAAI/Emu3-Gen", trust_remote_code=True)
-processor = AutoProcessor.from_pretrained("BAAI/Emu3-Gen", trust_remote_code=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},
-    "carne": {"calorias": 250, "proteinas": 26, "carboidratos": 0, "gorduras": 17},
-    "batata frita": {"calorias": 312, "proteinas": 3.4, "carboidratos": 41, "gorduras": 15},
-    "salada": {"calorias": 15, "proteinas": 1.4, "carboidratos": 2.9, "gorduras": 0.2}
-}
-
-def process_image(image, progress=gr.Progress()):
-    """Processa a imagem usando Emu3-Gen"""
-    try:
-        progress(0.3, desc="Processando imagem...")
-        
-        # Prepara a imagem
-        if isinstance(image, str):
-            image = Image.open(image)
-        elif isinstance(image, np.ndarray):
-            image = Image.fromarray(image)
-
-        # Prompt específico para análise de alimentos
-        prompt = "Describe in detail all the foods present in this image, including their preparation methods."
-        
-        progress(0.6, desc="Analisando conteúdo...")
-        # Processa a imagem
-        inputs = processor(
-            images=image,
-            text=prompt,
-            return_tensors="pt"
-        ).to(model.device)
+class ModelManager:
+    def __init__(self):
+        self.current_model = None
+        self.current_processor = None
+        self.model_name = None
         
-        # Gera a descrição
-        outputs = model.generate(
-            **inputs,
-            max_new_tokens=100,
-            num_beams=5,
-            temperature=0.7,
-            top_p=0.9
+    def load_blip2(self):
+        """Carrega modelo BLIP-2"""
+        self.model_name = "Salesforce/blip2-opt-2.7b"
+        self.current_processor = Blip2Processor.from_pretrained(self.model_name)
+        self.current_model = Blip2ForConditionalGeneration.from_pretrained(
+            self.model_name,
+            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+            device_map="auto"
         )
-        
-        description = processor.decode(outputs[0], skip_special_tokens=True)
-        
-        progress(1.0, desc="Concluído!")
-        return description
-        
-    except Exception as e:
-        raise gr.Error(f"Erro no processamento: {str(e)}")
-
-def analyze_nutrition(description):
-    """Analisa nutrientes baseado na descrição"""
-    found_foods = []
+        return "BLIP-2 carregado com sucesso!"
     
-    # Identifica alimentos na descrição
-    for food in NUTRITION_DB.keys():
-        if food.lower() in description.lower():
-            found_foods.append(food)
-    
-    # Calcula nutrientes
-    total_nutrients = {
-        "calorias": 0,
-        "proteinas": 0,
-        "carboidratos": 0,
-        "gorduras": 0
-    }
-    
-    for food in found_foods:
-        for nutrient, value in NUTRITION_DB[food].items():
-            total_nutrients[nutrient] += value
+    def load_llava(self):
+        """Carrega modelo LLaVA"""
+        self.model_name = "llava-hf/llava-1.5-7b-hf"
+        self.current_processor = AutoProcessor.from_pretrained(self.model_name)
+        self.current_model = AutoModelForVision2Seq.from_pretrained(
+            self.model_name,
+            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+            device_map="auto"
+        )
+        return "LLaVA carregado com sucesso!"
     
-    return total_nutrients, found_foods
+    def load_git(self):
+        """Carrega modelo GIT"""
+        self.model_name = "microsoft/git-base-coco"
+        self.current_processor = AutoProcessor.from_pretrained(self.model_name)
+        self.current_model = AutoModelForCausalLM.from_pretrained(
+            self.model_name,
+            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+            device_map="auto"
+        )
+        return "GIT carregado com sucesso!"
 
-def analyze_image(image):
-    """Função principal de análise"""
-    try:
-        # Processa a imagem
-        description = process_image(image)
-        
-        # Analisa nutrientes
-        total_nutrients, found_foods = analyze_nutrition(description)
-        
-        # Prepara dados para visualização
-        table_data = [
-            ["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"]
-        ]
-        
-        # Dados para o gráfico
-        plot_data = pd.DataFrame({
-            'Nutriente': ['Proteínas', 'Carboidratos', 'Gorduras'],
-            'Quantidade': [
-                total_nutrients['proteinas'],
-                total_nutrients['carboidratos'],
-                total_nutrients['gorduras']
-            ]
-        })
+    def analyze_image(self, image, question, model_choice):
+        """Analisa imagem com o modelo selecionado"""
+        try:
+            # Carrega o modelo apropriado se necessário
+            if model_choice == "BLIP-2" and (self.model_name != "Salesforce/blip2-opt-2.7b"):
+                status = self.load_blip2()
+            elif model_choice == "LLaVA" and (self.model_name != "llava-hf/llava-1.5-7b-hf"):
+                status = self.load_llava()
+            elif model_choice == "GIT" and (self.model_name != "microsoft/git-base-coco"):
+                status = self.load_git()
+            
+            # Prepara a imagem
+            if isinstance(image, str):
+                image = Image.open(image)
+            elif isinstance(image, np.ndarray):
+                image = Image.fromarray(image)
+            
+            # Processa a entrada
+            inputs = self.current_processor(
+                images=image,
+                text=question,
+                return_tensors="pt"
+            ).to(self.current_model.device)
+            
+            # Gera a resposta
+            outputs = self.current_model.generate(
+                **inputs,
+                max_new_tokens=150,
+                num_beams=5,
+                temperature=0.7,
+                top_p=0.9
+            )
+            
+            response = self.current_processor.decode(outputs[0], skip_special_tokens=True)
+            return response
         
-        # Monta o relatório
-        analysis = f"""### 🔍 Análise da Imagem:
-{description}
+        except Exception as e:
+            return f"Erro na análise: {str(e)}"
 
-### 🍽️ Alimentos Identificados:
-{', '.join(found_foods)}
-
-### 📊 Informação Nutricional:
-• Calorias: {total_nutrients['calorias']:.1f} kcal
-• Proteínas: {total_nutrients['proteinas']:.1f}g
-• Carboidratos: {total_nutrients['carboidratos']:.1f}g
-• Gorduras: {total_nutrients['gorduras']:.1f}g
-
-### 💡 Recomendações:
-{"⚠️ Alto valor calórico" if total_nutrients['calorias'] > 800 else "✅ Calorias adequadas"}
-{"⚠️ Considere reduzir carboidratos" if total_nutrients['carboidratos'] > 60 else "✅ Carboidratos adequados"}
-{"⚠️ Alto teor de gorduras" if total_nutrients['gorduras'] > 20 else "✅ Gorduras adequadas"}
-"""
-        
-        return analysis, table_data, plot_data
-        
-    except Exception as e:
-        return str(e), None, None
+# Cria instância do gerenciador de modelos
+model_manager = ModelManager()
 
 # Interface Gradio
 with gr.Blocks(theme=gr.themes.Soft()) as iface:
-    gr.Markdown("# 🍽️ NutriAI - Análise Nutricional com IA")
+    gr.Markdown("""
+    # 🤖 Análise Visual Multi-Modelo
+    Escolha o modelo que deseja usar para analisar sua imagem
+    """)
     
     with gr.Row():
         with gr.Column():
+            # Inputs
+            model_choice = gr.Radio(
+                choices=["BLIP-2", "LLaVA", "GIT"],
+                label="Escolha o Modelo",
+                value="BLIP-2"
+            )
+            
+            with gr.Box():
+                gr.Markdown("""
+                ### 📝 Características dos Modelos:
+                
+                **BLIP-2:**
+                - Melhor para análise técnica
+                - Mais preciso em detalhes
+                - Respostas estruturadas
+                
+                **LLaVA:**
+                - Mais conversacional
+                - Respostas naturais
+                - Bom para perguntas abertas
+                
+                **GIT:**
+                - Mais rápido e leve
+                - Bom para descrições simples
+                - Menor uso de memória
+                """)
+            
             image_input = gr.Image(
                 type="pil",
-                label="Foto do Prato",
-                sources=["upload", "webcam"]
+                label="Imagem para Análise"
             )
-            analyze_btn = gr.Button("📊 Analisar", variant="primary")
+            
+            question_input = gr.Textbox(
+                label="Sua Pergunta",
+                placeholder="Faça uma pergunta sobre a imagem..."
+            )
+            
+            analyze_btn = gr.Button("🔍 Analisar", variant="primary")
         
         with gr.Column():
-            output_text = gr.Markdown()
+            # Output
+            with gr.Box():
+                gr.Markdown("### 📊 Resultado da Análise")
+                output_text = gr.Markdown()
             
-            with gr.Row():
-                output_table = gr.Dataframe(
-                    headers=["Nutriente", "Quantidade"],
-                    label="Informação Nutricional"
-                )
-                
-                output_plot = gr.BarPlot(
-                    x="Nutriente",
-                    y="Quantidade",
-                    title="Macronutrientes (g)",
-                    height=300
-                )
+            with gr.Accordion("💡 Sugestões de Perguntas", open=False):
+                gr.Markdown("""
+                1. Quais alimentos você identifica na imagem?
+                2. Como os alimentos estão preparados?
+                3. Descreva a apresentação do prato.
+                4. Que tipo de culinária parece ser?
+                5. Quais são os ingredientes principais?
+                6. Como está a disposição dos elementos no prato?
+                7. Há algum detalhe de decoração ou finalização?
+                8. Qual parece ser o método de cocção utilizado?
+                """)
     
+    # Eventos
     analyze_btn.click(
-        fn=analyze_image,
-        inputs=[image_input],
-        outputs=[output_text, output_table, output_plot]
+        fn=model_manager.analyze_image,
+        inputs=[image_input, question_input, model_choice],
+        outputs=output_text
     )
 
 if __name__ == "__main__":
-    print(f"Usando dispositivo: {'CUDA' if torch.cuda.is_available() else 'CPU'}")
-    iface.launch(share=False)
+    print(f"Dispositivo: {'CUDA' if torch.cuda.is_available() else 'CPU'}")
+    iface.launch()