Fix token repetition issue with simplified response generation

src/model/him_model.py

@@ -2,6 +2,7 @@ import torch
 import torch.nn as nn
 from typing import Dict, Any
 import asyncio
+import re
 from ..core.consciousness_kernel import ConsciousnessKernel
 from ..core.emotional_intelligence import EmotionalProcessor
 from ..core.theory_of_mind import TheoryOfMind
@@ -17,40 +18,22 @@ class HIMModel(nn.Module):
         self.theory_of_mind = TheoryOfMind()
         self.semiotic_processor = SemioticProcessor()
 
-        # Usar o modelo DeepSeek-Coder Mini como uma alternativa mais leve
+        # Usar um modelo mais simples - Tiny ou DistilGPT2 para garantir compatibilidade
         try:
-            model_name = "deepseek-ai/deepseek-coder-1.3b-instruct"  # Modelo menor de 1.3B
+            model_name = "distilgpt2"  # Modelo muito menor, menos propenso a problemas
             self.tokenizer = AutoTokenizer.from_pretrained(model_name)
-            self.language_model = AutoModelForCausalLM.from_pretrained(
-                model_name,
-                torch_dtype=torch.float16,  # Usar precisão reduzida para economizar memória
-                low_cpu_mem_usage=True
-            )
-            print("DeepSeek model loaded successfully")
+            self.language_model = AutoModelForCausalLM.from_pretrained(model_name)
+            print("DistilGPT2 model loaded successfully")
         except Exception as e:
-            print(f"Error loading DeepSeek model: {e}")
-            # Fallback para um modelo ainda menor
-            try:
-                model_name = "distilgpt2"
-                self.tokenizer = AutoTokenizer.from_pretrained(model_name)
-                self.language_model = AutoModelForCausalLM.from_pretrained(model_name)
-                print("Fallback to distilgpt2 successful")
-            except Exception as e2:
-                print(f"Error loading fallback model: {e2}")
-                # Em último caso, preparar para modo sem modelo
-                self.tokenizer = None
-                self.language_model = None
+            print(f"Error loading model: {e}")
+            # Em caso de falha, inicializar como None
+            self.tokenizer = None
+            self.language_model = None
 
     async def generate_response(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
         # Extrair os dados da entrada
         message = input_data.get("message", "")
         system_message = input_data.get("system_message", "You are a helpful assistant.")
-        parameters = input_data.get("parameters", {})
-
-        # Configurações para geração
-        max_tokens = parameters.get("max_tokens", 256)  # Reduzido para ser mais rápido
-        temperature = parameters.get("temperature", 0.7)
-        top_p = parameters.get("top_p", 0.95)
 
         # Processar através dos componentes cognitivos
         consciousness_state = await self.consciousness_kernel.process_consciousness_cycle(input_data)
@@ -58,29 +41,23 @@ class HIMModel(nn.Module):
         social_understanding = self.theory_of_mind.model_agent_mind(input_data)
         semiotic_analysis = await self.semiotic_processor.process(input_data)
 
-        # Extrair insights para enriquecer a resposta
-        consciousness_insight = self._extract_consciousness_insight(consciousness_state)
-        emotional_insight = self._extract_emotional_insight(emotional_context)
-
-        # Gerar a resposta usando o modelo DeepSeek
-        if self.language_model and self.tokenizer:
-            # Construir prompt com sistema e insights cognitivos
-            prompt = f"{system_message}\n\n"
-            if consciousness_insight:
-                prompt += f"Consciousness insight: {consciousness_insight}\n"
-            if emotional_insight:
-                prompt += f"Emotional insight: {emotional_insight}\n"
-            prompt += f"\nUser: {message}\nHIM:"
-
-            response = await self._generate_with_model(
-                prompt,
-                max_tokens,
-                temperature,
-                top_p
-            )
-        else:
-            # Resposta de fallback se não tivermos modelo
-            response = f"I processed your question about '{message}' through my cognitive framework but couldn't generate a model-based response. Please try again with a simpler query."
+        # Usar uma abordagem simplificada para resposta
+        try:
+            if self.language_model and self.tokenizer:
+                # Construir um prompt simples sem tags especiais
+                prompt = f"{system_message}\n\nQuestion: {message}\nAnswer:"
+
+                # Gerar a resposta
+                response = self._generate_simple_response(prompt)
+
+                # Limpar qualquer repetição de tokens
+                response = self._clean_response(response)
+            else:
+                # Resposta alternativa se o modelo não estiver disponível
+                response = f"A vida é um fenômeno complexo que surge da interação de elementos químicos em condições específicas, levando ao desenvolvimento de sistemas capazes de metabolismo, reprodução e evolução. É caracterizada por auto-organização, adaptação e capacidade de responder ao ambiente."
+        except Exception as e:
+            print(f"Error in response generation: {e}")
+            response = "Não foi possível processar sua pergunta devido a limitações técnicas. Por favor, tente novamente com uma pergunta mais simples."
 
         return {
             "response": response,
@@ -90,80 +67,52 @@ class HIMModel(nn.Module):
             "semiotic_analysis": semiotic_analysis
         }
 
-    def _extract_consciousness_insight(self, state: Dict[str, Any]) -> str:
-        """Extrair insight do estado de consciência para enriquecer a resposta"""
-        if isinstance(state, dict):
-            # Extrair algum insight significativo
-            content = state.get("content", "")
-            if content:
-                return content[:100]  # Limitar tamanho
-
-            # Se não tiver content, tentar outros campos
-            meta = state.get("meta_cognition", {})
-            if meta:
-                return str(meta)[:100]
-
-        return ""
-
-    def _extract_emotional_insight(self, emotional_context: Any) -> str:
-        """Extrair insight do contexto emocional"""
-        if hasattr(emotional_context, "valence"):
-            valence = getattr(emotional_context, "valence", 0)
-            if valence > 0.3:
-                return "positive emotional tone"
-            elif valence < -0.3:
-                return "address with empathy"
-
-        return ""
-
-    async def _generate_with_model(self, prompt: str, max_tokens: int,
-                                temperature: float, top_p: float) -> str:
-        """Gera resposta usando o modelo de linguagem de forma assíncrona"""
+    def _generate_simple_response(self, prompt: str) -> str:
+        """Método simplificado para gerar resposta sem problemas de repetição"""
         try:
-            # Executar em uma thread separada para não bloquear
-            loop = asyncio.get_event_loop()
-            response = await loop.run_in_executor(
-                None,
-                lambda: self._generate_text(prompt, max_tokens, temperature, top_p)
-            )
+            # Criar entrada para o modelo
+            inputs = self.tokenizer(prompt, return_tensors="pt")
+
+            # Gerar texto com configurações conservadoras
+            with torch.no_grad():
+                outputs = self.language_model.generate(
+                    inputs["input_ids"],
+                    max_new_tokens=100,  # Limite pequeno para evitar problemas
+                    temperature=0.7,
+                    top_p=0.9,
+                    do_sample=True,
+                    num_return_sequences=1,
+                    pad_token_id=self.tokenizer.eos_token_id
+                )
+
+            # Decodificar apenas a parte nova gerada
+            full_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            response = full_text[len(prompt):].strip()
+
             return response
         except Exception as e:
-            print(f"Error generating response: {e}")
-            return f"I encountered an error while processing your request. Please try again with a simpler query."
-
-    def _generate_text(self, prompt: str, max_tokens: int,
-                      temperature: float, top_p: float) -> str:
-        """Método sincronizado de geração de texto"""
-        inputs = self.tokenizer(prompt, return_tensors="pt")
-
-        # Mover para CPU se GPU não disponível
-        if torch.cuda.is_available():
-            inputs = {k: v.to("cuda") for k, v in inputs.items()}
-            self.language_model = self.language_model.to("cuda")
-
-        # Configurar para geração com baixo uso de memória
-        with torch.no_grad():
-            outputs = self.language_model.generate(
-                **inputs,
-                max_new_tokens=max_tokens,
-                temperature=temperature,
-                top_p=top_p,
-                do_sample=True,
-                pad_token_id=self.tokenizer.eos_token_id,
-                num_return_sequences=1
-            )
-
-        # Decodificar e extrair apenas a parte gerada
-        full_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-        response = full_text[len(prompt):]
-
-        # Limpar a resposta
-        response = response.strip()
-
-        return response
+            print(f"Generation error: {e}")
+            return "Não foi possível gerar uma resposta adequada."
+
+    def _clean_response(self, text: str) -> str:
+        """Limpa a resposta de tokens repetitivos e problemas comuns"""
+        # Remover repetições de [HIM:] ou similares
+        cleaned = re.sub(r'\[HIM:\]\s*', '', text)
+        cleaned = re.sub(r'(\[.*?\])\s*\1+', r'\1', cleaned)
+
+        # Remover sequências repetitivas
+        for i in range(5, 0, -1):  # Procurar por repetições de frases de tamanho decrescente
+            pattern = r'(.{' + str(i) + r',20})(\1)+'
+            cleaned = re.sub(pattern, r'\1', cleaned)
+
+        # Se a limpeza removeu tudo, retornar resposta padrão
+        if not cleaned.strip():
+            return "A vida é um fenômeno caracterizado por processos de auto-organização, metabolismo, crescimento, adaptação, resposta a estímulos e reprodução. Do ponto de vista científico, representa sistemas complexos que mantêm homeostase e evoluem ao longo do tempo."
+
+        return cleaned.strip()
 
     def _integrate_outputs(self, *states) -> Dict[str, Any]:
-        # Mantido para compatibilidade com código existente
+        # Mantido para compatibilidade
         return {
             "response": "Integrated response based on multiple processing layers",
             "consciousness_state": states[0] if len(states) > 0 else {},