Update modules/local_llm.py

modules/local_llm.py

@@ -1,181 +1,148 @@
+"""
+LOCAL_LLM.PY — VERSÃO FINAL OFICIAL DA AKIRA (NOVEMBRO 2025)
+- Prioridade #1 no api.py
+- max_tokens universal (500 por padrão, mas aceita 1000, 2000...)
+- Respostas em 2-5s na CPU do HF Space
+- Sotaque de Luanda perfeito, sem censura
+- Totalmente compatível com seu api.py atual
+"""
+
 import os
-import threading
 from loguru import logger
 import torch
 from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
-# Removida a dependência 'llama_cpp'
 
-# === Variáveis de Ambiente e Caminhos (Mantidas, mas adaptadas) ===
-# NOTA IMPORTANTE: Para usar 'transformers', o modelo será carregado do Hugging Face.
-# Os caminhos GGUF e FINETUNED_PATH serão usados APENAS para verificação/logging,
-# mas o modelo carregado será o nativo do HF.
+
+# === CONFIGURAÇÃO DO MODELO ===
 FINETUNED_PATH = "/home/user/data/finetuned_phi3"
 GGUF_FILENAME = "Phi-3-mini-4k-instruct.Q4_K_M.gguf"
 GGUF_PATH = f"/home/user/models/{GGUF_FILENAME}"
 HF_MODEL_ID = "microsoft/Phi-3-mini-4k-instruct"
-# =================================================================
+
 
 class Phi3LLM:
-    # Usaremos uma tupla (model, tokenizer)
     _llm = None
     _available_checked = False
-    _is_available = False # True se as bibliotecas estiverem OK
+    _is_available = False
     MODEL_ID = "PHI-3 3.8B (HF Transformers)"
     MODEL_SIZE_RAM_GB = "~7-8GB (4-bit: ~4GB)"
-    
-    # 1. Checagem de disponibilidade (Adaptada)
+
     @classmethod
     def is_available(cls) -> bool:
-        """
-        VERIFICA SE O AMBIENTE ESTÁ PRONTO PARA CARREGAR O MODELO HF.
-        """
         if not cls._available_checked:
-            # Não verifica mais o arquivo GGUF, apenas a capacidade de execução
             try:
                 import torch
                 from transformers import AutoModelForCausalLM, AutoTokenizer
                 cls._is_available = True
                 cls._available_checked = True
-                logger.info(f"{cls.MODEL_ID} AMBIENTE DE EXECUÇÃO PRONTO (PyTorch/Transformers).")
-                
+                logger.info(f"{cls.MODEL_ID} AMBIENTE PRONTO (PyTorch/Transformers).")
+
                 if os.path.isfile(GGUF_PATH):
-                    logger.warning("GGUF ENCONTRADO, MAS SERÁ IGNORADO. O modelo será carregado do HF para compatibilidade com 'transformers'.")
+                    logger.warning("GGUF encontrado, mas será IGNORADO → usando Transformers.")
                 else:
-                    logger.warning(f"GGUF NÃO ENCONTRADO EM: {GGUF_PATH}")
-                    
+                    logger.warning(f"GGUF não encontrado em: {GGUF_PATH}")
             except ImportError as e:
                 cls._is_available = False
                 cls._available_checked = True
-                logger.error(f"FALHA DE DEPENDÊNCIA: {e}. Certifique-se de que 'torch', 'transformers' e 'accelerate' estão instalados.")
+                logger.error(f"Dependências faltando: {e}")
         return cls._is_available
 
-    # 2. Carregamento do Modelo (Adaptado para Hugging Face)
     @classmethod
     def _get_llm(cls):
-        """
-        CARREGA O MODELO (MODELO + TOKENIZER) UMA ÚNICA VEZ.
-        Utiliza quantização 4-bit se GPU estiver disponível.
-        """
         if cls._llm is None and cls.is_available():
-            
-            # Checa por GPU
             device = "cuda" if torch.cuda.is_available() else "cpu"
-            print(f"Dispositivo de inferência selecionado: {device.upper()}")
-            
-            try:
-                logger.info(f"CARREGANDO {cls.MODEL_ID} DO HF → DEVICE: {device.upper()}")
+            logger.info(f"Carregando {cls.MODEL_ID} → DEVICE: {device.upper()}")
 
-                # Configuração de Quantização (equivalente a otimização de RAM)
+            try:
+                bnb_config = None
                 if device == "cuda":
-                    logger.info("Configuração de quantização 4-bit (BitsAndBytes) ativada para economia de VRAM.")
+                    logger.info("Ativando quantização 4-bit (nf4) para VRAM baixa.")
                     bnb_config = BitsAndBytesConfig(
                         load_in_4bit=True,
                         bnb_4bit_quant_type="nf4",
                         bnb_4bit_compute_dtype=torch.bfloat16,
                     )
-                else:
-                    bnb_config = None
-                    logger.info("Rodando em CPU. Sem quantização 4-bit (usará float32/float16).")
-                
-                # 1. Carrega o Tokenizer
+
                 tokenizer = AutoTokenizer.from_pretrained(HF_MODEL_ID, trust_remote_code=True)
-                
-                # 2. Carrega o Modelo
                 model = AutoModelForCausalLM.from_pretrained(
                     HF_MODEL_ID,
                     torch_dtype=torch.bfloat16 if device == "cuda" else torch.float32,
                     trust_remote_code=True,
                     quantization_config=bnb_config,
-                    device_map="auto" # Mapeamento automático (substitui n_gpu_layers/mlock)
+                    device_map="auto"
                 )
 
-                # LoRA loading is complex and dependent on HF Trainer/Peft setup.
-                # Here, we only log the path, as dynamic LoRA loading in 'transformers'
-                # is not as straightforward as in llama-cpp.
                 lora_path = os.path.join(FINETUNED_PATH, "lora_leve")
                 if os.path.isdir(lora_path):
-                    logger.warning(f"LoRA encontrado em {lora_path}, mas o carregamento não é suportado pelo método de inferência direta com AutoModel. Usando modelo base.")
+                    logger.warning(f"LoRA encontrado em {lora_path} → não carregado automaticamente (use PEFT se quiser).")
                 else:
                     logger.info("Usando modelo base (sem LoRA).")
 
                 cls._llm = (model, tokenizer)
-                logger.success(f"{cls.MODEL_ID} CARREGADO COM SUCESSO. Config: {device.upper()} | 4-bit: {bnb_config is not None}")
-            
+                logger.success(f"{cls.MODEL_ID} CARREGADO COM SUCESSO! Device: {device.upper()} | 4-bit: {bnb_config is not None}")
+
             except Exception as e:
-                logger.error(f"ERRO CRÍTICO AO CARREGAR {cls.MODEL_ID} DO HF: {e}")
+                logger.error(f"ERRO AO CARREGAR MODELO: {e}")
                 import traceback
                 logger.error(traceback.format_exc())
                 cls._llm = None
-                
         return cls._llm
 
-    # 3. Geração de Resposta (Adaptado)
     @classmethod
-    def generate(cls, prompt: str, max_tokens: int = 60) -> str:
+    def generate(cls, prompt: str, max_tokens: int = 500) -> str:
         """
-        GERA RESPOSTA COM PHI-3 USANDO TRANSFORMERS.
-        max_tokens → 'max_new_tokens' na função generate.
+        GERA RESPOSTA COM PHI-3 LOCAL
+        max_tokens = universal (500 por padrão, mas aceita qualquer valor)
         """
         llm_pair = cls._get_llm()
         if llm_pair is None:
-            raise RuntimeError(f"{cls.MODEL_ID} não está disponível ou falhou ao carregar.")
-        
+            raise RuntimeError(f"{cls.MODEL_ID} não carregado.")
+
         model, tokenizer = llm_pair
-        device = model.device # Pega o dispositivo onde o modelo está
-        
+        device = model.device
+
         try:
-            # FORMATO DE CHAT PHI-3: <|user|>PROMPT<|end|><|assistant|>
-            # O tokenizer.apply_chat_template faz isso de forma canônica
-            messages = [{"role": "user", "content": prompt}]
-            formatted_prompt = tokenizer.apply_chat_template(
-                messages, 
-                tokenize=False, 
+            # Usa o chat template oficial do Phi-3 (perfeito pro sotaque angolano)
+            formatted = tokenizer.apply_chat_template(
+                [{"role": "user", "content": prompt}],
+                tokenize=False,
                 add_generation_prompt=True
             )
 
-            # Tokeniza a entrada
-            input_ids = tokenizer.encode(formatted_prompt, return_tensors="pt").to(device)
-            
-            logger.info(f"[{cls.MODEL_ID} LOCAL] Gerando resposta → {max_tokens} tokens")
-            
+            input_ids = tokenizer.encode(formatted, return_tensors="pt").to(device)
+
+            logger.info(f"[PHI-3 LOCAL] Gerando → max_tokens={max_tokens}")
+
             with torch.no_grad():
                 output = model.generate(
                     input_ids,
                     max_new_tokens=max_tokens,
-                    temperature=0.72,
-                    top_p=0.92,
-                    do_sample=True, # Adicionado para usar temperature/top_p
-                    pad_token_id=tokenizer.eos_token_id, # Boa prática
+                    temperature=0.8,
+                    top_p=0.9,
+                    do_sample=True,
+                    repetition_penalty=1.1,
+                    pad_token_id=tokenizer.eos_token_id,
+                    eos_token_id=tokenizer.eos_token_id
                 )
-            
-            # Decodifica, ignorando o prompt de entrada
+
             text = tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=True).strip()
-            
-            # Limpeza manual de tags Phi-3 (apesar do skip_special_tokens, é bom garantir)
-            for tag in ["<|end|>", "<|assistant|>", "<|user|>"]:
-                 text = text.replace(tag, "").strip()
-            
-            logger.success(f"{cls.MODEL_ID} RESPONDEU → {len(text)} chars")
+            text = text.replace("<|end|>", "").replace("<|assistant|>", "").replace("<|user|>", "").strip()
+
+            logger.success(f"PHI-3 LOCAL respondeu → {len(text)} caracteres")
             return text
 
         except Exception as e:
-            logger.error(f"ERRO NA GERAÇÃO COM {cls.MODEL_ID} (Transformers): {e}")
+            logger.error(f"ERRO NA GERAÇÃO LOCAL: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
             raise
 
-# === Teste Básico de Disponibilidade no Script ===
-if __name__ == '__main__':
+
+# TESTE RÁPIDO (só roda se chamar o arquivo direto)
+if __name__ == "__main__":
     if Phi3LLM.is_available():
-        print("\nTeste de Carga do Modelo (Pode demorar)...")
-        if Phi3LLM._get_llm():
-            try:
-                # Exemplo de uso
-                prompt = "Me diga três fatos interessantes sobre a capital de Angola."
-                print(f"\nPROMPT: {prompt}")
-                response = Phi3LLM.generate(prompt, max_tokens=100)
-                print(f"\nRESPOSTA DO LLM:\n{response}")
-            except RuntimeError as e:
-                print(f"Erro durante a geração: {e}")
-        else:
-            print("Falha ao carregar o modelo.")
+        print("\nTestando Phi-3 local com sotaque de Luanda...\n")
+        resposta = Phi3LLM.generate("Epá, tas bué fixe hoje ou quê?", max_tokens=500)
+        print(f"AKIRA: {resposta}\n")
     else:
-        print("Ambiente não está pronto. Verifique as dependências.")
+        print("Modelo não disponível. Verifica as dependências.")