Update app.py

app.py

@@ -1,319 +1,92 @@
 import gradio as gr
-from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
+from transformers import AutoTokenizer, AutoModelForCausalLM
 import torch
-import time
-import threading
-from collections import deque
+import os
 
-# === Modelos otimizados para velocidade ===
-MODEL_OPTIONS = {
-    "Microsoft DialoGPT": "microsoft/DialoGPT-small",  # Otimizado para conversas
-    "DistilGPT2": "distilgpt2",  # Backup rápido
-    "GPT2 Small": "gpt2"  # Fallback
-}
+# Model configuration: Qwen2.5-0.5B-Instruct (lightweight, PT-BR optimized)
+MODEL_NAME = "Qwen/Qwen2.5-0.5B-Instruct"
+USE_QUANTIZATION = True  # Enable 4-bit quantization for speed and low memory
 
-# === Configurações otimizadas ===
-MODEL_NAME = MODEL_OPTIONS["Microsoft DialoGPT"]
-CACHE_SIZE = 50  # Cache das últimas respostas
-MAX_TOKENS = 100  # Reduzido para velocidade
-TEMPERATURE = 0.8  # Aumentado para criatividade
-
-# === Cache para respostas frequentes ===
-response_cache = {}
-recent_questions = deque(maxlen=CACHE_SIZE)
-
-# === Respostas pré-definidas para perguntas comuns ===
-QUICK_RESPONSES = {
-    "ponteiros": """**Ponteiros em C** são variáveis que armazenam endereços de memória.
-
-**Exemplo básico:**
-```c
-int x = 10;
-int *ptr = &x;  // ptr aponta para x
-printf("%d", *ptr);  // Imprime 10
-```
-
-**Usos principais:**
-- Passagem por referência
-- Alocação dinâmica de memória
-- Estruturas de dados (listas, árvores)""",
-    
-    "java equals": """**Diferença entre == e equals() em Java:**
-
-**==** compara referências (endereços na memória)
-**equals()** compara conteúdo dos objetos
-
-**Exemplo:**
-```java
-String a = new String("Hello");
-String b = new String("Hello");
-System.out.println(a == b);      // false
-System.out.println(a.equals(b)); // true
-```""",
-    
-    "machine learning": """**Machine Learning** é um subcampo da IA onde máquinas aprendem padrões a partir de dados.
-
-**Tipos principais:**
-1. **Supervisionado**: Aprende com exemplos rotulados
-2. **Não-supervisionado**: Encontra padrões em dados
-3. **Por reforço**: Aprende através de tentativa e erro
-
-**Aplicações**: Reconhecimento de imagem, processamento de linguagem, recomendações.""",
-    
-    "html css javascript": """**Tecnologias Web Fundamentais:**
-
-**HTML**: Estrutura da página (esqueleto)
-**CSS**: Estilização e layout (aparência)
-**JavaScript**: Interatividade e lógica (comportamento)
-
-**Analogia**: 
-- HTML = Estrutura da casa
-- CSS = Decoração e pintura
-- JavaScript = Eletricidade e automação""",
-    
-    "algoritmos ordenação": """**Algoritmos de Ordenação:**
-
-**Bubble Sort**: O(n²) - Simples, mas lento
-**Quick Sort**: O(n log n) - Rápido e eficiente
-**Merge Sort**: O(n log n) - Estável e confiável
+# Load model and tokenizer
+def load_model():
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+        model_config = {
+            "pretrained_model_name_or_path": MODEL_NAME,
+            "torch_dtype": torch.bfloat16,
+        }
+        if USE_QUANTIZATION and torch.cuda.is_available():
+            from transformers import BitsAndBytesConfig
+            model_config["quantization_config"] = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_compute_dtype=torch.bfloat16,
+                bnb_4bit_quant_type="nf4",
+                bnb_4bit_use_double_quant=True
+            )
+            model_config["device_map"] = "auto"  # Requires accelerate
+        else:
+            model_config["device"] = "cpu"  # Fallback to CPU if no GPU or accelerate
+        model = AutoModelForCausalLM.from_pretrained(**model_config)
+        return model, tokenizer
+    except Exception as e:
+        raise gr.Error(f"Erro ao carregar o modelo: {str(e)}")
 
-**Exemplo Quick Sort:**
-```c
-void quickSort(int arr[], int low, int high) {
-    if (low < high) {
-        int pi = partition(arr, low, high);
-        quickSort(arr, low, pi - 1);
-        quickSort(arr, pi + 1, high);
-    }
-}
-```"""
-}
+model, tokenizer = load_model()
 
-def get_quick_response(pergunta):
-    """Verifica se há uma resposta rápida para a pergunta"""
-    pergunta_lower = pergunta.lower()
-    
-    for keyword, response in QUICK_RESPONSES.items():
-        if keyword in pergunta_lower:
-            return response
-    return None
-
-def load_model_optimized():
-    """Carrega modelo com configurações otimizadas"""
+# Main function for generating responses
+def responder_como_aldo(pergunta):
     try:
-        print(f"🚀 Carregando modelo otimizado: {MODEL_NAME}")
-        
-        # Carrega com configurações de velocidade
-        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, padding_side='left')
-        if tokenizer.pad_token is None:
-            tokenizer.pad_token = tokenizer.eos_token
-            
-        model = AutoModelForCausalLM.from_pretrained(
-            MODEL_NAME,
-            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-            low_cpu_mem_usage=True
-        )
-        
-        # Pipeline otimizado
-        gerador = pipeline(
-            "text-generation",
-            model=model,
-            tokenizer=tokenizer,
-            device=0 if torch.cuda.is_available() else -1,
-            max_new_tokens=MAX_TOKENS,
-            temperature=TEMPERATURE,
+        # Format prompt using chat template
+        messages = [
+            {"role": "system", "content": "Você é o professor Dr. Aldo Henrique, especialista em C, Java, desenvolvimento web e inteligência artificial. Responda com clareza, profundidade e tom acadêmico, como um professor experiente. Evite respostas genéricas e forneça exemplos práticos, se aplicável."},
+            {"role": "user", "content": pergunta}
+        ]
+        input_text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+        inputs = tokenizer(input_text, return_tensors="pt").to(model.device)
+
+        # Generate response
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=100,  # Reduced for faster responses
+            temperature=0.7,
             top_p=0.9,
             do_sample=True,
             pad_token_id=tokenizer.eos_token_id
         )
-        
-        print("✅ Modelo carregado com sucesso!")
-        return gerador, tokenizer
-        
-    except Exception as e:
-        print(f"❌ Erro ao carregar {MODEL_NAME}: {e}")
-        # Fallback para DistilGPT2
-        return load_fallback_model()
-
-def load_fallback_model():
-    """Carrega modelo de fallback"""
-    try:
-        print("🔄 Carregando modelo de fallback...")
-        fallback_name = MODEL_OPTIONS["DistilGPT2"]
-        
-        tokenizer = AutoTokenizer.from_pretrained(fallback_name)
-        if tokenizer.pad_token is None:
-            tokenizer.pad_token = tokenizer.eos_token
-            
-        model = AutoModelForCausalLM.from_pretrained(fallback_name)
-        
-        gerador = pipeline(
-            "text-generation",
-            model=model,
-            tokenizer=tokenizer,
-            device=-1,  # Força CPU para economia
-            max_new_tokens=MAX_TOKENS,
-            temperature=TEMPERATURE,
-            do_sample=True
-        )
-        
-        print("✅ Modelo de fallback carregado!")
-        return gerador, tokenizer
-        
+        resposta = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        return resposta.split("Resposta:")[-1].strip() if "Resposta:" in resposta else resposta.strip()
     except Exception as e:
-        raise Exception(f"Falha ao carregar qualquer modelo: {e}")
-
-# === Carrega modelo na inicialização ===
-gerador, tokenizer = load_model_optimized()
+        return f"Erro ao gerar resposta: {str(e)}"
 
-def responder_como_aldo(pergunta):
-    """Função principal otimizada"""
-    if not pergunta.strip():
-        return "Por favor, faça uma pergunta específica."
-    
-    start_time = time.time()
+# Gradio interface
+with gr.Blocks(title="Pergunte ao Dr. Aldo Henrique") as interface:
+    gr.Markdown("## 🤖 Pergunte ao Dr. Aldo Henrique")
+    gr.Markdown(f"**Modelo carregado:** {MODEL_NAME} (leve e otimizado para PT-BR)")
+    gr.Markdown("Dúvidas sobre C, Java, desenvolvimento web ou IA? O Dr. Aldo responde com clareza e profundidade.")
     
-    # 1. Verifica cache de respostas rápidas
-    quick_response = get_quick_response(pergunta)
-    if quick_response:
-        return f"📚 **Resposta Rápida do Dr. Aldo:**\n\n{quick_response}"
+    with gr.Row():
+        entrada = gr.Textbox(label="Pergunta", placeholder="Ex: Como usar ponteiros em C?", lines=4)
+        saida = gr.Textbox(label="Resposta do Dr. Aldo", lines=8, interactive=False)
     
-    # 2. Verifica cache de respostas anteriores
-    pergunta_hash = hash(pergunta.lower().strip())
-    if pergunta_hash in response_cache:
-        cached_response = response_cache[pergunta_hash]
-        return f"💾 **Dr. Aldo responde:**\n\n{cached_response}"
-    
-    # 3. Gera nova resposta
-    try:
-        # Prompt otimizado e conciso
-        if "DialoGPT" in MODEL_NAME:
-            prompt = f"Professor: {pergunta}\nDr. Aldo:"
-        else:
-            prompt = f"Pergunta: {pergunta}\nDr. Aldo Henrique responde:"
-        
-        # Geração com timeout implícito
-        response = gerador(
-            prompt,
-            max_new_tokens=MAX_TOKENS,
-            num_return_sequences=1,
-            truncation=True
-        )[0]["generated_text"]
-        
-        # Limpa resposta
-        if "Dr. Aldo:" in response:
-            resposta_limpa = response.split("Dr. Aldo:")[-1].strip()
-        elif "responde:" in response:
-            resposta_limpa = response.split("responde:")[-1].strip()
-        else:
-            resposta_limpa = response.replace(prompt, "").strip()
-        
-        # Remove repetições comuns
-        resposta_limpa = resposta_limpa.replace(pergunta, "").strip()
-        
-        if not resposta_limpa or len(resposta_limpa) < 10:
-            resposta_limpa = "Desculpe, não consegui gerar uma resposta adequada. Tente reformular sua pergunta."
-        
-        # Salva no cache
-        response_cache[pergunta_hash] = resposta_limpa
-        recent_questions.append(pergunta)
-        
-        elapsed_time = time.time() - start_time
-        
-        return f"🎓 **Dr. Aldo responde** ⚡ *({elapsed_time:.1f}s)*:\n\n{resposta_limpa}"
-        
-    except Exception as e:
-        return f"❌ **Erro temporário**: {str(e)}\n\nTente novamente ou reformule sua pergunta."
-
-# === Interface Gradio otimizada ===
-def create_interface():
-    with gr.Blocks(
-        title="Dr. Aldo Henrique - IA Educacional",
-        theme=gr.themes.Soft(),
-        css="""
-        .gradio-container { max-width: 900px; margin: auto; }
-        .output-text { font-family: 'Segoe UI', Arial, sans-serif; }
-        .quick-stats { background: #f0f0f0; padding: 10px; border-radius: 5px; }
-        """
-    ) as interface:
-        
-        gr.Markdown("""
-        # 🎓 Dr. Aldo Henrique - Professor Virtual
-        ### 💻 Especialista em C, Java, Web e Inteligência Artificial
-        """)
-        
-        with gr.Row():
-            gr.Markdown(f"""
-            <div class="quick-stats">
-            📊 <strong>Status:</strong> Modelo {MODEL_NAME.split('/')[-1]} carregado<br>
-            ⚡ <strong>Performance:</strong> Otimizado para respostas rápidas<br>
-            💾 <strong>Cache:</strong> {len(QUICK_RESPONSES)} respostas instantâneas
-            </div>
-            """)
-        
-        with gr.Row():
-            with gr.Column(scale=2):
-                entrada = gr.Textbox(
-                    label="🤔 Sua pergunta para o Dr. Aldo",
-                    placeholder="Ex: Como usar ponteiros em C? ou Explique machine learning",
-                    lines=3,
-                    max_lines=5
-                )
-                
-                with gr.Row():
-                    botao = gr.Button("🚀 Perguntar", variant="primary", size="lg")
-                    limpar = gr.Button("🗑️ Limpar", variant="secondary")
-            
-            with gr.Column(scale=3):
-                saida = gr.Textbox(
-                    label="💡 Resposta do Dr. Aldo",
-                    lines=12,
-                    max_lines=20,
-                    interactive=False,
-                    elem_classes=["output-text"]
-                )
-        
-        # Exemplos organizados por categoria
-        with gr.Accordion("📚 Exemplos de Perguntas", open=False):
-            gr.Examples(
-                examples=[
-                    ["Como usar ponteiros em C?"],
-                    ["Diferença entre == e equals() em Java"],
-                    ["O que é machine learning?"],
-                    ["Explique HTML, CSS e JavaScript"],
-                    ["Quais são os algoritmos de ordenação?"],
-                    ["Como implementar uma lista ligada?"],
-                    ["O que são estruturas de dados?"],
-                    ["Como funciona recursão?"],
-                    ["Diferença entre pilha e fila"],
-                    ["O que é programação orientada a objetos?"]
-                ],
-                inputs=entrada,
-                label="Clique em qualquer exemplo"
-            )
-        
-        # Eventos
-        botao.click(fn=responder_como_aldo, inputs=entrada, outputs=saida)
-        limpar.click(fn=lambda: ("", ""), outputs=[entrada, saida])
-        entrada.submit(fn=responder_como_aldo, inputs=entrada, outputs=saida)
-        
-        gr.Markdown("""
-        ---
-        <center>
-        ✨ <strong>Dica:</strong> Para respostas mais rápidas, use palavras-chave como "ponteiros", "java equals", "machine learning"<br>
-        🔧 <strong>Desenvolvido com:</strong> Transformers + Gradio | <strong>Otimizado para:</strong> Educação em Programação
-        </center>
-        """)
-    
-    return interface
-
-# === Lançamento ===
+    botao = gr.Button("Responder")
+    exemplos = gr.Examples(
+        examples=[
+            ["Como implementar uma lista ligada em C?"],
+            ["Qual a diferença entre == e equals() em Java?"],
+            ["Como funciona o machine learning?"],
+            ["Explique os conceitos de HTML, CSS e JavaScript"],
+            ["O que são algoritmos de ordenação?"]
+        ],
+        inputs=entrada
+    )
+    botao.click(fn=responder_como_aldo, inputs=entrada, outputs=saida)
+
+# Launch with optimized settings
 if __name__ == "__main__":
-    print("🎯 Iniciando Dr. Aldo Henrique - Versão Otimizada")
-    interface = create_interface()
     interface.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
-        show_error=True
+        queue_concurrency_count=2,  # Limit concurrent requests
+        max_threads=4  # Optimize for 2 vCPUs
     )