Update modules/treinamento.py

modules/treinamento.py

@@ -1,417 +1,315 @@
-# treinamento.py
-import threading
-import time
-import logging
-import sqlite3
-import re
-import json
-from typing import Optional, Any, List, Dict, Tuple
-import collections
-
-logger = logging.getLogger(__name__)
-
-try:
-    from sentence_transformers import SentenceTransformer
-except Exception:
-    SentenceTransformer = None
-
-# Listas para análise de emoções, gírias e tom
-PALAVRAS_POSITIVAS = ['bom', 'ótimo', 'incrível', 'maravilhoso', 'feliz', 'alegre', 'amor', 'gostar', 'adorei', 'top', 'show', 'legal', 'bacana']
-PALAVRAS_NEGATIVAS = ['ruim', 'péssimo', 'horrível', 'triste', 'ódio', 'raiva', 'chateado', 'detesto', 'odeio', 'merda', 'porra', 'foda-se']
-GIRIAS_ANGOLANAS = ['mano', 'puto', 'kkk', 'rsrs', 'lol', 'tô', 'cê', 'num', 'tipo', 'né', 'bah', 'uai', 'oxe', 'eita', 'caramba', 'pqp', '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']
-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', 'kkk', 'vai tomar no cu', 'vai se foder', 'vai pra puta que pariu', 'seu filho da puta', 'sua puta', 'sua vadia', 'sua piranha', 'sua cachorra', 'sua puta barata', 'sua vagabunda', 'sua ordinária', 'sua desgraçada', 'sua infeliz', 'sua imbecil', 'sua idiota', 'sua burra', 'sua retardada', 'sua mongoloide', 'sua deficiente', 'sua aleijada', 'sua gorda', 'sua magrela', 'sua feia', 'sua bonita de merda', 'sua gostosa de bosta']
-
-
-class Treinamento:
-    """Classe responsável por treinar/ajustar o comportamento de Akira a partir dos dados no banco.
-
-    Funcionalidades principais:
-    - Agregar aprendizados e mensagens do banco
-    - Gerar embeddings (se disponível) e armazenar via Database.salvar_embedding
-    - Atualizar aprendizados agregados (interesses, limites, persona) no DB
-    - Rodar em background periodicamente (por padrão 24h)
-    """
-
-    def __init__(self, db, contexto: Optional[Any] = None, interval_hours: int = 24):
-        self.db = db
-        self.contexto = contexto
-        self.interval_hours = interval_hours
-        self._thread = None
-        self._running = False
-        self._model = None
-        # Usuários privilegiados que devem ter tom formal por padrão
-        self.privileged_users = ['244937035662', 'isaac', 'isaac quarenta', 'ceo', 'fundador']
-
-    def registrar_interacao(self, usuario: str, mensagem: str, resposta: str, numero: str = '', is_reply: bool = False, mensagem_original: str = ''):
-        """Registra uma interação para treinamento futuro."""
-        try:
-            conn = sqlite3.connect(self.db.db_path)
-            c = conn.cursor()
-            c.execute('INSERT INTO mensagens (usuario, mensagem, resposta, numero, is_reply, mensagem_original) VALUES (?, ?, ?, ?, ?, ?)',
-                     (usuario, mensagem, resposta, numero, is_reply, mensagem_original))
-            conn.commit()
-            conn.close()
-            logger.info('Interação registrada para treinamento')
-        except Exception as e:
-            logger.warning(f'Erro ao registrar interação: {e}')
-
-    def _ensure_model(self):
-        # tenta usar o model já carregado no contexto, ou carrega localmente
-        if self._model is not None:
-            return
-        if self.contexto and hasattr(self.contexto, 'model') and getattr(self.contexto, 'model', None):
-            self._model = self.contexto.model
-            return
-        if SentenceTransformer is None:
-            logger.debug('SentenceTransformer não disponível; embeddings desativados.')
-            return
-        try:
-            self._model = SentenceTransformer('all-MiniLM-L6-v2')
-            logger.info('Treinamento: modelo de embeddings carregado localmente.')
-        except Exception as e:
-            logger.warning(f'Treinamento: falha ao carregar SentenceTransformer: {e}')
-            self._model = None
-
-    def _fetch_recent_data(self, limit=1000) -> List[tuple]:
-        """Lê mensagens e aprendizados do banco diretamente via sqlite para agregação.
-        Filtra apenas conversas reais onde Akira respondeu e números válidos."""
-        rows = []
-        try:
-            conn = sqlite3.connect(self.db.db_path)
-            c = conn.cursor()
-            # Filtrar apenas linhas com resposta não vazia, número válido e usuário não vazio
-            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 usuario IS NOT NULL AND usuario != '' AND usuario != 'unknown'
-                AND LENGTH(numero) >= 10 AND numero LIKE '244%'
-                ORDER BY id DESC LIMIT ?
-            ''', (limit,))
-            rows = c.fetchall()
-            conn.close()
-            logger.info(f'Treinamento: filtrados {len(rows)} registros válidos de conversas reais')
-        except Exception as e:
-            logger.error(f'Erro ao buscar dados para treinamento: {e}')
-        return rows
-
-    def train_once(self):
-        """Executa um ciclo de treinamento simples/heurístico: agrega mensagens, cria embeddings e atualiza aprendizados."""
-        logger.info('Iniciando ciclo de treinamento (train_once)')
-        data = self._fetch_recent_data(limit=1000)
-        if not data:
-            logger.info('Nenhuma mensagem encontrada para treinar.')
-            # registra horário do último treino
-            try:
-                self.db.salvar_info_geral('ultimo_treino', str(time.time()))
-            except Exception:
-                pass
-            return
-
-        # Extrair palavras-chave simples por frequência para adaptar 'interesses' gerais
-        token_counter = collections.Counter()
-        sentences_for_embeddings = []
-        for usuario, numero, mensagem, resposta in data:
-            texto = (mensagem or '') + ' ' + (resposta or '')
-            # tokenização simples
-            tokens = [t for t in re.split(r'\W+', texto.lower()) if len(t) > 2]
-            token_counter.update(tokens)
-            sentences_for_embeddings.append(mensagem or '')
-
-        # top keywords
-        top_keywords = [w for w, _ in token_counter.most_common(20)]
-        logger.info({'event': 'top_keywords', 'keywords': top_keywords[:10]})
-
-        # Análise de emoções, gírias e tom
-        emocoes_positivas = 0
-        emocoes_negativas = 0
-        girias_counter = collections.Counter()
-        tom_rude = 0
-        for usuario, numero, mensagem, resposta in data:
-            texto = (mensagem or '') + ' ' + (resposta or '')
-            tokens = [t for t in re.split(r'\W+', texto.lower()) if len(t) > 2]
-            for token in tokens:
-                if token in PALAVRAS_POSITIVAS:
-                    emocoes_positivas += 1
-                if token in PALAVRAS_NEGATIVAS:
-                    emocoes_negativas += 1
-                if token in GIRIAS_ANGOLANAS:
-                    girias_counter[token] += 1
-                if token in PALAVRAS_RUDES:
-                    tom_rude += 1
-
-        # top girias
-        top_girias = [w for w, c in girias_counter.most_common(10)]
-        logger.info({'event': 'top_girias', 'girias': top_girias})
-        logger.info({'event': 'analise', 'positivas': emocoes_positivas, 'negativas': emocoes_negativas, 'rude': tom_rude})
-
-        # salvar agregados
-        try:
-            self.db.salvar_info_geral('interesses_geral', ','.join(top_keywords))
-        except Exception as e:
-            logger.warning(f'Não foi possível salvar interesses_geral: {e}')
-
-        try:
-            self.db.salvar_info_geral('emocoes_positivas', str(emocoes_positivas))
-        except Exception as e:
-            logger.warning(f'Não foi possível salvar emocoes_positivas: {e}')
-
-        try:
-            self.db.salvar_info_geral('emocoes_negativas', str(emocoes_negativas))
-        except Exception as e:
-            logger.warning(f'Não foi possível salvar emocoes_negativas: {e}')
-
-        try:
-            self.db.salvar_info_geral('girias_geral', ','.join(top_girias))
-        except Exception as e:
-            logger.warning(f'Não foi possível salvar girias_geral: {e}')
-
-        try:
-            self.db.salvar_info_geral('tom_rude', str(tom_rude))
-        except Exception as e:
-            logger.warning(f'Não foi possível salvar tom_rude: {e}')
-
-        # gerar embeddings se possível
-        self._ensure_model()
-        if self._model:
-            try:
-                # remove vazios
-                sentences = [s for s in sentences_for_embeddings if s and s.strip()]
-                # limitar para evitar uso excessivo de memória
-                sentences = sentences[:512]
-                embeddings = self._model.encode(sentences)
-                for s, emb in zip(sentences, embeddings):
-                    try:
-                        self.db.salvar_embedding(s, emb.tobytes())
-                    except Exception:
-                        # salvar_embedding deve existir no Database
-                        pass
-                logger.info('Embeddings gerados e salvos (parciais).')
-            except Exception as e:
-                logger.warning(f'Erro ao gerar embeddings no treino: {e}')
-
-        # NOVO: Análise avançada de aprendizado por usuário
-        self._analisar_aprendizado_por_usuario(data)
-
-        # marcar último treino
-        try:
-            self.db.salvar_info_geral('ultimo_treino', str(time.time()))
-        except Exception:
-            pass
-        logger.info('Ciclo de treinamento finalizado.')
-
-    def _analisar_aprendizado_por_usuario(self, data: List[tuple]):
-        """Analisa aprendizado específico por usuário para adaptação dinâmica"""
-        usuarios_unicos = set()
-        for _, numero, _, _ in data:
-            usuarios_unicos.add(numero)
-
-        for numero_usuario in usuarios_unicos:
-            # Buscar mensagens recentes do usuário
-            mensagens_usuario = self._fetch_user_messages(numero_usuario, limit=50)
-
-            if not mensagens_usuario:
-                continue
-
-            # Analisar emoções e tom
-            analise_emocional = self._analisar_emocoes_usuario(mensagens_usuario)
-            tom_predominante = self._detectar_tom_usuario(mensagens_usuario, numero_usuario)
-
-            # Aprender gírias específicas do usuário
-            girias_aprendidas = self._aprender_girias_usuario(numero_usuario, mensagens_usuario)
-
-            # Salvar aprendizados específicos
-            self._salvar_aprendizados_usuario(numero_usuario, analise_emocional, tom_predominante, girias_aprendidas)
-
-    def _fetch_user_messages(self, numero_usuario: str, limit: int = 50) -> List[tuple]:
-        """Busca mensagens recentes de um usuário específico"""
-        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_usuario, limit))
-            rows = c.fetchall()
-            conn.close()
-        except Exception as e:
-            logger.error(f'Erro ao buscar mensagens do usuário {numero_usuario}: {e}')
-        return rows
-
-    def _analisar_emocoes_usuario(self, mensagens: List[tuple]) -> Dict[str, Any]:
-        """Analisa emoções nas mensagens de um usuário"""
-        emocao_counter = collections.Counter()
-        intensidade_total = 0
-        total_mensagens = len(mensagens)
-
-        for mensagem, resposta in mensagens:
-            texto = (mensagem or '') + ' ' + (resposta or '')
-            analise = self.db.analisar_emocoes_mensagem(texto)
-            emocao_counter[analise['emocao']] += 1
-            intensidade_total += analise['intensidade']
-
-        emocao_predominante = emocao_counter.most_common(1)[0][0] if emocao_counter else 'neutro'
-        intensidade_media = intensidade_total / total_mensagens if total_mensagens > 0 else 0
-
-        return {
-            'emocao_predominante': emocao_predominante,
-            'intensidade_media': intensidade_media,
-            'distribuicao_emocoes': dict(emocao_counter)
-        }
-
-    def _detectar_tom_usuario(self, mensagens: List[tuple], numero_usuario: str = '') -> str:
-        """Detecta o tom predominante do usuário"""
-        # Usuários privilegiados sempre têm tom formal
-        if numero_usuario in self.privileged_users:
-            return 'formal'
-
-        tom_counter = collections.Counter()
-
-        for mensagem, _ in mensagens:
-            mensagem_lower = (mensagem or '').lower()
-
-            # Detectar tom rude
-            if any(palavra in mensagem_lower for palavra in PALAVRAS_RUDES):
-                tom_counter['rude'] += 1
-            # Detectar tom formal
-            elif any(palavra in mensagem_lower for palavra in ['por favor', 'obrigado', 'desculpe', 'com licença', 'senhor', 'senhora', 'prezado', 'estimado']):
-                tom_counter['formal'] += 1
-            # Detectar tom casual
-            elif any(palavra in mensagem_lower for palavra in GIRIAS_ANGOLANAS):
-                tom_counter['casual'] += 1
-            else:
-                tom_counter['neutro'] += 1
-
-        return tom_counter.most_common(1)[0][0] if tom_counter else 'neutro'
-
-    def _aprender_girias_usuario(self, numero_usuario: str, mensagens: List[tuple]) -> List[Dict[str, Any]]:
-        """Aprende gírias específicas do usuário"""
-        girias_novas = []
-
-        for mensagem, resposta in mensagens:
-            texto = (mensagem or '') + ' ' + (resposta or '')
-            tokens = [t for t in re.split(r'\W+', texto.lower()) if len(t) > 2]
-
-            for token in tokens:
-                # Verificar se é uma possível gíria (não está em dicionário comum)
-                if (token not in PALAVRAS_POSITIVAS and
-                    token not in PALAVRAS_NEGATIVAS and
-                    len(token) > 2 and
-                    not token.isdigit()):
-
-                    # Verificar frequência e contexto
-                    if self._eh_giria_potencial(token, mensagens):
-                        significado_inferido = self._inferir_significado_giria(token, mensagens)
-
-                        if significado_inferido:
-                            girias_novas.append({
-                                'giria': token,
-                                'significado': significado_inferido,
-                                'contexto': self._extrair_contexto_giria(token, mensagens)
-                            })
-
-                            # Salvar no banco
-                            self.db.salvar_giria_aprendida(numero_usuario, token, significado_inferido,
-                                                         self._extrair_contexto_giria(token, mensagens))
-
-        return girias_novas
-
-    def _eh_giria_potencial(self, palavra: str, mensagens: List[tuple], threshold: int = 3) -> bool:
-        """Verifica se uma palavra é uma gíria potencial baseada na frequência"""
-        count = 0
-        for mensagem, resposta in mensagens:
-            texto = (mensagem or '') + ' ' + (resposta or '')
-            count += texto.lower().count(palavra.lower())
-
-        return count >= threshold
-
-    def _inferir_significado_giria(self, giria: str, mensagens: List[tuple]) -> Optional[str]:
-        """Tenta inferir o significado de uma gíria baseada no contexto"""
-        contextos = []
-
-        for mensagem, resposta in mensagens:
-            texto = (mensagem or '') + ' ' + (resposta or '')
-            if giria.lower() in texto.lower():
-                # Extrair contexto ao redor da gíria
-                palavras = texto.split()
-                try:
-                    idx = next(i for i, p in enumerate(palavras) if p.lower() == giria.lower())
-                    contexto = ' '.join(palavras[max(0, idx-3):idx+4])
-                    contextos.append(contexto)
-                except (StopIteration, ValueError):
-                    continue
-
-        if not contextos:
-            return None
-
-        # Análise simples: se aparece com exclamação, pode ser admiração
-        if any('!' in ctx for ctx in contextos):
-            return "expressão de admiração ou surpresa"
-
-        # Se aparece com interrogação, pode ser dúvida
-        if any('?' in ctx for ctx in contextos):
-            return "expressão de dúvida ou confusão"
-
-        # Default: expressão emocional
-        return "expressão emocional ou gíria local"
-
-    def _extrair_contexto_giria(self, giria: str, mensagens: List[tuple]) -> str:
-        """Extrai contexto de uso da gíria"""
-        contextos = []
-        for mensagem, resposta in mensagens:
-            texto = (mensagem or '') + ' ' + (resposta or '')
-            if giria.lower() in texto.lower():
-                contextos.append(texto[:100] + '...' if len(texto) > 100 else texto)
-
-        return '; '.join(contextos[:3])  # Limitar a 3 exemplos
-
-    def _salvar_aprendizados_usuario(self, numero_usuario: str, analise_emocional: Dict[str, Any],
-                                   tom_predominante: str, girias_aprendidas: List[Dict[str, Any]]):
-        """Salva os aprendizados específicos do usuário"""
-        try:
-            # Salvar emoção predominante
-            self.db.salvar_aprendizado_detalhado(numero_usuario, 'emocao_predominante',
-                                               analise_emocional['emocao_predominante'])
-
-            # Salvar intensidade emocional
-            self.db.salvar_aprendizado_detalhado(numero_usuario, 'intensidade_emocional',
-                                               str(analise_emocional['intensidade_media']))
-
-            # Salvar tom predominante
-            self.db.registrar_tom_usuario(numero_usuario, tom_predominante,
-                                        analise_emocional['intensidade_media'])
-
-            # Salvar distribuição de emoções
-            self.db.salvar_aprendizado_detalhado(numero_usuario, 'distribuicao_emocoes',
-                                               json.dumps(analise_emocional['distribuicao_emocoes']))
-
-            logger.info(f'Aprendizados salvos para usuário {numero_usuario}: emoção={analise_emocional["emocao_predominante"]}, tom={tom_predominante}')
-
-        except Exception as e:
-            logger.warning(f'Erro ao salvar aprendizados do usuário {numero_usuario}: {e}')
-
-    def _run_loop(self):
-        interval = max(1, self.interval_hours) * 3600
-        logger.info(f'Treinamento periódico iniciado (interval_hours={self.interval_hours})')
-        while self._running:
-            try:
-                self.train_once()
-            except Exception as e:
-                logger.exception(f'Erro no loop de treinamento: {e}')
-            # dormir pelo intervalo configurado
-            for _ in range(int(interval)):
-                if not self._running:
-                    break
-                time.sleep(1)
-        logger.info('Treinamento periódico finalizado.')
-
-    def start_periodic_training(self):
-        if self._running:
-            return
-        self._running = True
-        self._thread = threading.Thread(target=self._run_loop, daemon=True)
-        self._thread.start()
-
-    def stop(self):
-        self._running = False
-        if self._thread:
-            self._thread.join(timeout=5)
+# treinamento.py
+import threading
+import time
+import logging
+import sqlite3
+import re
+import json
+import collections
+from typing import Optional, Any, List, Dict, Tuple
+
+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"
+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}")
+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'
+]
+
+
+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
+    """
+
+    def __init__(self, db, contexto: Optional[Any] = None, interval_hours: int = 1):
+        self.db = db
+        self.contexto = contexto
+        self.interval_hours = interval_hours
+        self._thread = None
+        self._running = False
+        self._model = None
+        self.privileged_users = ['244937035662', 'isaac', 'isaac quarenta', 'ceo', 'fundador']
+
+    # ================================================================
+    # CARREGAMENTO DO MODELO PESADO (com fallback)
+    # ================================================================
+
+    def _ensure_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.")
+            return
+        try:
+            logger.info(f"Carregando modelo pesado: {MODEL_NAME} (pode demorar 10-20s)...")
+            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}")
+            self._model = None
+
+    # ================================================================
+    # APRENDIZADO EM TEMPO REAL
+    # ================================================================
+
+    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"""
+        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}")
+        except Exception as e:
+            logger.warning(f'Erro ao registrar: {e}')
+
+    def _aprender_em_tempo_real(self, numero: str, msg: str, resp: str):
+        if not numero or numero == 'unknown':
+            return
+
+        texto = f"{msg} {resp}".lower()
+
+        # === ANÁLISE COM MODELO PESADO (se disponível) ===
+        self._ensure_model()
+        if self._model:
+            try:
+                # Embedding da mensagem completa
+                emb = self._model.encode(texto).tobytes()
+                self.db.salvar_embedding(texto, emb)
+
+                # 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) ===
+        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'}]
+        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])
+
+        # Salvar gírias
+        for giria in top_girias:
+            significado = "gíria agressiva" if rude else "gíria local"
+            self.db.salvar_giria_aprendida(numero, giria, significado, texto[:100])
+
+    # ================================================================
+    # TREINAMENTO PERIÓDICO (a cada hora)
+    # ================================================================
+
+    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()
+            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
+
+            analise = self._analisar_com_mpnet(msgs) if self._model else self._analisar_heuristica(msgs)
+            tom = self._detectar_tom_usuario(msgs, numero)
+
+            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'])
+
+        self._gerar_embeddings_globais(data)
+        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:
+        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):
+                counter['rude'] += 1
+            elif any(p in msg_lower for p in ['por favor', 'obrigado', 'senhor']):
+                counter['formal'] += 1
+            elif any(p in msg_lower 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
+
+    # ================================================================
+    # LOOP DE 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)")
+        while self._running:
+            try:
+                self.train_once()
+            except Exception as e:
+                logger.exception(f"Erro no treinamento: {e}")
+            for _ in range(int(interval)):
+                if not self._running:
+                    break
+                time.sleep(1)
+        logger.info("Treinamento periódico parado.")
+
+    def start_periodic_training(self):
+        if self._running:
+            return
+        self._running = True
+        self._thread = threading.Thread(target=self._run_loop, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        self._running = False
+        if self._thread:
+            self._thread.join(timeout=5)