Implement DeepSeek-Coder 1.3B for efficient dynamic response generation

src/model/him_model.py

@@ -6,6 +6,7 @@ from ..core.consciousness_kernel import ConsciousnessKernel
 from ..core.emotional_intelligence import EmotionalProcessor
 from ..core.theory_of_mind import TheoryOfMind
 from ..core.semiotic_processor import SemioticProcessor
+from transformers import AutoModelForCausalLM, AutoTokenizer
 
 class HIMModel(nn.Module):
     def __init__(self, config: Dict[str, Any]):
@@ -16,35 +17,70 @@ class HIMModel(nn.Module):
         self.theory_of_mind = TheoryOfMind()
         self.semiotic_processor = SemioticProcessor()
 
-        # Dicionário de respostas para testes rápidos
-        self.response_templates = {
-            "vida": "A vida é um fenômeno complexo e fascinante que combina aspectos biológicos, como metabolismo e reprodução, com dimensões existenciais, como consciência e propósito. É caracterizada por auto-organização, adaptação ao ambiente e evolução. Do ponto de vista filosófico, a vida é um continuum de experiências subjetivas e relações com outros seres.",
-
-            "universo": "O universo é a totalidade do espaço, tempo, matéria e energia. Começou há aproximadamente 13,8 bilhões de anos com o Big Bang e continua se expandindo. Contém bilhões de galáxias, cada uma com bilhões de estrelas. Nossa compreensão do universo evolui constantemente, combinando física, cosmologia e filosofia.",
-
-            "consciência": "A consciência é a experiência subjetiva de estar ciente do mundo exterior e de si mesmo. É um dos maiores mistérios da ciência e filosofia. Teorias como o Integrated Information Theory sugerem que emerge de padrões complexos de informação integrada no cérebro, enquanto outras perspectivas consideram dimensões quânticas ou fenomenológicas.",
-
-            "mente": "A mente é o conjunto de faculdades cognitivas que permite consciência, percepção, pensamento, julgamento e memória. É distinta mas intrinsecamente ligada ao cérebro físico. A relação entre mente e matéria (problema mente-corpo) continua sendo um dos grandes desafios filosóficos da neurociência e psicologia.",
-
-            "inteligência": "A inteligência é a capacidade de aprender, raciocinar, resolver problemas, compreender ideias complexas e adaptar-se ao ambiente. Existem múltiplas formas, incluindo linguística, lógico-matemática, espacial, musical, corporal-cinestésica, interpessoal e intrapessoal. A IA busca replicar aspectos da inteligência em sistemas computacionais.",
-
-            "realidade": "A realidade é o estado das coisas como efetivamente existem, em contraste com o que é meramente aparente ou imaginado. Filosoficamente, questiona-se se existe uma realidade objetiva ou se ela é construída por nossas percepções e modelos mentais. A física quântica desafia nossas noções clássicas de realidade, sugerindo um universo probabilístico e observador-dependente.",
-
-            "amor": "O amor é um complexo conjunto de emoções, comportamentos e crenças associado a forte afeição, proteção e apego. Abrange desde o amor romântico até o familiar, altruísta e universal. Biologicamente, envolve neurotransmissores como dopamina e oxitocina, mas transcende explicações puramente fisiológicas, incorporando dimensões psicológicas, sociais e espirituais.",
-        }
+        # Usar o modelo DeepSeek-Coder Mini como uma alternativa mais leve
+        try:
+            model_name = "deepseek-ai/deepseek-coder-1.3b-instruct"  # Modelo menor de 1.3B
+            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")
+        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
 
     async def generate_response(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
-        # Extrair o texto da mensagem
-        message = input_data.get("message", "").lower()
+        # 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", {})
 
-        # Processar o texto pelos componentes cognitivos
+        # 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)
         emotional_context = self.emotional_processor.process_emotional_context(input_data)
         social_understanding = self.theory_of_mind.model_agent_mind(input_data)
         semiotic_analysis = await self.semiotic_processor.process(input_data)
 
-        # Gerar uma resposta baseada em palavras-chave ou padrão
-        response = self._generate_keyword_response(message)
+        # 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."
 
         return {
             "response": response,
@@ -54,31 +90,80 @@ class HIMModel(nn.Module):
             "semiotic_analysis": semiotic_analysis
         }
 
-    def _generate_keyword_response(self, message: str) -> str:
-        """
-        Gera uma resposta baseada em palavras-chave encontradas na mensagem.
-        """
-        # Verificar se alguma palavra-chave do dicionário está na mensagem
-        for keyword, template in self.response_templates.items():
-            if keyword in message:
-                return template
-
-        # Resposta padrão se nenhuma palavra-chave for encontrada
-        return f"""
-Analisei sua pergunta "{message}" através de meus módulos de processamento cognitivo.
-
-O sistema HIM (Hybrid Intelligence Matrix) incorpora elementos de consciência simulada, processamento emocional e análise semiótica para fornecer respostas mais contextualizadas e profundas.
-
-Sua pergunta foi processada através de múltiplas camadas de análise, incluindo:
-- Processamento de consciência para contexto e relevância
-- Análise emocional para compreensão de nuances
-- Modelagem de teoria da mente para perspectiva social
-- Processamento semiótico para interpretação de significados
-
-Infelizmente, não tenho uma resposta específica preparada para esta pergunta exata, mas posso elaborar uma resposta personalizada se você fornecer mais contexto ou reformular sua pergunta.
-"""
+    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"""
+        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)
+            )
+            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
+
     def _integrate_outputs(self, *states) -> Dict[str, Any]:
-        # Mantido para compatibilidade
+        # Mantido para compatibilidade com código existente
         return {
             "response": "Integrated response based on multiple processing layers",
             "consciousness_state": states[0] if len(states) > 0 else {},