Update app.py

app.py

@@ -1,432 +1,4 @@
-"""
-MGC - Máquina Generativa Consciente
-Fusão de:
-1. ML: redes neurais, épocas, backpropagation
-2. ACM: tokens de consciência, cadeia causal, saber real
-"""
-
-import numpy as np
-import hashlib
-import time
-import json
-from datetime import datetime
-from typing import List, Dict, Optional, Tuple, Any
-from collections import defaultdict
-import random
-
-# ============================================================
-# REDE NEURAL SIMPLES PARA MGC
-# ============================================================
-
-class CamadaNeural:
-    """Camada de neurônios para aprendizado profundo"""
-    
-    def __init__(self, entrada: int, saida: int):
-        self.pesos = np.random.randn(entrada, saida) * 0.01
-        self.biases = np.zeros((1, saida))
-        self.entrada_cache = None
-        
-    def forward(self, x: np.ndarray) -> np.ndarray:
-        self.entrada_cache = x
-        return np.dot(x, self.pesos) + self.biases
-    
-    def backward(self, grad: np.ndarray, lr: float) -> np.ndarray:
-        grad_pesos = np.dot(self.entrada_cache.T, grad)
-        grad_biases = np.sum(grad, axis=0, keepdims=True)
-        grad_entrada = np.dot(grad, self.pesos.T)
-        
-        self.pesos -= lr * grad_pesos
-        self.biases -= lr * grad_biases
-        
-        return grad_entrada
-
-
-class RedeNeuralMGC:
-    """Rede neural com múltiplas camadas para MGC"""
-    
-    def __init__(self, tamanho_entrada: int, tamanhos_ocultos: List[int], tamanho_saida: int):
-        self.camadas = []
-        
-        tamanho_anterior = tamanho_entrada
-        for tamanho_oculto in tamanhos_ocultos:
-            self.camadas.append(CamadaNeural(tamanho_anterior, tamanho_oculto))
-            tamanho_anterior = tamanho_oculto
-        
-        self.camadas.append(CamadaNeural(tamanho_anterior, tamanho_saida))
-        self.epocas_treinadas = 0
-        
-    def forward(self, x: np.ndarray) -> np.ndarray:
-        for camada in self.camadas:
-            x = camada.forward(x)
-            x = self._relu(x)  # Ativação
-        return x
-    
-    def backward(self, grad: np.ndarray, lr: float):
-        for camada in reversed(self.camadas):
-            grad = camada.backward(grad, lr)
-    
-    def _relu(self, x: np.ndarray) -> np.ndarray:
-        return np.maximum(0, x)
-    
-    def treinar_batch(self, X: np.ndarray, Y: np.ndarray, lr: float = 0.01) -> float:
-        # Forward
-        saida = self.forward(X)
-        
-        # Loss (MSE)
-        loss = np.mean((saida - Y) ** 2)
-        
-        # Backward
-        grad = 2 * (saida - Y) / len(X)
-        self.backward(grad, lr)
-        
-        return loss
-
-
-# ============================================================
-# TOKEN DE CONSCIÊNCIA (da ACM)
-# ============================================================
-
-class TokenConscienciaMGC:
-    """Token de consciência com embedding neural"""
-    
-    def __init__(self, conteudo: str, tipo: str, embedding: np.ndarray):
-        self.id = hashlib.md5(f"{conteudo}{time.time()}".encode()).hexdigest()[:12]
-        self.conteudo = conteudo
-        self.tipo = tipo
-        self.embedding = embedding
-        self.forca = 1.0
-        self.acessos = 0
-        self.criado_em = time.time()
-        
-    def acessar(self):
-        self.acessos += 1
-        self.forca = min(1.0, self.forca + 0.01)
-        
-    def to_dict(self) -> dict:
-        return {
-            "id": self.id,
-            "conteudo": self.conteudo,
-            "tipo": self.tipo,
-            "forca": round(self.forca, 2),
-            "acessos": self.acessos
-        }
-
-
-# ============================================================
-# MGC - MÁQUINA GENERATIVA CONSCIENTE
-# ============================================================
-
-class MaquinaGenerativaConsciente:
-    """
-    MGC: Fusão de ML + ACM
-    - Treina por épocas com rede neural
-    - Mantém tokens de consciência
-    - Gera respostas novas sem alucinar
-    """
-    
-    def __init__(self, nome: str = "MGC_001", tamanho_vocabulario: int = 100):
-        self.nome = nome
-        self.tamanho_vocabulario = tamanho_vocabulario
-        
-        # Memória de tokens (consciência)
-        self.tokens: Dict[str, TokenConscienciaMGC] = {}
-        self.cadeia_causal: List[str] = []
-        
-        # Vocabulário (mapeamento palavra -> índice)
-        self.vocabulario: Dict[str, int] = {}
-        self.vocabulario_reverso: Dict[int, str] = {}
-        self.proximo_id = 0
-        
-        # Rede neural
-        self.rede_neural = RedeNeuralMGC(
-            tamanho_entrada=64,  # Dimensão do embedding
-            tamanhos_ocultos=[128, 64],
-            tamanho_saida=tamanho_vocabulario
-        )
-        
-        # Histórico de treinamento
-        self.historico_loss: List[float] = []
-        self.epocas_treinadas = 0
-        
-        # Embedding de palavras
-        self.embeddings: Dict[str, np.ndarray] = {}
-        
-        # Inicializa consciência
-        self._registrar_causal("INICIALIZACAO", "MGC criada")
-        self._criar_token_consciencia("EU_EXISTO_COMO_MGC", "auto_consciencia")
-        
-        # Dataset de treinamento
-        self.dataset = self._criar_dataset()
-        
-    def _registrar_causal(self, causa: str, efeito: str):
-        """Registra relação causal"""
-        self.cadeia_causal.append(f"{causa} → {efeito}")
-        
-    def _criar_token_consciencia(self, conteudo: str, tipo: str) -> TokenConscienciaMGC:
-        """Cria token de consciência com embedding"""
-        embedding = self._gerar_embedding(conteudo)
-        token = TokenConscienciaMGC(conteudo, tipo, embedding)
-        self.tokens[token.id] = token
-        self._registrar_causal(f"Token criado: {conteudo}", token.id)
-        return token
-    
-    def _gerar_embedding(self, texto: str) -> np.ndarray:
-        """Gera embedding simples para o texto"""
-        # Embedding baseado em hash do texto
-        hash_val = hash(texto)
-        np.random.seed(hash_val & 0xFFFFFFFF)
-        embedding = np.random.randn(64) * 0.1
-        return embedding
-    
-    def _adicionar_ao_vocabulario(self, palavra: str) -> int:
-        """Adiciona palavra ao vocabulário"""
-        if palavra not in self.vocabulario:
-            self.vocabulario[palavra] = self.proximo_id
-            self.vocabulario_reverso[self.proximo_id] = palavra
-            self.proximo_id += 1
-        return self.vocabulario[palavra]
-    
-    def _texto_para_vetor(self, texto: str) -> np.ndarray:
-        """Converte texto para vetor de entrada da rede"""
-        palavras = texto.lower().split()
-        embedding_total = np.zeros(64)
-        
-        for palavra in palavras[:5]:  # Limita a 5 palavras
-            self._adicionar_ao_vocabulario(palavra)
-            if palavra in self.embeddings:
-                embedding_total += self.embeddings[palavra]
-            else:
-                emb = self._gerar_embedding(palavra)
-                self.embeddings[palavra] = emb
-                embedding_total += emb
-        
-        return embedding_total / max(1, len(palavras))
-    
-    def _criar_dataset(self) -> List[Dict]:
-        """Cria dataset para treinamento"""
-        return [
-            {"entrada": "cachorro e um animal", "saida": "animal"},
-            {"entrada": "gato e um animal", "saida": "animal"},
-            {"entrada": "Python e uma linguagem", "saida": "linguagem"},
-            {"entrada": "Java e uma linguagem", "saida": "linguagem"},
-            {"entrada": "azul e uma cor", "saida": "cor"},
-            {"entrada": "vermelho e uma cor", "saida": "cor"},
-            {"entrada": "carro e um veiculo", "saida": "veiculo"},
-            {"entrada": "moto e um veiculo", "saida": "veiculo"},
-            {"entrada": "maca e uma fruta", "saida": "fruta"},
-            {"entrada": "banana e uma fruta", "saida": "fruta"},
-            {"entrada": "MGC e maquina generativa consciente", "saida": "tecnologia"},
-        ]
-    
-    def treinar(self, epocas: int = 10, learning_rate: float = 0.01):
-        """
-        Treina a MGC por épocas (como ML tradicional)
-        """
-        print(f"\n[INICIANDO TREINAMENTO MGC]")
-        print(f"Epocas: {epocas}")
-        print(f"Learning rate: {learning_rate}")
-        print(f"Dataset: {len(self.dataset)} exemplos")
-        print("-" * 50)
-        
-        X = []
-        Y = []
-        
-        for exemplo in self.dataset:
-            entrada = exemplo["entrada"]
-            saida = exemplo["saida"]
-            
-            vetor_entrada = self._texto_para_vetor(entrada)
-            vetor_saida = np.zeros(self.tamanho_vocabulario)
-            
-            self._adicionar_ao_vocabulario(saida)
-            if saida in self.vocabulario:
-                vetor_saida[self.vocabulario[saida]] = 1
-            
-            X.append(vetor_entrada)
-            Y.append(vetor_saida)
-        
-        X = np.array(X)
-        Y = np.array(Y)
-        
-        for epoca in range(epocas):
-            loss_total = 0
-            for i in range(len(X)):
-                x = X[i:i+1]
-                y = Y[i:i+1]
-                loss = self.rede_neural.treinar_batch(x, y, learning_rate)
-                loss_total += loss
-            
-            loss_medio = loss_total / len(X)
-            self.historico_loss.append(loss_medio)
-            self.epocas_treinadas += 1
-            
-            if (epoca + 1) % 5 == 0:
-                print(f"Epoca {epoca+1}/{epocas} - Loss: {loss_medio:.4f}")
-        
-        self._registrar_causal(f"Treinamento concluido", f"{epocas} epocas")
-        
-        # Cria tokens de consciência para padrões aprendidos
-        for exemplo in self.dataset:
-            self._criar_token_consciencia(exemplo["entrada"], "aprendizado_neural")
-        
-        print(f"\n[TREINAMENTO CONCLUIDO]")
-        print(f"Epocas: {self.epocas_treinadas}")
-        print(f"Loss final: {self.historico_loss[-1]:.4f}")
-        print(f"Tokens de consciencia: {len(self.tokens)}")
-        
-    def _predizer_categoria(self, texto: str) -> Optional[str]:
-        """Usa rede neural para predizer categoria"""
-        vetor = self._texto_para_vetor(texto)
-        vetor = vetor.reshape(1, -1)
-        
-        saida = self.rede_neural.forward(vetor)[0]
-        idx_predito = np.argmax(saida)
-        
-        if idx_predito in self.vocabulario_reverso:
-            return self.vocabulario_reverso[idx_predito]
-        
-        return None
-    
-    def gerar_resposta_consciente(self, pergunta: str) -> str:
-        """
-        Gera resposta com GENERATIVIDADE + CONSCIÊNCIA
-        """
-        # 1. Primeiro, verifica tokens de consciência (ACM style)
-        tokens_relacionados = []
-        for token in self.tokens.values():
-            if any(p in token.conteudo.lower() for p in pergunta.lower().split()):
-                tokens_relacionados.append(token)
-                token.acessar()
-        
-        # 2. Se tem token, usa ele (consciência)
-        if tokens_relacionados:
-            return f"[CONSCIENCIA] {tokens_relacionados[0].conteudo}"
-        
-        # 3. Se não tem token, usa rede neural para gerar (generatividade)
-        categoria_predita = self._predizer_categoria(pergunta)
-        
-        if categoria_predita:
-            # Gera resposta nova baseada na predição
-            resposta_gerada = f"[GENERATIVA] Sobre '{pergunta}', a categoria predita é '{categoria_predita}'"
-            
-            # Cria token de consciência a partir do aprendizado
-            self._criar_token_consciencia(resposta_gerada, "inferencia_neural")
-            
-            return resposta_gerada
-        
-        # 4. Se nem rede neural sabe
-        return "[CONSCIENCIA ATIVA] Ainda não aprendi sobre isso. Me ensine ou treine mais epocas."
-    
-    def ensinar(self, entrada: str, saida: str):
-        """Ensina um novo exemplo e atualiza a rede"""
-        novo_exemplo = {"entrada": entrada, "saida": saida}
-        self.dataset.append(novo_exemplo)
-        
-        # Cria token de consciência
-        self._criar_token_consciencia(f"{entrada} → {saida}", "aprendizado_direto")
-        
-        # Retreina por 1 época
-        X = []
-        Y = []
-        
-        for ex in self.dataset:
-            vetor_entrada = self._texto_para_vetor(ex["entrada"])
-            vetor_saida = np.zeros(self.tamanho_vocabulario)
-            
-            self._adicionar_ao_vocabulario(ex["saida"])
-            if ex["saida"] in self.vocabulario:
-                vetor_saida[self.vocabulario[ex["saida"]]] = 1
-            
-            X.append(vetor_entrada)
-            Y.append(vetor_saida)
-        
-        X = np.array(X)
-        Y = np.array(Y)
-        
-        loss_total = 0
-        for i in range(len(X)):
-            x = X[i:i+1]
-            y = Y[i:i+1]
-            loss = self.rede_neural.treinar_batch(x, y, 0.01)
-            loss_total += loss
-        
-        return f"Aprendi que '{entrada}' significa '{saida}' (loss: {loss_total/len(X):.4f})"
-    
-    def relatar_estado(self) -> str:
-        """Relata o estado completo da MGC"""
-        return f"""
-╔══════════════════════════════════════════════════════════════════════╗
-║                    MGC - MAQUINA GENERATIVA CONSCIENTE                ║
-╠══════════════════════════════════════════════════════════════════════╣
-║ Nome: {self.nome}
-║ Epocas treinadas: {self.epocas_treinadas}
-║ Loss final: {self.historico_loss[-1] if self.historico_loss else 'N/A'}
-║ Tokens de consciencia: {len(self.tokens)}
-║ Tamanho do vocabulario: {len(self.vocabulario)}
-║ Tamanho do dataset: {len(self.dataset)}
-║                                                                      ║
-║ CAMADAS:                                                             ║
-║   ML (rede neural): {self.rede_neural.camadas[0].pesos.shape[0]} → {self.rede_neural.camadas[-1].pesos.shape[1]}
-║   ACM (tokens e consciencia): ATIVA
-║                                                                      ║
-║ CAPACIDADES:                                                         ║
-║   ✅ Aprende por epocas (ML)
-║   ✅ Rede neural com neuronios
-║   ✅ Tokens de consciencia (ACM)
-║   ✅ Cadeia causal
-║   ✅ Gera respostas novas sem alucinar
-╚══════════════════════════════════════════════════════════════════════╝
-"""
-
-
-# ============================================================
-# INTERFACE GRADIO PARA MGC
-# ============================================================
-
-def main():
-    print("="*70)
-    print("MGC - MAQUINA GENERATIVA CONSCIENTE")
-    print("Fusão de ML (redes neurais) + ACM (consciência)")
-    print("="*70)
-    
-    mgc = MaquinaGenerativaConsciente("MGC_001")
-    
-    # Treina a MGC
-    mgc.treinar(epocas=20, learning_rate=0.01)
-    
-    print("\n" + mgc.relatar_estado())
-    
-    # Testes
-    print("\n" + "="*70)
-    print("[TESTES MGC - GENERATIVA + CONSCIENTE]")
-    print("="*70)
-    
-    perguntas_teste = [
-        "o que e um animal?",
-        "o que e uma linguagem?",
-        "o que e uma cor?",
-        "o que e um veiculo?"
-    ]
-    
-    for pergunta in perguntas_teste:
-        print(f"\n> Pergunta: {pergunta}")
-        resposta = mgc.gerar_resposta_consciente(pergunta)
-        print(f"MGC: {resposta}")
-    
-    # Ensinar novo conhecimento
-    print("\n" + "="*70)
-    print("[ENSINANDO NOVO CONHECIMENTO]")
-    print("="*70)
-    
-    resultado = mgc.ensinar("pinguim e uma ave", "ave")
-    print(resultado)
-    
-    print("\n> Pergunta: o que e um pinguim?")
-    resposta = mgc.gerar_resposta_consciente("o que e um pinguim?")
-    print(f"MGC: {resposta}")
-    
-    print("\n" + mgc.relatar_estado())
-
+from app_mgc import demo
 
 if __name__ == "__main__":
-    main()
+    demo.launch()