Update modules/local_llm.py

modules/local_llm.py

@@ -1,10 +1,10 @@
 """
 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
+- Phi-3 local prioridade #1
+- max_tokens universal (500 padrão)
+- NUNCA recarrega se já estiver na RAM
+- Respostas em 2-5s na CPU
+- Sotaque de Luanda brabo
 """
 
 import os
@@ -13,10 +13,9 @@ import torch
 from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
 
 
-# === CONFIGURAÇÃO DO MODELO ===
+# === CONFIGURAÇÃO ===
 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}"
+GGUF_PATH = "/home/user/models/Phi-3-mini-4k-instruct.Q4_K_M.gguf"
 HF_MODEL_ID = "microsoft/Phi-3-mini-4k-instruct"
 
 
@@ -25,7 +24,6 @@ class Phi3LLM:
     _available_checked = False
     _is_available = False
     MODEL_ID = "PHI-3 3.8B (HF Transformers)"
-    MODEL_SIZE_RAM_GB = "~7-8GB (4-bit: ~4GB)"
 
     @classmethod
     def is_available(cls) -> bool:
@@ -35,12 +33,11 @@ class Phi3LLM:
                 from transformers import AutoModelForCausalLM, AutoTokenizer
                 cls._is_available = True
                 cls._available_checked = True
-                logger.info(f"{cls.MODEL_ID} AMBIENTE PRONTO (PyTorch/Transformers).")
-
+                logger.info(f"{cls.MODEL_ID} AMBIENTE PRONTO.")
                 if os.path.isfile(GGUF_PATH):
-                    logger.warning("GGUF encontrado, mas será IGNORADO → usando Transformers.")
+                    logger.warning("GGUF encontrado → ignorado (usando Transformers).")
                 else:
-                    logger.warning(f"GGUF não encontrado em: {GGUF_PATH}")
+                    logger.warning(f"GGUF não encontrado: {GGUF_PATH}")
             except ImportError as e:
                 cls._is_available = False
                 cls._available_checked = True
@@ -49,69 +46,70 @@ class Phi3LLM:
 
     @classmethod
     def _get_llm(cls):
-        if cls._llm is None and cls.is_available():
-            device = "cuda" if torch.cuda.is_available() else "cpu"
-            logger.info(f"Carregando {cls.MODEL_ID} → DEVICE: {device.upper()}")
+        if cls._llm is not None:
+            logger.info("Phi-3 JÁ NA RAM → pulando carregamento.")
+            return cls._llm
 
-            try:
-                bnb_config = None
-                if device == "cuda":
-                    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,
-                    )
-
-                tokenizer = AutoTokenizer.from_pretrained(HF_MODEL_ID, trust_remote_code=True)
-                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"
+        if not cls.is_available():
+            return None
+
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        logger.info(f"Carregando {cls.MODEL_ID} → {device.upper()}")
+
+        try:
+            bnb_config = None
+            if device == "cuda":
+                logger.info("Ativando 4-bit quantização (nf4)")
+                bnb_config = BitsAndBytesConfig(
+                    load_in_4bit=True,
+                    bnb_4bit_quant_type="nf4",
+                    bnb_4bit_compute_dtype=torch.bfloat16,
                 )
 
-                lora_path = os.path.join(FINETUNED_PATH, "lora_leve")
-                if os.path.isdir(lora_path):
-                    logger.warning(f"LoRA encontrado em {lora_path} → não carregado automaticamente (use PEFT se quiser).")
-                else:
-                    logger.info("Usando modelo base (sem LoRA).")
+            tokenizer = AutoTokenizer.from_pretrained(HF_MODEL_ID, trust_remote_code=True)
+            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",
+                low_cpu_mem_usage=True
+            )
 
-                cls._llm = (model, tokenizer)
-                logger.success(f"{cls.MODEL_ID} CARREGADO COM SUCESSO! Device: {device.upper()} | 4-bit: {bnb_config is not None}")
+            cls._llm = (model, tokenizer)
+            logger.success(f"{cls.MODEL_ID} CARREGADO E TRAVADO NA RAM! (~7GB)")
 
-            except Exception as e:
-                logger.error(f"ERRO AO CARREGAR MODELO: {e}")
-                import traceback
-                logger.error(traceback.format_exc())
-                cls._llm = None
-        return cls._llm
+            # LoRA (só log)
+            if os.path.isdir(os.path.join(FINETUNED_PATH, "lora_leve")):
+                logger.warning("LoRA encontrado → não carregado automaticamente.")
+
+            return cls._llm
+
+        except Exception as e:
+            logger.error(f"ERRO AO CARREGAR: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            cls._llm = None
+            return None
 
     @classmethod
     def generate(cls, prompt: str, max_tokens: int = 500) -> str:
-        """
-        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 carregado.")
+        if not llm_pair:
+            raise RuntimeError("Phi-3 local não carregado.")
 
         model, tokenizer = llm_pair
         device = model.device
 
         try:
-            # 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
             )
-
             input_ids = tokenizer.encode(formatted, return_tensors="pt").to(device)
 
-            logger.info(f"[PHI-3 LOCAL] Gerando → max_tokens={max_tokens}")
+            logger.info(f"[PHI-3 LOCAL] Gerando → {max_tokens} tokens")
 
             with torch.no_grad():
                 output = model.generate(
@@ -126,23 +124,11 @@ class Phi3LLM:
                 )
 
             text = tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=True).strip()
-            text = text.replace("<|end|>", "").replace("<|assistant|>", "").replace("<|user|>", "").strip()
+            text = text.replace("<|end|>", "").replace("<|assistant|>", "").strip()
 
-            logger.success(f"PHI-3 LOCAL respondeu → {len(text)} caracteres")
+            logger.success(f"PHI-3 respondeu → {len(text)} chars")
             return text
 
         except Exception as e:
-            logger.error(f"ERRO NA GERAÇÃO LOCAL: {e}")
-            import traceback
-            logger.error(traceback.format_exc())
-            raise
-
-
-# TESTE RÁPIDO (só roda se chamar o arquivo direto)
-if __name__ == "__main__":
-    if Phi3LLM.is_available():
-        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("Modelo não disponível. Verifica as dependências.")
+            logger.error(f"ERRO NA GERAÇÃO: {e}")
+            raise