app.py

import gradio as gr
from transformers import Blip2Processor, Blip2ForConditionalGeneration, pipeline
from PIL import Image
import requests
import os

# Função para verificar se o modelo existe localmente
def check_model_locally(model_name):
    cache_dir = os.path.expanduser("~/.cache/huggingface/transformers")
    model_path = os.path.join(cache_dir, model_name.replace("/", "--"))
    return os.path.exists(model_path)

# Carregar o modelo BLIP-2 para geração de descrições de imagens
model_blip2_name = "Salesforce/blip2-opt-2.7b"
if check_model_locally(model_blip2_name):
    print(f"Modelo {model_blip2_name} encontrado localmente.")
    processor = Blip2Processor.from_pretrained(model_blip2_name, local_files_only=True)
    model_blip2 = Blip2ForConditionalGeneration.from_pretrained(model_blip2_name, local_files_only=True)
else:
    print(f"Modelo {model_blip2_name} não encontrado localmente. Baixando...")
    processor = Blip2Processor.from_pretrained(model_blip2_name)
    model_blip2 = Blip2ForConditionalGeneration.from_pretrained(model_blip2_name)

# Carregar um modelo de linguagem para análise nutricional (exemplo: Flan-T5)
nutrition_model_name = "google/flan-t5-large"
if check_model_locally(nutrition_model_name):
    print(f"Modelo {nutrition_model_name} encontrado localmente.")
    nutrition_model = pipeline("text2text-generation", model=nutrition_model_name, local_files_only=True)
else:
    print(f"Modelo {nutrition_model_name} não encontrado localmente. Baixando...")
    nutrition_model = pipeline("text2text-generation", model=nutrition_model_name)

def interpret_image(image):
    # Converter a imagem para o formato PIL se necessário
    if isinstance(image, str):
        image = Image.open(requests.get(image, stream=True).raw)
    
    # Processar a imagem e gerar a descrição usando BLIP-2
    inputs = processor(image, return_tensors="pt")
    out = model_blip2.generate(**inputs)
    
    # Decodificar a saída para texto
    description = processor.decode(out[0], skip_special_tokens=True)
    
    # Pós-processamento para melhorar a descrição
    description = description.strip().capitalize()
    if not description.endswith("."):
        description += "."
    
    return description

def nutritional_analysis(image):
    # Passo 1: Gerar descrição da imagem usando BLIP-2
    description = interpret_image(image)
    
    # Passo 2: Criar um prompt refinado para análise nutricional
    prompt = (
        f"Com base na descrição do prato de comida abaixo, forneça uma análise nutricional detalhada.\n\n"
        f"Descrição do prato: {description}\n\n"
        f"Siga este formato:\n"
        f"- Calorias totais estimadas: [valor]\n"
        f"- Macronutrientes (em gramas):\n"
        f"  - Carboidratos: [valor]\n"
        f"  - Proteínas: [valor]\n"
        f"  - Gorduras: [valor]\n"
        f"- Recomendações para melhorar o prato: [sugestões]\n\n"
        f"Análise nutricional:"
    )
    
    # Passo 3: Usar o modelo de linguagem para gerar a análise nutricional
    analysis = nutrition_model(prompt, max_length=300)[0]['generated_text']
    
    # Pós-processamento para formatar a análise nutricional
    analysis = analysis.replace("Análise nutricional:", "").strip()
    
    # Retornar a descrição e a análise nutricional
    return description, analysis

# Interface Gradio com Design Avançado
with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="cyan")) as demo:
    # Cabeçalho com Marketing
    with gr.Row():
        gr.Markdown("""
        # 🍽️ Agente Nutricionista Inteligente
        ### Transforme suas refeições em escolhas saudáveis!
        - **Descrição automática** de pratos de comida com IA avançada.
        - **Análise nutricional detalhada** com estimativas de calorias e macronutrientes.
        - **Recomendações personalizadas** para melhorar sua dieta.
        """)
    
    # Seção de Upload de Imagem
    with gr.Row():
        with gr.Column(scale=1):
            gr.Markdown("### 📸 Carregue uma Imagem")
            image_input = gr.Image(type="pil", label="Upload de Imagem", height=300)
        
        with gr.Column(scale=2):
            gr.Markdown("### 🔍 Resultados")
            with gr.Tabs():
                with gr.TabItem("Descrição do Prato"):
                    description_output = gr.Textbox(label="Descrição Gerada", lines=3, interactive=False)
                
                with gr.TabItem("Análise Nutricional"):
                    analysis_output = gr.Textbox(label="Análise Nutricional", lines=8, interactive=False)
    
    # Botão de Ação
    with gr.Row():
        submit_button = gr.Button("✨ Analisar Prato", variant="primary")
    
    # Feedback do Usuário
    with gr.Row():
        feedback = gr.Markdown("")
    
    # Função para processar a imagem
    def process_image(image):
        try:
            description, analysis = nutritional_analysis(image)
            feedback.update("✅ Análise concluída com sucesso!")
            return description, analysis
        except Exception as e:
            feedback.update(f"❌ Erro ao processar a imagem: {str(e)}")
            return "", ""
    
    # Conectar botão aos outputs
    submit_button.click(process_image, inputs=image_input, outputs=[description_output, analysis_output])
    
    # Rodapé com Chamada à Ação
    with gr.Row():
        gr.Markdown("""
        ---
        ### 💡 Dicas para Melhores Resultados:
        - Use imagens claras e bem iluminadas.
        - Inclua todos os ingredientes visíveis no prato.
        - Experimente diferentes ângulos para capturar mais detalhes.
        
        ### 🌟 Entre em Contato
        - Quer saber mais? Visite nosso [site](https://example.com) ou nos siga nas redes sociais!
        """)
    
    # Adicionar exemplos pré-definidos
    examples = [
        "https://huggingface.co/spaces/DHEIVER/blip-image-captioning-base/blob/main/img.jpg"
    ]
    gr.Examples(examples, inputs=image_input)

# Iniciar o aplicativo
demo.launch()