Update modules/treinamento.py

modules/treinamento.py

@@ -1,4 +1,13 @@
-# treinamento.py
+# modules/treinamento.py
+"""
+Sistema de treinamento avançado para Akira IA.
+- Fine-tuning leve do YAYA-23-8B com LoRA (PEFT)
+- Análise emocional com sentence-transformers (mpnet)
+- Aprendizado em tempo real + periódico
+- Gírias, tom, ironia, contexto angolano
+- Integração total com database.py
+"""
+
 import threading
 import time
 import logging
@@ -7,57 +16,53 @@ import re
 import json
 import collections
 from typing import Optional, Any, List, Dict, Tuple
+from dataclasses import dataclass
 
 logger = logging.getLogger(__name__)
 
-# MODELO MAIS PESADO E ROBUSTO: paraphrase-multilingual-mpnet-base-v2
-# - 110M parâmetros
-# - Suporta 50+ idiomas (inclui português, gírias, sotaques)
-# - Excelente em: semântica, intenção, emoção, ironia, contexto
-# - Ideal para bots com "alma humana"
+# MODELO PESADO: paraphrase-multilingual-mpnet-base-v2
 try:
     from sentence_transformers import SentenceTransformer
-    # Força o modelo mais poderoso
     MODEL_NAME = "sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
-    logger.info(f"Carregando modelo pesado: {MODEL_NAME}")
+    logger.info(f"Modelo NLP carregado: {MODEL_NAME}")
 except Exception as e:
     logger.warning(f"sentence_transformers não disponível: {e}")
     SentenceTransformer = None
     MODEL_NAME = None
 
-# Listas expandidas para análise emocional + gírias angolanas
-PALAVRAS_POSITIVAS = [
-    'bom', 'ótimo', 'incrível', 'maravilhoso', 'feliz', 'alegre', 'amor', 'gostar', 'adorei',
-    'top', 'show', 'legal', 'bacana', 'fixe', 'bué', 'oroh', 'máximo', 'perfeito', 'genial',
-    'divertido', 'hilário', 'gargalhada', 'rsrs', 'kkk', 'lol', 'haha', 'amo', 'adoro'
-]
-
-PALAVRAS_NEGATIVAS = [
-    'ruim', 'péssimo', 'horrível', 'triste', 'ódio', 'raiva', 'chateado', 'detesto', 'odeio',
-    'merda', 'porra', 'caralho', 'puto', 'foda-se', 'tristeza', 'depressão', 'sofrimento',
-    'choro', 'lágrima', 'dor', 'sofrer', 'fracasso', 'perdi', 'derrota'
-]
-
-GIRIAS_ANGOLANAS = [
-    'mano', 'puto', 'kkk', 'rsrs', 'lol', 'tô', 'cê', 'num', 'tipo', 'né', 'bah', 'uai',
-    'oxe', 'eita', 'caramba', 'pqp', 'fdp', 'vsf', 'mlk', 'mwangolé', 'kota', 'mané',
-    'oroh', 'bué', 'fixe', 'kota', 'baza', 'bazar', 'bazar fora', 'está fixe', 'está bué'
-]
-
-PALAVRAS_RUDES = [
-    'puto', 'merda', 'porra', 'caralho', 'cacete', 'fdp', 'vsf', 'mlk', 'arrombado',
-    'viado', 'bicha', 'cu', 'buceta', 'rola', 'pau', 'bunda', 'peito', 'teta', 'bct',
-    'pnc', 'pnctl', 'fuder', 'foder', 'transar', 'comer', 'chupar', 'mamada', 'boquete',
-    'punheta', 'gozar', 'pqp', 'vai tomar no cu', 'vai se foder', 'seu filho da puta'
-]
+# YAYA LOCAL (para fine-tuning)
+try:
+    from modules.local_llm import YayaLLM
+    from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+    from transformers import TrainingArguments, Trainer, DataCollatorForLanguageModeling
+    PEFT_AVAILABLE = True
+except Exception as e:
+    logger.warning(f"PEFT não disponível: {e}")
+    PEFT_AVAILABLE = False
+
+# Listas angolanas
+PALAVRAS_POSITIVAS = ['bom', 'ótimo', 'incrível', 'feliz', 'alegre', 'fixe', 'bué', 'top', 'show', 'adoro', 'rsrs', 'kkk']
+PALAVRAS_NEGATIVAS = ['ruim', 'péssimo', 'triste', 'ódio', 'puto', 'merda', 'caralho', 'chateado']
+GIRIAS_ANGOLANAS = ['mano', 'puto', 'cota', 'mwangolé', 'kota', 'oroh', 'bué', 'fixe', 'baza', 'kuduro']
+PALAVRAS_RUDES = ['caralho', 'puto', 'merda', 'fdp', 'vsf', 'burro', 'idiota', 'parvo']
+
+
+@dataclass
+class Interacao:
+    usuario: str
+    mensagem: str
+    resposta: str
+    numero: str
+    is_reply: bool = False
+    mensagem_original: str = ""
 
 
 class Treinamento:
     """
-    Treinamento com o modelo MAIS PESADO E HUMANO:
-    - paraphrase-multilingual-mpnet-base-v2
-    - Aprendizado em tempo real + periódico
-    - Detecta: intenção, emoção, ironia, gírias, tom, contexto
+    Treinamento contínuo da Akira:
+    - Registra interações
+    - Analisa tom, emoção, gírias
+    - Fine-tuning periódico do YAYA com LoRA
     """
 
     def __init__(self, db, contexto: Optional[Any] = None, interval_hours: int = 1):
@@ -67,27 +72,23 @@ class Treinamento:
         self._thread = None
         self._running = False
         self._model = None
-        self.privileged_users = ['244937035662', 'isaac', 'isaac quarenta', 'ceo', 'fundador']
+        self.yaya = YayaLLM() if PEFT_AVAILABLE else None
+        self.privileged_users = ['244937035662', 'isaac', 'isaac quarenta']
 
     # ================================================================
-    # CARREGAMENTO DO MODELO PESADO (com fallback)
+    # CARREGAMENTO DO MODELO NLP
     # ================================================================
 
-    def _ensure_model(self):
+    def _ensure_nlp_model(self):
         if self._model is not None:
             return
-        if self.contexto and hasattr(self.contexto, 'model') and self.contexto.model:
-            self._model = self.contexto.model
-            return
-        if SentenceTransformer is None or MODEL_NAME is None:
-            logger.warning("Modelo pesado não disponível. Usando análise heurística.")
+        if SentenceTransformer is None:
             return
         try:
-            logger.info(f"Carregando modelo pesado: {MODEL_NAME} (pode demorar 10-20s)...")
+            logger.info("Carregando modelo NLP pesado...")
             self._model = SentenceTransformer(MODEL_NAME)
-            logger.info("Modelo pesado carregado com sucesso! Akira agora é mais humana.")
         except Exception as e:
-            logger.error(f"Falha ao carregar modelo pesado: {e}")
+            logger.error(f"Falha ao carregar modelo NLP: {e}")
             self._model = None
 
     # ================================================================
@@ -95,11 +96,11 @@ class Treinamento:
     # ================================================================
 
     def registrar_interacao(self, usuario: str, mensagem: str, resposta: str, numero: str = '', is_reply: bool = False, mensagem_original: str = ''):
-        """Registra + aprende na hora com modelo pesado"""
+        """Salva + aprende na hora"""
         try:
             self.db.salvar_mensagem(usuario, mensagem, resposta, numero, is_reply, mensagem_original)
             self._aprender_em_tempo_real(numero, mensagem, resposta)
-            logger.info(f"Interação aprendida em tempo real: {numero}")
+            logger.info(f"Interação aprendida: {numero}")
         except Exception as e:
             logger.warning(f'Erro ao registrar: {e}')
 
@@ -109,180 +110,168 @@ class Treinamento:
 
         texto = f"{msg} {resp}".lower()
 
-        # === ANÁLISE COM MODELO PESADO (se disponível) ===
-        self._ensure_model()
+        # === ANÁLISE NLP (se disponível) ===
+        self._ensure_nlp_model()
         if self._model:
             try:
-                # Embedding da mensagem completa
                 emb = self._model.encode(texto).tobytes()
                 self.db.salvar_embedding(texto, emb)
+            except: pass
 
-                # Similaridade com frases emocionais (exemplo)
-                frases_emocao = {
-                    "feliz": "estou muito feliz hoje",
-                    "triste": "estou muito triste e sozinho",
-                    "raiva": "estou puto com tudo",
-                    "amor": "eu te amo muito"
-                }
-                embs_ref = self._model.encode(list(frases_emocao.values()))
-                sims = self._model.encode(texto) @ embs_ref.T
-                emocao_pred = list(frases_emocao.keys())[sims.argmax()]
-                intensidade = float(sims.max())
-                self.db.salvar_aprendizado_detalhado(numero, "emocao_ia", json.dumps({
-                    "emocao": emocao_pred,
-                    "intensidade": intensidade,
-                    "fonte": "mpnet"
-                }))
-            except Exception as e:
-                logger.warning(f"Erro no modelo pesado: {e}")
-
-        # === ANÁLISE HEURÍSTICA (sempre) ===
+        # === ANÁLISE HEURÍSTICA ===
         rude = any(p in texto for p in PALAVRAS_RUDES)
         tom = 'rude' if rude else 'casual'
 
         palavras = [p for p in re.findall(r'\b\w{4,}\b', texto)
-                    if p not in {'não', 'que', 'com', 'pra', 'pro', 'uma', 'ele', 'ela', 'isso'}]
+                    if p not in {'não', 'que', 'com', 'pra', 'uma', 'ele', 'ela'}]
         contador = collections.Counter(palavras)
         top_girias = [w for w, c in contador.most_common(5) if c > 1]
 
         # Salvar tom
-        intensidade_tom = 0.8 if rude else 0.5
-        self.db.registrar_tom_usuario(numero, tom, intensidade_tom, texto[:100])
+        intensidade = 0.9 if rude else 0.6
+        self.db.registrar_tom_usuario(numero, tom, intensidade, texto[:100])
 
         # Salvar gírias
         for giria in top_girias:
-            significado = "gíria agressiva" if rude else "gíria local"
+            significado = "gíria rude" if rude else "gíria local"
             self.db.salvar_giria_aprendida(numero, giria, significado, texto[:100])
 
+        # Emoção
+        analise = self.db.analisar_emocoes_mensagem(texto)
+        self.db.salvar_aprendizado_detalhado(numero, "emocao_recente", json.dumps(analise))
+
     # ================================================================
-    # TREINAMENTO PERIÓDICO (a cada hora)
+    # FINE-TUNING DO YAYA (LOKA)
     # ================================================================
 
-    def train_once(self):
-        logger.info("Iniciando treinamento periódico com modelo pesado...")
-        data = self._fetch_recent_data(limit=1000)
-        if not data:
-            logger.info("Nenhum dado para treinar.")
-            self._salvar_ultimo_treino()
+    def _prepare_dataset(self, interacoes: List[Interacao]) -> List[Dict]:
+        """Prepara dataset para LoRA"""
+        dataset = []
+        for i in interacoes:
+            prompt = f"[INST] <<SYS>>\nVocê é Akira, angolana sarcástica. Responda curto e com gírias.\n<</SYS>>\n\n{i.mensagem} [/INST]"
+            dataset.append({
+                "text": f"{prompt} {i.resposta}"
+            })
+        return dataset
+
+    def fine_tune_yaya(self):
+        """Fine-tuning leve com LoRA"""
+        if not PEFT_AVAILABLE or not self.yaya or not self.yaya.model:
+            logger.info("Fine-tuning desativado (YAYA/PEFT indisponível)")
             return
 
-        usuarios = set(row[1] for row in data if row[1] and row[1].startswith('244'))
-        for numero in usuarios:
-            msgs = self._fetch_user_messages(numero, limit=50)
-            if len(msgs) < 3:
-                continue
+        try:
+            logger.info("Iniciando fine-tuning do YAYA-23-8B com LoRA...")
+
+            # Pega últimas 500 interações
+            rows = self.db._execute_with_retry(
+                "SELECT usuario, mensagem, resposta, numero FROM mensagens WHERE resposta != '' ORDER BY id DESC LIMIT 500"
+            )
+            interacoes = [Interacao(u, m, r, n) for u, m, r, n in rows]
+
+            if len(interacoes) < 50:
+                logger.info("Poucos dados. Pulando fine-tuning.")
+                return
+
+            dataset = self._prepare_dataset(interacoes)
+
+            # Tokeniza
+            def tokenize_function(examples):
+                return self.yaya.tokenizer(examples["text"], truncation=True, max_length=512)
+
+            tokenized = [tokenize_function(d) for d in dataset]
+            from datasets import Dataset
+            hf_dataset = Dataset.from_list(tokenized)
+
+            # LoRA config
+            peft_config = LoraConfig(
+                r=16,
+                lora_alpha=32,
+                target_modules=["q_proj", "v_proj"],
+                lora_dropout=0.05,
+                bias="none",
+                task_type="CAUSAL_LM"
+            )
+
+            model = prepare_model_for_kbit_training(self.yaya.model)
+            model = get_peft_model(model, peft_config)
+
+            # Trainer
+            training_args = TrainingArguments(
+                output_dir="./yaya-finetuned",
+                per_device_train_batch_size=1,
+                gradient_accumulation_steps=4,
+                num_train_epochs=1,
+                learning_rate=2e-4,
+                fp16=True,
+                logging_steps=10,
+                save_steps=100,
+                save_total_limit=2,
+                report_to=[],
+                disable_tqdm=True
+            )
+
+            trainer = Trainer(
+                model=model,
+                args=training_args,
+                train_dataset=hf_dataset,
+                data_collator=DataCollatorForLanguageModeling(self.yaya.tokenizer, mlm=False)
+            )
+
+            trainer.train()
+            model.save_pretrained("./yaya-finetuned")
+            self.yaya.tokenizer.save_pretrained("./yaya-finetuned")
+            logger.info("Fine-tuning concluído! Modelo salvo.")
 
-            analise = self._analisar_com_mpnet(msgs) if self._model else self._analisar_heuristica(msgs)
-            tom = self._detectar_tom_usuario(msgs, numero)
+        except Exception as e:
+            logger.error(f"Erro no fine-tuning: {e}")
 
-            self.db.salvar_aprendizado_detalhado(numero, 'emocao_predominante', analise['emocao_predominante'])
-            self.db.salvar_aprendizado_detalhado(numero, 'intensidade_emocional', str(analise['intensidade_media']))
-            self.db.registrar_tom_usuario(numero, tom, analise['intensidade_media'])
+    # ================================================================
+    # TREINAMENTO PERIÓDICO
+    # ================================================================
 
-        self._gerar_embeddings_globais(data)
+    def train_once(self):
+        logger.info("Treinamento periódico iniciado...")
+        self.fine_tune_yaya()
+        self._analisar_usuarios()
         self._salvar_ultimo_treino()
-        logger.info("Treinamento concluído com sucesso.")
-
-    def _analisar_com_mpnet(self, mensagens: List[Tuple]) -> Dict:
-        """Análise emocional com modelo pesado"""
-        textos = [f"{m} {r}" for m, r in mensagens]
-        embs = self._model.encode(textos)
-
-        # Frases de referência
-        refs = {
-            "feliz": "estou muito feliz e animado",
-            "triste": "estou triste e deprimido",
-            "raiva": "estou com raiva e irritado",
-            "amor": "eu amo e adoro essa pessoa"
-        }
-        ref_embs = self._model.encode(list(refs.values()))
-        sims = embs @ ref_embs.T
-        emocoes = [list(refs.keys())[i] for i in sims.argmax(axis=1)]
-        intensidades = sims.max(axis=1)
-
-        counter = collections.Counter(emocoes)
-        return {
-            'emocao_predominante': counter.most_common(1)[0][0],
-            'intensidade_media': float(intensidades.mean())
-        }
-
-    def _analisar_heuristica(self, mensagens: List[Tuple]) -> Dict:
-        counter = collections.Counter()
-        intensidade = 0
-        total = len(mensagens)
-        for msg, resp in mensagens:
-            texto = (msg or '') + ' ' + (resp or '')
-            analise = self.db.analisar_emocoes_mensagem(texto)
-            counter[analise['emocao']] += 1
-            intensidade += analise['intensidade']
-        return {
-            'emocao_predominante': counter.most_common(1)[0][0] if counter else 'neutro',
-            'intensidade_media': intensidade / total if total > 0 else 0
-        }
-
-    def _detectar_tom_usuario(self, mensagens: List[Tuple], numero: str) -> str:
+        logger.info("Treinamento concluído.")
+
+    def _analisar_usuarios(self):
+        usuarios = set()
+        rows = self.db._execute_with_retry("SELECT DISTINCT numero FROM mensagens WHERE numero LIKE '244%'")
+        for r in rows:
+            usuarios.add(r[0])
+
+        for num in usuarios:
+            msgs = self.db._execute_with_retry(
+                "SELECT mensagem, resposta FROM mensagens WHERE numero=? ORDER BY id DESC LIMIT 20", (num,)
+            )
+            if len(msgs) < 3: continue
+
+            tom = self._detectar_tom(msgs, num)
+            self.db.salvar_preferencia_tom(num, tom)
+
+    def _detectar_tom(self, mensagens: List[Tuple], numero: str) -> str:
         if numero in self.privileged_users:
             return 'formal'
         counter = collections.Counter()
         for msg, _ in mensagens:
-            msg_lower = (msg or '').lower()
-            if any(p in msg_lower for p in PALAVRAS_RUDES):
+            msg_l = (msg or '').lower()
+            if any(p in msg_l for p in PALAVRAS_RUDES):
                 counter['rude'] += 1
-            elif any(p in msg_lower for p in ['por favor', 'obrigado', 'senhor']):
+            elif any(p in msg_l for p in ['por favor', 'obrigado']):
                 counter['formal'] += 1
-            elif any(p in msg_lower for p in GIRIAS_ANGOLANAS):
+            elif any(p in msg_l for p in GIRIAS_ANGOLANAS):
                 counter['casual'] += 1
             else:
                 counter['neutro'] += 1
         return counter.most_common(1)[0][0] if counter else 'neutro'
 
-    def _gerar_embeddings_globais(self, data: List[Tuple]):
-        if not self._model:
-            return
-        sentences = [row[2] for row in data if row[2] and len(row[2]) > 10][:256]
-        try:
-            embeddings = self._model.encode(sentences)
-            for s, emb in zip(sentences, embeddings):
-                self.db.salvar_embedding(s, emb.tobytes())
-        except Exception as e:
-            logger.warning(f'Erro ao gerar embeddings globais: {e}')
-
-    def _fetch_recent_data(self, limit=1000) -> List[Tuple]:
-        rows = []
-        try:
-            conn = sqlite3.connect(self.db.db_path)
-            c = conn.cursor()
-            c.execute('''
-                SELECT usuario, numero, mensagem, resposta 
-                FROM mensagens 
-                WHERE resposta IS NOT NULL AND resposta != ''
-                  AND numero IS NOT NULL AND numero != '' AND numero != 'unknown'
-                  AND LENGTH(numero) >= 10 AND numero LIKE '244%'
-                ORDER BY id DESC LIMIT ?
-            ''', (limit,))
-            rows = c.fetchall()
-            conn.close()
-        except Exception as e:
-            logger.error(f'Erro ao buscar dados: {e}')
-        return rows
-
-    def _fetch_user_messages(self, numero: str, limit: int = 50) -> List[Tuple]:
-        rows = []
-        try:
-            conn = sqlite3.connect(self.db.db_path)
-            c = conn.cursor()
-            c.execute('SELECT mensagem, resposta FROM mensagens WHERE numero=? ORDER BY id DESC LIMIT ?', (numero, limit))
-            rows = c.fetchall()
-            conn.close()
-        except Exception as e:
-            logger.error(f'Erro ao buscar mensagens do usuário {numero}: {e}')
-        return rows
-
     def _salvar_ultimo_treino(self):
         try:
             self.db.salvar_info_geral('ultimo_treino', str(time.time()))
-        except:
-            pass
+        except: pass
 
     # ================================================================
     # LOOP DE TREINAMENTO
@@ -290,7 +279,7 @@ class Treinamento:
 
     def _run_loop(self):
         interval = max(1, self.interval_hours) * 3600
-        logger.info(f"Treinamento periódico iniciado (a cada {self.interval_hours}h)")
+        logger.info(f"Treinamento a cada {self.interval_hours}h")
         while self._running:
             try:
                 self.train_once()
@@ -300,11 +289,10 @@ class Treinamento:
                 if not self._running:
                     break
                 time.sleep(1)
-        logger.info("Treinamento periódico parado.")
+        logger.info("Treinamento parado.")
 
     def start_periodic_training(self):
-        if self._running:
-            return
+        if self._running: return
         self._running = True
         self._thread = threading.Thread(target=self._run_loop, daemon=True)
         self._thread.start()