Create app.py

app.py

@@ -0,0 +1,136 @@
+import gradio as gr
+from transformers import (
+    AutoProcessor, 
+    AutoModelForVision2Seq, 
+    BlipProcessor, 
+    BlipForQuestionAnswering,
+    OFATokenizer, 
+    OFAModel
+)
+from PIL import Image
+import torch
+import warnings
+warnings.filterwarnings("ignore")
+
+class IridologyAnalyzer:
+    def __init__(self):
+        # Inicializar modelos
+        print("Carregando modelos...")
+        
+        # GIT model
+        self.git_processor = AutoProcessor.from_pretrained("microsoft/git-base-vqa")
+        self.git_model = AutoModelForVision2Seq.from_pretrained("microsoft/git-base-vqa")
+        
+        # BLIP model
+        self.blip_processor = BlipProcessor.from_pretrained("Salesforce/blip-vqa-base")
+        self.blip_model = BlipForQuestionAnswering.from_pretrained("Salesforce/blip-vqa-base")
+        
+        # OFA model
+        self.ofa_tokenizer = OFATokenizer.from_pretrained("OFA-Sys/ofa-base")
+        self.ofa_model = OFAModel.from_pretrained("OFA-Sys/ofa-base")
+        
+        # Perguntas predefinidas para análise de iridologia
+        self.iridology_questions = [
+            "What is the color pattern of the iris?",
+            "Are there any dark spots or marks in the iris?",
+            "What is the texture of the iris?",
+            "Are there any rings or circles in the iris?",
+            "What is the condition of the pupil?",
+            "Are there any lines radiating from the pupil?",
+            "Is there any discoloration in specific areas?",
+            "What is the overall clarity of the iris?"
+        ]
+        
+        print("Modelos carregados com sucesso!")
+
+    def analyze_with_git(self, image, question):
+        inputs = self.git_processor(images=image, text=question, return_tensors="pt")
+        outputs = self.git_model.generate(
+            **inputs,
+            max_length=50,
+            num_beams=4,
+            early_stopping=True
+        )
+        return self.git_processor.batch_decode(outputs, skip_special_tokens=True)[0]
+
+    def analyze_with_blip(self, image, question):
+        inputs = self.blip_processor(image, question, return_tensors="pt")
+        outputs = self.blip_model.generate(**inputs)
+        return self.blip_processor.decode(outputs[0], skip_special_tokens=True)
+
+    def analyze_with_ofa(self, image, question):
+        inputs = self.ofa_tokenizer([question], return_tensors="pt")
+        img = self.ofa_tokenizer(images=image, return_tensors="pt").pixel_values
+        
+        outputs = self.ofa_model.generate(
+            input_ids=inputs.input_ids,
+            pixel_values=img,
+            max_length=50,
+            num_beams=4
+        )
+        return self.ofa_tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]
+
+    def comprehensive_analysis(self, image):
+        """Realiza uma análise completa usando todos os modelos e questões predefinidas."""
+        results = []
+        
+        for question in self.iridology_questions:
+            # Análise com cada modelo
+            git_result = self.analyze_with_git(image, question)
+            blip_result = self.analyze_with_blip(image, question)
+            ofa_result = self.analyze_with_ofa(image, question)
+            
+            results.append({
+                "question": question,
+                "git_analysis": git_result,
+                "blip_analysis": blip_result,
+                "ofa_analysis": ofa_result
+            })
+        
+        # Formatar resultados
+        formatted_results = "Análise Detalhada de Iridologia:\n\n"
+        for result in results:
+            formatted_results += f"Pergunta: {result['question']}\n"
+            formatted_results += f"GIT: {result['git_analysis']}\n"
+            formatted_results += f"BLIP: {result['blip_analysis']}\n"
+            formatted_results += f"OFA: {result['ofa_analysis']}\n"
+            formatted_results += "-" * 50 + "\n"
+        
+        return formatted_results
+
+def create_gradio_interface():
+    analyzer = IridologyAnalyzer()
+    
+    def process_image(image):
+        if image is None:
+            return "Por favor, faça o upload de uma imagem."
+        
+        # Converter para PIL Image se necessário
+        if not isinstance(image, Image.Image):
+            image = Image.fromarray(image)
+        
+        # Realizar análise
+        try:
+            return analyzer.comprehensive_analysis(image)
+        except Exception as e:
+            return f"Erro durante a análise: {str(e)}"
+    
+    # Interface Gradio
+    iface = gr.Interface(
+        fn=process_image,
+        inputs=gr.Image(type="pil", label="Upload da Imagem do Olho"),
+        outputs=gr.Textbox(label="Resultados da Análise", lines=20),
+        title="Analisador de Iridologia com IA",
+        description="""
+        Este sistema analisa imagens de íris usando múltiplos modelos de IA para identificar padrões relevantes para iridologia.
+        Faça o upload de uma imagem clara do olho para análise.
+        """,
+        examples=[],
+        cache_examples=True
+    )
+    
+    return iface
+
+if __name__ == "__main__":
+    iface = create_gradio_interface()
+    iface.launch(share=True)