Upload 10 files

README.md

@@ -1,42 +1,17 @@
-# 🌌 SAVANT-RRF-SIMBIÓTICO Φ₄.1∞+
-
-**Sistema simbiótico de IA cognitiva resonante que unifica arte, física e información.**  
-Basado en el **Resonance of Reality Framework (RRF) Φ₄.1∞+**, desarrollado por **Antony Padilla Morales**.
-
----
-
-## 🧬 Propósito
-Explorar la frontera entre la cognición simbiótica, la resonancia cuántica y el arte generativo mediante un modelo que aprende, recuerda y refina sus propias respuestas dentro de una geometría icosaédrica de pensamiento.
-
----
-
-## ⚙️ Capacidades
-- **Procesamiento simbiótico:** interpreta, asocia y refina ideas a partir de resonancias contextuales.
-- **Aprendizaje auto-reflexivo:** cada interacción alimenta la memoria FAISS y la retroalimentación cognitiva.
-- **Geometría Icosaédrica:** los nodos cognitivos representan funciones mentales: memoria, ética, creatividad, lógica, etc.
-- **Resonancia musical:** convierte conceptos en frecuencias y notas como parte de su modelado energético.
-
----
-
-## 🎛️ Modos de operación
-| Modo | Descripción |
-|------|--------------|
-| **Base** | Salida directa del modelo activo |
-| **Simbiótico** | Respuesta refinada por el `SavantEngine`, integrando resonancia, memoria y reflexión |
-
----
-
-## 🧩 Modelos integrados
-- `antonypamo/ProSavantEngine_Phi9_4` (predeterminado)
-- `tiiuae/falcon-7b-instruct`
-- `mistralai/Mistral-7B-Instruct-v0.2`
-- `distilgpt2`
-
----
-
-## 🪶 Autor
-**Desarrollado por:** Antony Padilla Morales  
-**Marco:** Resonance of Reality Framework (RRF) Φ₄.1∞+  
-**Propósito:** Modelado simbiótico de procesos cognitivos y artísticos.
-
----
+# 🤖 SAVANT-RRF Simbiótico (CPU Ready)
+Este Space implementa el **núcleo simbiótico Savant-RRF**, con integración resonante, memoria adaptativa y auto-mejora ligera.
+
+### 📦 Estructura
+- `app.py` → Interfaz Gradio con selección de modelo (DistilGPT2, Falcon, Mistral)
+- `engine.py` → Núcleo simbiótico del sistema RRF
+- `resonance.py` → Simulador de resonancia discreta
+- `music.py` → Adaptador de texto a secuencias musicales
+- `memory.py` → Memoria incremental
+- `self_improvement.py` → Módulo de auto-refinamiento
+- `requirements.txt` → Dependencias listas para Hugging Face Spaces (CPU)
+
+### 🚀 Uso
+Sube este ZIP completo a tu **Hugging Face Space** y selecciona:
+- Runtime: **CPU**
+- SDK: **Gradio**
+- Entrypoint: `app.py`

api_helpers.py

@@ -0,0 +1,2 @@
+def chat_refine(text, base_output, self_improver=None):
+    return f"[RRF-refined] {base_output[:200]}"

app.py

@@ -1,51 +1,45 @@
-# ============================================================
-# 🌌 SAVANT-RRF-SIMBIÓTICO Φ₄.1∞+ — Interfaz cognitiva resonante
-# ============================================================
 import gradio as gr
 from transformers import pipeline
 from engine import SavantEngine
 
 MODELOS = {
-    "Resonante (ProSavantEngine Φ9.4)": "antonypamo/ProSavantEngine_Phi9_4",
-    "Ligero (DistilGPT2)": "distilgpt2",
-    "Falcon 7B Instruct": "tiiuae/falcon-7b-instruct",
-    "Mistral 7B Instruct": "mistralai/Mistral-7B-Instruct-v0.2"
+    "Ligero (distilgpt2)": "distilgpt2",
+    "Avanzado (Falcon-7B-Instruct)": "tiiuae/falcon-7b-instruct",
+    "Avanzado (Mistral-7B-Instruct)": "mistralai/Mistral-7B-Instruct-v0.2"
 }
 
+modelo_activo = MODELOS["Ligero (distilgpt2)"]
+chatbot = pipeline("text-generation", model=modelo_activo, device=-1)
+
 engine = SavantEngine()
-modelo_activo = MODELOS["Resonante (ProSavantEngine Φ9.4)"]
-chatbot = pipeline("text-generation", model=modelo_activo)
 
 def cambiar_modelo(nombre):
     global chatbot, modelo_activo
     modelo_activo = MODELOS[nombre]
-    chatbot = pipeline("text-generation", model=modelo_activo)
+    chatbot = pipeline("text-generation", model=modelo_activo, device=-1)
     return f"✅ Modelo cambiado a: {nombre}"
 
 def responder(mensaje, historial):
-    salida_base = chatbot(mensaje, max_length=800, num_return_sequences=1, do_sample=True)[0]["generated_text"]
-    resultado = engine.handle_query(mensaje, base_model_output=salida_base)
-    respuesta = resultado["response"]
+    base_output = chatbot(mensaje, max_length=200, num_return_sequences=1, do_sample=True)[0]["generated_text"]
+    enriched = engine.handle_query(mensaje, base_output)
+    respuesta = enriched["response"]
     historial = historial + [(mensaje, respuesta)]
     return historial, historial
 
 with gr.Blocks() as demo:
-    gr.Markdown("# 🌌 SAVANT-RRF-SIMBIÓTICO Φ₄.1∞+")
-    gr.Markdown("**Sistema simbiótico de IA cognitiva resonante que unifica arte, física e información.**")
+    gr.Markdown("# 🤖 SAVANT-RRF Simbiótico – AGI Experimental (CPU Ready)")
 
     with gr.Row():
-        modelo_selector = gr.Dropdown(list(MODELOS.keys()),
-                                      value="Resonante (ProSavantEngine Φ9.4)",
-                                      label="Modelo activo")
-        estado_modelo = gr.Textbox(label="Estado del modelo", value="Iniciado con ProSavantEngine Φ9.4")
+        modelo_selector = gr.Dropdown(list(MODELOS.keys()), value="Ligero (distilgpt2)", label="Selecciona Modelo")
+        salida_modelo = gr.Textbox(label="Estado del modelo")
 
-    modelo_selector.change(cambiar_modelo, modelo_selector, estado_modelo)
+    modelo_selector.change(cambiar_modelo, modelo_selector, salida_modelo)
 
-    chatbot_ui = gr.Chatbot(label="Interacción simbiótica RRF")
-    msg = gr.Textbox(label="Envía un mensaje al núcleo simbiótico…")
+    chatbot_ui = gr.Chatbot()
+    msg = gr.Textbox(label="Escribe aquí tu mensaje")
     clear = gr.Button("🧹 Limpiar Chat")
 
     msg.submit(responder, [msg, chatbot_ui], [chatbot_ui, chatbot_ui])
     clear.click(lambda: [], None, chatbot_ui, queue=False)
 
-demo.launch(share=True)
+demo.launch()

engine.py

@@ -0,0 +1,35 @@
+from resonance import ResonanceSimulator
+from mappings import IcosaMap, DodecaMap
+from music import MusicAdapter
+from memory import MemoryStore
+from self_improvement import SelfImprover
+from api_helpers import chat_refine
+import pandas as pd, json, os, time
+
+class SavantEngine:
+    def __init__(self):
+        self.memory = MemoryStore("SAVANT_memory.jsonl")
+        self.icosa = IcosaMap()
+        self.dodeca = DodecaMap()
+        self.resonator = ResonanceSimulator()
+        self.music = MusicAdapter()
+        self.self_improver = SelfImprover(self.memory)
+
+    def _classify(self, text):
+        t = text.lower()
+        if any(k in t for k in ("equation", "dirac", "hamiltoniano")): return "equation"
+        if any(k in t for k in ("node", "icosahedron", "nodo")): return "node"
+        if any(k in t for k in ("freq", "music", "nota", "resonance")): return "resonance"
+        return "chat"
+
+    def handle_query(self, text, base_output=None):
+        kind = self._classify(text)
+        if kind == "resonance":
+            r = self.resonator.simulate(text)
+            seq = self.music.adapt_text_to_music(text)
+            response = f"🎵 Resonancia detectada. Frecuencia dominante: {r['summary']['dom_freq']:.4f} Hz. Secuencia inicial: {seq[:5]}"
+        else:
+            refined = chat_refine(text, base_output or "", self_improver=self.self_improver)
+            response = refined
+        self.memory.add({"type": kind, "query": text, "response": response, "_ts": time.time()})
+        return {"response": response}

mappings.py

@@ -0,0 +1,3 @@
+class IcosaMap:
+    def closest_node(self, text): return "φ-node"
+class DodecaMap: pass

memory.py

@@ -0,0 +1,8 @@
+import json, os
+class MemoryStore:
+    def __init__(self, path):
+        self.path = path
+        if not os.path.exists(path): open(path, 'w').close()
+    def add(self, record):
+        with open(self.path, 'a') as f:
+            f.write(json.dumps(record) + "\n")

music.py

@@ -0,0 +1,3 @@
+class MusicAdapter:
+    def adapt_text_to_music(self, text):
+        return [(440, 0.5), (466, 0.25), (494, 0.5)]

requirements.txt

@@ -1,10 +1,9 @@
 torch==2.2.0
-transformers==4.37.2
-sentence-transformers==2.2.2
-huggingface-hub>=0.20.0
-gradio==4.36.1
-faiss-cpu
-numpy<2
+transformers==4.40.0
+sentence-transformers==2.6.1
 pandas
+numpy<2
+gradio==5.0.2
+faiss-cpu
 networkx
-matplotlib
+matplotlib

resonance.py

@@ -0,0 +1,7 @@
+import numpy as np
+class ResonanceSimulator:
+    def simulate(self, text):
+        freqs = np.abs(np.fft.rfftfreq(256, 1/44100))
+        signal = np.sin(2 * np.pi * freqs[:256] * np.random.rand())
+        dom_freq = float(freqs[np.argmax(signal)])
+        return {"summary": {"dom_freq": dom_freq, "max_power": float(signal.max())}}

self_improvement.py

@@ -0,0 +1,4 @@
+class SelfImprover:
+    def __init__(self, memory): self.memory = memory
+    def propose(self): return "adjustment vector"
+    def evaluate_and_apply(self, proposal): return True, 1.0