Update app.py

app.py

@@ -1,52 +1,11 @@
 import gradio as gr
-from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
-from transformers import MarianMTModel, MarianTokenizer
-from diffusers import StableDiffusionPipeline
-import torch
+from transformers import pipeline
 import numpy as np
-from PIL import Image
-import spacy
 
-class AIServices:
+class LightAIServices:
     def __init__(self):
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.image_generator = None
-        self.translator = None
         self.sentiment_analyzer = None
-        self.summarizer = None
-        self.ner_model = None
-        self.classifier = None
-
-    def load_image_generator(self):
-        if self.image_generator is None:
-            model_id = "CompVis/stable-diffusion-v1-4"
-            self.image_generator = StableDiffusionPipeline.from_pretrained(
-                model_id,
-                torch_dtype=torch.float32
-            ).to(self.device)
-        return self.image_generator
-
-    def generate_image(self, prompt, num_images=1):
-        try:
-            generator = self.load_image_generator()
-            images = generator(
-                prompt,
-                num_images_per_prompt=num_images,
-                guidance_scale=7.5
-            ).images
-            return images[0] if num_images == 1 else images
-        except Exception as e:
-            return f"Erro na geração de imagem: {str(e)}"
-
-    def translate(self, text, src_lang, tgt_lang):
-        if self.translator is None:
-            model_name = f'Helsinki-NLP/opus-mt-{src_lang}-{tgt_lang}'
-            self.translator = pipeline('translation', model=model_name)
-        try:
-            result = self.translator(text)[0]['translation_text']
-            return result
-        except Exception as e:
-            return f"Erro na tradução: {str(e)}"
+        self.text_classifier = None
 
     def analyze_sentiment(self, text):
         if self.sentiment_analyzer is None:
@@ -60,134 +19,101 @@ class AIServices:
         except Exception as e:
             return f"Erro na análise: {str(e)}"
 
-    def summarize_text(self, text, max_length=150, min_length=50):
-        if self.summarizer is None:
-            self.summarizer = pipeline('summarization', model='facebook/bart-large-cnn')
+    def classify_text(self, text):
         try:
-            summary = self.summarizer(text, max_length=max_length, min_length=min_length)[0]
-            return summary['summary_text']
+            if self.text_classifier is None:
+                self.text_classifier = pipeline(
+                    "text-classification",
+                    model="bert-base-uncased"
+                )
+            
+            result = self.text_classifier(text)[0]
+            return f"Classificação: {result['label']}\nConfiança: {result['score']:.2f}"
         except Exception as e:
-            return f"Erro ao resumir: {str(e)}"
+            return f"Erro na classificação: {str(e)}"
 
-    def extract_entities(self, text):
+    def analyze_text_length(self, text):
         try:
-            if self.ner_model is None:
-                self.ner_model = spacy.load("pt_core_news_sm")
+            words = text.split()
+            characters = len(text)
+            sentences = text.count('.') + text.count('!') + text.count('?')
             
-            doc = self.ner_model(text)
-            entities = []
+            return f"""📊 Análise do Texto:
+            • Palavras: {len(words)}
+            • Caracteres: {characters}
+            • Sentenças: {sentences}
+            • Média de palavras por sentença: {len(words)/max(1,sentences):.1f}"""
+        except Exception as e:
+            return f"Erro na análise: {str(e)}"
+
+    def analyze_text_stats(self, text):
+        try:
+            # Contagem básica
+            total_chars = len(text)
+            total_words = len(text.split())
+            
+            # Contagem de tipos de caracteres
+            uppercase = sum(1 for c in text if c.isupper())
+            lowercase = sum(1 for c in text if c.islower())
+            digits = sum(1 for c in text if c.isdigit())
+            spaces = sum(1 for c in text if c.isspace())
             
-            for ent in doc.ents:
-                entities.append({
-                    'text': ent.text,
-                    'label': ent.label_,
-                    'start': ent.start_char,
-                    'end': ent.end_char
-                })
+            # Palavras únicas
+            unique_words = len(set(text.lower().split()))
             
-            # Formatando a saída
-            result = ""
-            for e in entities:
-                result += f"📌 {e['text']} ({e['label']})\n"
+            return f"""📊 Estatísticas Detalhadas:
             
-            return result if result else "Nenhuma entidade encontrada."
+            Contagens Básicas:
+            • Total de caracteres: {total_chars}
+            • Total de palavras: {total_words}
+            • Palavras únicas: {unique_words}
+            
+            Tipos de Caracteres:
+            • Maiúsculas: {uppercase}
+            • Minúsculas: {lowercase}
+            • Dígitos: {digits}
+            • Espaços: {spaces}
+            
+            Proporções:
+            • Diversidade de vocabulário: {unique_words/total_words:.2%}
+            • Densidade de caracteres: {total_chars/total_words:.1f} caracteres/palavra"""
         except Exception as e:
-            return f"Erro na extração de entidades: {str(e)}"
+            return f"Erro na análise: {str(e)}"
 
-    def classify_text(self, text):
-        if self.classifier is None:
-            self.classifier = pipeline(
-                "zero-shot-classification",
-                model="facebook/bart-large-mnli"
-            )
+    def text_similarity(self, text1, text2):
         try:
-            # Categorias predefinidas
-            candidate_labels = [
-                "negócios", "tecnologia", "política", 
-                "entretenimento", "esportes", "ciência",
-                "saúde", "educação"
-            ]
+            # Análise básica de similaridade
+            words1 = set(text1.lower().split())
+            words2 = set(text2.lower().split())
+            
+            # Intersecção de palavras
+            common_words = words1.intersection(words2)
             
-            result = self.classifier(text, candidate_labels, multi_label=True)
+            # Métricas de similaridade
+            similarity = len(common_words) / max(len(words1), len(words2))
             
-            # Formatando a saída
-            output = "🏷️ Classificação:\n"
-            for label, score in zip(result['labels'], result['scores']):
-                if score > 0.1:  # Mostra apenas scores relevantes
-                    output += f"{label}: {score:.1%}\n"
+            return f"""🔄 Análise de Similaridade:
             
-            return output
+            • Palavras em comum: {len(common_words)}
+            • Similaridade: {similarity:.1%}
+            • Palavras texto 1: {len(words1)}
+            • Palavras texto 2: {len(words2)}
+            • Palavras em comum: {', '.join(list(common_words)[:10])}"""
         except Exception as e:
-            return f"Erro na classificação: {str(e)}"
+            return f"Erro na análise de similaridade: {str(e)}"
 
 # Instância global dos serviços
-services = AIServices()
+services = LightAIServices()
 
 # Interface Gradio
-with gr.Blocks(title="Hub de Serviços de IA") as demo:
+with gr.Blocks(title="Análise de Texto") as demo:
     gr.Markdown("""
-    # 🤖 Hub de Serviços de IA
+    # 📝 Hub de Análise de Texto
     
-    Esta aplicação oferece diversos serviços de IA para processamento de texto e imagem.
+    Serviços de processamento e análise de texto usando IA.
     """)
     
-    # 1. Geração de Imagem
-    with gr.Tab("Geração de Imagem"):
-        gr.Markdown("### 🎨 Gerador de Imagens com Stable Diffusion")
-        with gr.Row():
-            img_prompt = gr.Textbox(
-                label="Descrição da imagem",
-                placeholder="Descreva a imagem que deseja gerar...",
-                lines=3
-            )
-            img_output = gr.Image(label="Imagem Gerada")
-        with gr.Row():
-            img_num = gr.Slider(
-                minimum=1,
-                maximum=4,
-                value=1,
-                step=1,
-                label="Número de imagens"
-            )
-        img_button = gr.Button("🎨 Gerar Imagem")
-        img_button.click(
-            services.generate_image,
-            inputs=[img_prompt, img_num],
-            outputs=img_output
-        )
-    
-    # 2. Tradução
-    with gr.Tab("Tradutor"):
-        gr.Markdown("### 🌐 Tradutor Multilíngue")
-        with gr.Row():
-            trans_input = gr.Textbox(
-                label="Texto para traduzir",
-                placeholder="Digite o texto aqui...",
-                lines=3
-            )
-            trans_output = gr.Textbox(
-                label="Tradução",
-                lines=3
-            )
-        with gr.Row():
-            src_lang = gr.Dropdown(
-                choices=["en", "pt", "es", "fr", "de"],
-                value="en",
-                label="Idioma de origem"
-            )
-            tgt_lang = gr.Dropdown(
-                choices=["pt", "en", "es", "fr", "de"],
-                value="pt",
-                label="Idioma de destino"
-            )
-        trans_button = gr.Button("🔄 Traduzir")
-        trans_button.click(
-            services.translate,
-            inputs=[trans_input, src_lang, tgt_lang],
-            outputs=trans_output
-        )
-    
-    # 3. Análise de Sentimentos
+    # 1. Análise de Sentimentos
     with gr.Tab("Análise de Sentimentos"):
         gr.Markdown("### 😊 Análise de Sentimentos")
         with gr.Row():
@@ -207,87 +133,96 @@ with gr.Blocks(title="Hub de Serviços de IA") as demo:
             outputs=sent_output
         )
 
-    # 4. Resumo de Texto
-    with gr.Tab("Resumo"):
-        gr.Markdown("### 📝 Resumo Automático de Texto")
+    # 2. Classificação
+    with gr.Tab("Classificação"):
+        gr.Markdown("### 📋 Classificação de Texto")
         with gr.Row():
-            sum_input = gr.Textbox(
-                label="Texto para resumir",
-                placeholder="Cole aqui o texto que deseja resumir...",
-                lines=8
+            class_input = gr.Textbox(
+                label="Texto para classificar",
+                placeholder="Digite o texto para classificar...",
+                lines=5
             )
-            sum_output = gr.Textbox(
-                label="Resumo",
-                lines=4
+            class_output = gr.Textbox(
+                label="Classificação",
+                lines=2
             )
+        class_button = gr.Button("🏷️ Classificar Texto")
+        class_button.click(
+            services.classify_text,
+            inputs=class_input,
+            outputs=class_output
+        )
+
+    # 3. Análise de Comprimento
+    with gr.Tab("Análise de Comprimento"):
+        gr.Markdown("### 📏 Análise de Comprimento do Texto")
         with gr.Row():
-            max_len = gr.Slider(
-                minimum=50,
-                maximum=500,
-                value=150,
-                step=10,
-                label="Tamanho máximo do resumo"
+            len_input = gr.Textbox(
+                label="Texto para análise",
+                placeholder="Digite ou cole o texto para analisar...",
+                lines=5
             )
-            min_len = gr.Slider(
-                minimum=30,
-                maximum=200,
-                value=50,
-                step=10,
-                label="Tamanho mínimo do resumo"
+            len_output = gr.Textbox(
+                label="Estatísticas",
+                lines=5
             )
-        sum_button = gr.Button("📚 Gerar Resumo")
-        sum_button.click(
-            services.summarize_text,
-            inputs=[sum_input, max_len, min_len],
-            outputs=sum_output
+        len_button = gr.Button("📏 Analisar Comprimento")
+        len_button.click(
+            services.analyze_text_length,
+            inputs=len_input,
+            outputs=len_output
         )
 
-    # 5. Extração de Entidades
-    with gr.Tab("Entidades"):
-        gr.Markdown("### 🔍 Reconhecimento de Entidades")
+    # 4. Estatísticas Detalhadas
+    with gr.Tab("Estatísticas"):
+        gr.Markdown("### 📊 Estatísticas Detalhadas do Texto")
         with gr.Row():
-            ner_input = gr.Textbox(
+            stats_input = gr.Textbox(
                 label="Texto para análise",
-                placeholder="Digite o texto para extrair entidades...",
+                placeholder="Digite ou cole o texto para análise detalhada...",
                 lines=5
             )
-            ner_output = gr.Textbox(
-                label="Entidades encontradas",
-                lines=5
+            stats_output = gr.Textbox(
+                label="Estatísticas Detalhadas",
+                lines=10
             )
-        ner_button = gr.Button("🎯 Extrair Entidades")
-        ner_button.click(
-            services.extract_entities,
-            inputs=ner_input,
-            outputs=ner_output
+        stats_button = gr.Button("📊 Analisar Estatísticas")
+        stats_button.click(
+            services.analyze_text_stats,
+            inputs=stats_input,
+            outputs=stats_output
         )
 
-    # 6. Classificação de Texto
-    with gr.Tab("Classificação"):
-        gr.Markdown("### 📋 Classificação de Texto")
+    # 5. Comparação de Textos
+    with gr.Tab("Comparação"):
+        gr.Markdown("### 🔄 Comparação de Textos")
         with gr.Row():
-            class_input = gr.Textbox(
-                label="Texto para classificar",
-                placeholder="Digite o texto para classificar...",
-                lines=5
+            comp_input1 = gr.Textbox(
+                label="Primeiro texto",
+                placeholder="Digite o primeiro texto...",
+                lines=3
             )
-            class_output = gr.Textbox(
-                label="Classificação",
-                lines=5
+            comp_input2 = gr.Textbox(
+                label="Segundo texto",
+                placeholder="Digite o segundo texto...",
+                lines=3
             )
-        class_button = gr.Button("🏷️ Classificar Texto")
-        class_button.click(
-            services.classify_text,
-            inputs=class_input,
-            outputs=class_output
+        comp_output = gr.Textbox(
+            label="Resultado da comparação",
+            lines=6
+        )
+        comp_button = gr.Button("🔄 Comparar Textos")
+        comp_button.click(
+            services.text_similarity,
+            inputs=[comp_input1, comp_input2],
+            outputs=comp_output
         )
 
     gr.Markdown("""
     ### 📝 Notas:
-    - A geração de imagens requer GPU para melhor performance
-    - Os modelos são carregados sob demanda para economizar memória
-    - Primeira execução pode ser mais lenta devido ao download dos modelos
-    - Todos os modelos são open source
+    - Todos os serviços funcionam localmente
+    - Análises rápidas e eficientes
+    - Suporte para textos em português e inglês
     """)
 
 if __name__ == "__main__":