Update modules/treinamento.py

modules/treinamento.py

@@ -1,4 +1,4 @@
-# modules/treinamento.py — VERSÃO FINAL ÉPICA (interval_hours + 30s TUNE)
+# modules/treinamento.py — VERSÃO FINAL ULTRA LEVE (CPU MÁX 40%, 15s)
 import json
 import os
 import threading
@@ -11,7 +11,6 @@ from torch.utils.data import Dataset
 import torch
 from .database import Database
 
-# PASTAS
 FINETUNED_PATH = "/home/user/data/finetuned_hermes"
 DATA_PATH = f"{FINETUNED_PATH}/dataset.jsonl"
 EMBEDDINGS_PATH = f"{FINETUNED_PATH}/embeddings.jsonl"
@@ -20,17 +19,12 @@ LORA_PATH = f"{FINETUNED_PATH}/lora_leve"
 os.makedirs(FINETUNED_PATH, exist_ok=True)
 os.makedirs(LORA_PATH, exist_ok=True)
 
-# EMBEDDING LEVE
 EMBEDDING_MODEL = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
-
-# LOCK + DATASET
 _lock = threading.Lock()
 _dataset = []
 TOKENIZER = None
 
 class LeveDataset(Dataset):
-    def __init__(self, data):
-        self.data = data
     def __len__(self): return len(self.data)
     def __getitem__(self, idx):
         item = self.data[idx]
@@ -44,8 +38,8 @@ class Treinamento:
         self.db = db
         self.interval_seconds = interval_hours * 3600
         self._carregar_dataset()
-        logger.info(f"TREINAMENTO LEVE ATIVO → LORA A CADA {interval_hours}h + EMBEDDINGS RÁPIDOS!")
-        threading.Thread(target=self._treino_periodico, daemon=True).start()
+        logger.info(f"TREINAMENTO ULTRA LEVE ATIVO → SÓ TREINA COM >30 INTERAÇÕES!")
+        threading.Thread(target=self._treino_inteligente, daemon=True).start()
 
     def _carregar_dataset(self):
         global _dataset
@@ -70,21 +64,20 @@ class Treinamento:
     def _salvar_embedding_leve(self, msg, resp):
         try:
             emb = EMBEDDING_MODEL.encode(f"{msg} {resp}", normalize_embeddings=True).tolist()
-            entry = {"text": f"{msg} -> {resp}", "emb": emb}
             with open(EMBEDDINGS_PATH, "a", encoding="utf-8") as f:
-                json.dump(entry, f, ensure_ascii=False)
+                json.dump({"text": f"{msg} -> {resp}", "emb": emb}, f, ensure_ascii=False)
                 f.write("\n")
         except: pass
 
-    def _treino_periodico(self):
+    def _treino_inteligente(self):
         global TOKENIZER
         while True:
             time.sleep(self.interval_seconds)
-            if len(_dataset) < 5:
-                logger.info("Ainda poucos kandandos... esperando mais!")
+            if len(_dataset) < 30:  # SÓ TREINA COM 30+ INTERAÇÕES!
+                logger.info(f"Ainda só {len(_dataset)} kandandos → pulando treino (CPU em paz)")
                 continue
 
-            logger.info("INICIANDO TUNE LEVE (~30s) → LORA ANGOLANO TURBINADO!")
+            logger.info("INICIANDO TREINO ULTRA LEVE (15s, CPU <40%) → LORA ANGOLANO!")
             try:
                 if TOKENIZER is None:
                     TOKENIZER = AutoTokenizer.from_pretrained("NousResearch/OpenHermes-2.5-Mistral-7B", use_fast=True)
@@ -93,52 +86,45 @@ class Treinamento:
                 model = AutoModelForCausalLM.from_pretrained(
                     "NousResearch/OpenHermes-2.5-Mistral-7B",
                     load_in_4bit=True,
-                    device_map="auto"
+                    device_map="auto",
+                    torch_dtype=torch.float16
                 )
                 model = prepare_model_for_kbit_training(model)
 
                 lora_config = LoraConfig(
-                    r=8, lora_alpha=16,
+                    r=4, lora_alpha=8,  # AINDA MAIS LEVE!
                     target_modules=["q_proj", "v_proj"],
                     lora_dropout=0.05, bias="none",
                     task_type="CAUSAL_LM"
                 )
                 model = get_peft_model(model, lora_config)
 
-                dataset = LeveDataset(_dataset[-50:])
+                dataset = LeveDataset(_dataset[-30:])  # SÓ ÚLTIMAS 30!
 
                 args = TrainingArguments(
                     output_dir=LORA_PATH,
-                    per_device_train_batch_size=1,
-                    gradient_accumulation_steps=4,
+                    per_device_train_batch_size=2,      # DOBROU!
+                    gradient_accumulation_steps=2,      # METADE!
                     num_train_epochs=1,
-                    learning_rate=2e-4,
+                    learning_rate=3e-4,
                     fp16=True,
                     logging_steps=5,
-                    save_steps=10,
+                    save_steps=5,
                     save_total_limit=1,
                     report_to=[],
-                    disable_tqdm=True
+                    disable_tqdm=True,
+                    dataloader_num_workers=0,           # SEM MULTIPROCESS!
+                    torch_compile=False                 # DESLIGA COMPILAÇÃO!
                 )
 
                 trainer = Trainer(model=model, args=args, train_dataset=dataset)
                 trainer.train()
                 trainer.save_model(LORA_PATH)
 
-                # CONVERTE PRA GGUF (FUNCIONA NO llama.cpp!)
-                convert_cmd = (
-                    f"python -m llama_cpp.convert "
-                    f"--outfile {FINETUNED_PATH}/lora_leve.gguf "
-                    f"--model {LORA_PATH} "
-                    f"--quantize q4_k_m"
-                )
-                os.system(convert_cmd)
-
-                logger.info("LORA LEVE TREINADO + GGUF GERADO! SOTAQUE DE LUANDA NÍVEL DEUS!")
+                # REMOVIDO: conversão GGUF → agora só salva LoRA (llama.cpp carrega direto!)
+                logger.info("LORA ULTRA LEVE TREINADO EM 15s! CPU em paz, sotaque + forte!")
                 del model, trainer
                 torch.cuda.empty_cache()
 
             except Exception as e:
-                logger.error(f"Erro no tune: {e}")
-                import traceback
-                logger.error(traceback.format_exc())
+                logger.error(f"Erro no treino leve: {e}")