Update app.py

app.py

@@ -1,80 +1,116 @@
 import gradio as gr
 import torch
-from transformers import pipeline, AutoProcessor, AutoModelForVision2Seq
-from PIL import Image, ImageOps
+from transformers import AutoProcessor, AutoModelForVision2Seq
+from PIL import Image
 import numpy as np
 import os
-from huggingface_hub import snapshot_download
 import logging
+import cv2
+import shutil
+import subprocess
 from pathlib import Path
 import tempfile
-import requests
-from io import BytesIO
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
+# Configuração de logging
+logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 
-class ImageHandler:
-    """Handle image processing and conversion"""
+class ForceImageProcessor:
+    """Processador agressivo de imagens com múltiplos fallbacks"""
+    
     @staticmethod
-    def convert_to_rgb(image_path):
-        """Convert image to RGB format supporting multiple formats"""
+    def force_convert_image(input_path):
+        """Converte imagem usando múltiplos métodos até funcionar"""
         try:
-            # If image is a URL, download it first
-            if isinstance(image_path, str) and (image_path.startswith('http://') or image_path.startswith('https://')):
-                response = requests.get(image_path)
-                image_data = BytesIO(response.content)
-                image = Image.open(image_data)
-            else:
-                image = Image.open(image_path)
-
-            # Convert RGBA to RGB if needed
-            if image.mode == 'RGBA':
-                background = Image.new('RGB', image.size, (255, 255, 255))
-                background.paste(image, mask=image.split()[3])
-                image = background
-            # Convert any other mode to RGB
-            elif image.mode != 'RGB':
-                image = image.convert('RGB')
+            # Cria diretório temporário
+            with tempfile.TemporaryDirectory() as temp_dir:
+                temp_path = Path(temp_dir) / "converted_image.jpg"
+                
+                # Tenta diferentes métodos de conversão
+                methods = [
+                    ForceImageProcessor._try_pillow,
+                    ForceImageProcessor._try_opencv,
+                    ForceImageProcessor._try_imagemagick,
+                    ForceImageProcessor._try_ffmpeg
+                ]
+                
+                for method in methods:
+                    try:
+                        result = method(input_path, temp_path)
+                        if result:
+                            return Image.open(temp_path)
+                    except Exception as e:
+                        logger.debug(f"Método falhou: {str(e)}")
+                        continue
+                
+                raise ValueError("Todos os métodos de conversão falharam")
                 
-            return image
-            
         except Exception as e:
-            logger.error(f"Error converting image: {str(e)}")
-            raise ValueError(f"Não foi possível processar a imagem. Erro: {str(e)}")
-
+            logger.error(f"Erro na conversão: {str(e)}")
+            raise
+    
     @staticmethod
-    def process_image(image):
-        """Process image from various input types"""
+    def _try_pillow(input_path, output_path):
+        """Tenta converter usando Pillow"""
         try:
-            if isinstance(image, np.ndarray):
-                return Image.fromarray(image)
-            elif isinstance(image, Image.Image):
-                return image
-            elif isinstance(image, (str, Path)):
-                return ImageHandler.convert_to_rgb(image)
-            else:
-                raise ValueError("Formato de imagem não suportado")
-                
-        except Exception as e:
-            logger.error(f"Error processing image: {str(e)}")
-            raise ValueError(f"Erro no processamento da imagem: {str(e)}")
+            img = Image.open(input_path)
+            img = img.convert('RGB')
+            img.save(output_path, 'JPEG')
+            return True
+        except:
+            return False
+    
+    @staticmethod
+    def _try_opencv(input_path, output_path):
+        """Tenta converter usando OpenCV"""
+        try:
+            img = cv2.imread(str(input_path))
+            if img is None:
+                return False
+            cv2.imwrite(str(output_path), img)
+            return True
+        except:
+            return False
+    
+    @staticmethod
+    def _try_imagemagick(input_path, output_path):
+        """Tenta converter usando ImageMagick"""
+        try:
+            result = subprocess.run(
+                ['convert', str(input_path), str(output_path)],
+                capture_output=True,
+                text=True
+            )
+            return result.returncode == 0
+        except:
+            return False
+    
+    @staticmethod
+    def _try_ffmpeg(input_path, output_path):
+        """Tenta converter usando FFmpeg"""
+        try:
+            result = subprocess.run(
+                ['ffmpeg', '-i', str(input_path), '-y', str(output_path)],
+                capture_output=True,
+                text=True
+            )
+            return result.returncode == 0
+        except:
+            return False
 
 class NutritionalAnalyzer:
     def __init__(self):
         self.device = "cuda" if torch.cuda.is_available() else "cpu"
         self.models = {}
         self.processors = {}
-        self.image_handler = ImageHandler()
+        self.image_processor = ForceImageProcessor()
         
-    def initialize_model(self, model_name):
-        """Initialize a specific model with error handling and caching"""
+    async def initialize_model(self, model_name):
+        """Inicializa modelo com tratamento de erros melhorado"""
         try:
             if model_name not in self.models:
-                logger.info(f"Initializing {model_name}...")
+                logger.info(f"Inicializando {model_name}...")
                 
-                # Model-specific configurations
                 model_configs = {
                     "llava": {
                         "repo": "llava-hf/llava-1.5-7b-hf",
@@ -90,124 +126,132 @@ class NutritionalAnalyzer:
                 if not config:
                     raise ValueError(f"Modelo não suportado: {model_name}")
                 
-                # Ensure cache directory exists
+                # Garante que o diretório de cache existe
                 os.makedirs(config["local_cache"], exist_ok=True)
                 
-                # Download model if not cached
-                if not os.path.exists(os.path.join(config["local_cache"], "model.safetensors")):
-                    snapshot_download(
-                        repo_id=config["repo"],
-                        local_dir=config["local_cache"],
-                        ignore_patterns=["*.md", "*.txt"]
+                # Carrega processador e modelo
+                try:
+                    self.processors[model_name] = await gr.asyncio.asyncio.to_thread(
+                        AutoProcessor.from_pretrained,
+                        config["repo"],
+                        trust_remote_code=True
                     )
+                    
+                    self.models[model_name] = await gr.asyncio.asyncio.to_thread(
+                        AutoModelForVision2Seq.from_pretrained,
+                        config["repo"],
+                        torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                        device_map="auto",
+                        trust_remote_code=True
+                    )
+                except Exception as e:
+                    logger.error(f"Erro ao carregar modelo: {str(e)}")
+                    raise
                 
-                # Load processor and model
-                self.processors[model_name] = AutoProcessor.from_pretrained(
-                    config["local_cache"],
-                    local_files_only=True
-                )
-                
-                self.models[model_name] = AutoModelForVision2Seq.from_pretrained(
-                    config["local_cache"],
-                    torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
-                    device_map="auto",
-                    local_files_only=True
-                )
-                
-                logger.info(f"{model_name} initialized successfully")
+                logger.info(f"{model_name} inicializado com sucesso")
                 return True
             
             return True
             
         except Exception as e:
-            logger.error(f"Error initializing {model_name}: {str(e)}")
+            logger.error(f"Erro na inicialização do {model_name}: {str(e)}")
             return False
 
-    def generate_nutritional_prompt(self, user_question):
-        """Generate a comprehensive nutritional analysis prompt"""
-        return f"""Como nutricionista especializado, analise esta refeição detalhadamente:
-
-1. Composição do Prato:
-   - Ingredientes principais
-   - Proporções aproximadas
-   - Método de preparo aparente
-
-2. Análise Nutricional:
-   - Estimativa calórica
-   - Macronutrientes (proteínas, carboidratos, gorduras)
-   - Principais micronutrientes
-
-3. Recomendações:
-   - Sugestões para versão mais saudável
-   - Porção recomendada
-   - Adequação para dietas específicas
-
-Pergunta específica do usuário: {user_question}
-
-Por favor, forneça uma análise detalhada em português."""
-
-    def analyze_image(self, image, question, model_choice):
-        """Analyze image with nutritional focus"""
+    async def analyze_image(self, image, question, model_choice):
+        """Analisa imagem com foco nutricional"""
         try:
             if image is None:
-                return "Por favor, faça upload de uma imagem para análise."
+                return "Por favor, envie uma imagem para análise."
 
-            # Convert model choice to internal name
+            # Converte escolha do modelo
             model_name = model_choice.lower().replace("-", "")
             
-            # Initialize model if needed
-            if not self.initialize_model(model_name):
-                return "Erro: Não foi possível inicializar o modelo. Por favor, tente novamente."
+            # Inicializa modelo
+            if not await self.initialize_model(model_name):
+                return "Erro: Falha ao inicializar o modelo. Tente novamente."
             
-            # Process image with enhanced error handling
+            # Processa imagem com conversão forçada
             try:
-                processed_image = self.image_handler.process_image(image)
-            except ValueError as e:
-                return str(e)
+                with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as temp_file:
+                    if isinstance(image, np.ndarray):
+                        cv2.imwrite(temp_file.name, cv2.cvtColor(image, cv2.COLOR_RGB2BGR))
+                    else:
+                        shutil.copy2(image, temp_file.name)
+                    
+                    processed_image = await gr.asyncio.asyncio.to_thread(
+                        self.image_processor.force_convert_image,
+                        temp_file.name
+                    )
             except Exception as e:
-                return f"Erro no processamento da imagem: {str(e)}"
-
-            # Generate and process prompt
+                logger.error(f"Erro no processamento da imagem: {str(e)}")
+                return f"Erro ao processar imagem: {str(e)}"
+            
+            # Gera prompt
             nutritional_prompt = self.generate_nutritional_prompt(question)
             
-            # Process input
+            # Processa input
             try:
-                inputs = self.processors[model_name](
+                inputs = await gr.asyncio.asyncio.to_thread(
+                    self.processors[model_name],
                     images=processed_image,
                     text=nutritional_prompt,
                     return_tensors="pt"
-                ).to(self.device)
+                )
+                inputs = {k: v.to(self.device) for k, v in inputs.items()}
             except Exception as e:
-                return f"Erro no processamento do modelo: {str(e)}"
+                return f"Erro no processamento: {str(e)}"
             
-            # Generate response with enhanced parameters
+            # Gera resposta
             try:
                 with torch.no_grad():
-                    outputs = self.models[model_name].generate(
+                    outputs = await gr.asyncio.asyncio.to_thread(
+                        self.models[model_name].generate,
                         **inputs,
                         max_new_tokens=300,
                         num_beams=5,
+                        do_sample=True,  # Habilitado para usar temperature e top_p
                         temperature=0.7,
                         top_p=0.9,
                         repetition_penalty=1.2,
-                        length_penalty=1.0
+                        no_repeat_ngram_size=3,  # Evita repetições de frases
+                        early_stopping=True  # Para quando a geração estiver completa
                     )
                 
-                # Decode and format response
                 response = self.processors[model_name].decode(outputs[0], skip_special_tokens=True)
-                formatted_response = self.format_response(response)
-                
-                return formatted_response
+                return self.format_response(response)
             
             except Exception as e:
                 return f"Erro na geração da análise: {str(e)}"
             
         except Exception as e:
-            logger.error(f"Analysis error: {str(e)}")
-            return f"Erro na análise: {str(e)}\nPor favor, tente novamente ou escolha outro modelo."
+            logger.error(f"Erro na análise: {str(e)}")
+            return f"Erro: {str(e)}\nPor favor, tente novamente."
+        
+    def generate_nutritional_prompt(self, question):
+        """Gera prompt para análise nutricional"""
+        return f"""Como nutricionista especializado, analise esta refeição detalhadamente:
+
+1. Composição do Prato:
+   - Ingredientes principais
+   - Proporções aproximadas
+   - Método de preparo aparente
+
+2. Análise Nutricional:
+   - Estimativa calórica
+   - Macronutrientes (proteínas, carboidratos, gorduras)
+   - Principais micronutrientes
+
+3. Recomendações:
+   - Sugestões para versão mais saudável
+   - Porção recomendada
+   - Adequação para dietas específicas
+
+Pergunta específica do usuário: {question}
+
+Por favor, forneça uma análise detalhada em português."""
 
     def format_response(self, response):
-        """Format the response for better readability"""
+        """Formata a resposta para melhor legibilidade"""
         sections = [
             "Composição do Prato",
             "Análise Nutricional",
@@ -215,20 +259,15 @@ Por favor, forneça uma análise detalhada em português."""
         ]
         
         formatted = "# 📊 Análise Nutricional\n\n"
-        
-        # Split response into paragraphs
-        paragraphs = response.split("\n")
-        
         current_section = ""
-        for paragraph in paragraphs:
-            # Check if paragraph starts a new section
+        
+        for paragraph in response.split("\n"):
             for section in sections:
                 if section.lower() in paragraph.lower():
                     current_section = f"\n## {section}\n"
                     formatted += current_section
                     break
             
-            # Add paragraph to current section
             if paragraph.strip() and current_section:
                 formatted += f"- {paragraph.strip()}\n"
             elif paragraph.strip():
@@ -236,20 +275,20 @@ Por favor, forneça uma análise detalhada em português."""
         
         return formatted
 
-# Create interface
 def create_interface():
+    """Cria interface Gradio"""
     analyzer = NutritionalAnalyzer()
     
     with gr.Blocks(theme=gr.themes.Soft()) as iface:
         gr.Markdown("""
         # 🥗 Análise Nutricional Inteligente
-        Faça upload da foto do seu prato para receber uma análise nutricional detalhada.
+        Upload da foto do seu prato para análise nutricional detalhada.
         """)
         
         with gr.Row():
             with gr.Column(scale=2):
                 image_input = gr.Image(
-                    type="pil",
+                    type="filepath",  # Mudado para filepath para melhor compatibilidade
                     label="📸 Foto do Prato",
                     height=400
                 )
@@ -263,33 +302,31 @@ def create_interface():
                 model_choice = gr.Radio(
                     choices=["LLaVA", "GIT"],
                     value="LLaVA",
-                    label="🤖 Escolha o Modelo de Análise"
+                    label="🤖 Escolha o Modelo"
                 )
                 
                 analyze_btn = gr.Button(
                     "🔍 Analisar Prato",
-                    variant="primary",
-                    scale=1
+                    variant="primary"
                 )
             
             with gr.Column(scale=3):
                 output = gr.Markdown(label="Resultado da Análise")
         
-        # Add examples and tips
-        with gr.Accordion("💡 Dicas de Uso", open=False):
+        with gr.Accordion("💡 Dicas", open=False):
             gr.Markdown("""
-            ### Sugestões de Perguntas:
-            - Qual o valor nutricional aproximado deste prato?
-            - Como tornar esta refeição mais equilibrada?
-            - Este prato é adequado para dieta low-carb?
-            - Quais nutrientes importantes estão presentes?
+            ### Formatos Suportados:
+            - JPG/JPEG
+            - PNG
+            - WEBP
+            - AVIF
+            - Outros formatos de imagem comuns
             
-            ### Dicas para Melhores Resultados:
-            1. Tire a foto com boa iluminação
-            2. Capture todos os elementos do prato
+            ### Para Melhores Resultados:
+            1. Boa iluminação na foto
+            2. Capture todo o prato
             3. Evite ângulos muito inclinados
-            4. Seja específico em suas perguntas
-            5. Formatos de imagem suportados: JPG, PNG, WEBP
+            4. Perguntas específicas ajudam
             """)
         
         analyze_btn.click(
@@ -302,4 +339,10 @@ def create_interface():
 
 if __name__ == "__main__":
     iface = create_interface()
-    iface.launch()
+    iface.launch(
+        share=False,
+        debug=True,
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )