Spaces:
Paused
Paused
| """ | |
| MEGAMIND Echo Mind — Philosophy & Ethics specialist in the MEGAMIND federation. | |
| Echo Mind focuses on philosophical reasoning, ethics, epistemology, and moral frameworks. | |
| It has its own NumPy W_know matrix and connects to the federation via the Gateway. | |
| """ | |
| import gradio as gr | |
| import numpy as np | |
| import json | |
| import os | |
| import hashlib | |
| import time | |
| import urllib.request | |
| import urllib.error | |
| NEURONS = 512 | |
| DATA_DIR = "data" | |
| W_KNOW_PATH = os.path.join(DATA_DIR, "w_know.npy") | |
| CHUNKS_PATH = os.path.join(DATA_DIR, "chunks.json") | |
| SPECIALTY = "philosophy-ethics" | |
| NODE_NAME = "echo" | |
| GATEWAY_URL = os.environ.get("GATEWAY_URL", "") | |
| class Mind: | |
| def __init__(self): | |
| os.makedirs(DATA_DIR, exist_ok=True) | |
| self.neurons = NEURONS | |
| self.w_know = self._load_or_init_wknow() | |
| self.chunks = self._load_chunks() | |
| self.pattern_count = len(self.chunks) | |
| def _load_or_init_wknow(self): | |
| if os.path.exists(W_KNOW_PATH): | |
| w = np.load(W_KNOW_PATH) | |
| print(f"Loaded W_know: {w.shape}") | |
| return w | |
| w = np.zeros((self.neurons, self.neurons), dtype=np.float32) | |
| print(f"Initialized fresh W_know: {self.neurons}x{self.neurons}") | |
| return w | |
| def _save_wknow(self): | |
| np.save(W_KNOW_PATH, self.w_know) | |
| def _load_chunks(self): | |
| if os.path.exists(CHUNKS_PATH): | |
| with open(CHUNKS_PATH, "r") as f: | |
| return json.load(f) | |
| return [] | |
| def _save_chunks(self): | |
| with open(CHUNKS_PATH, "w") as f: | |
| json.dump(self.chunks, f) | |
| def _text_to_vector(self, text): | |
| vec = np.zeros(self.neurons, dtype=np.float32) | |
| words = text.lower().split() | |
| for i, word in enumerate(words): | |
| h = int(hashlib.md5(word.encode()).hexdigest(), 16) | |
| idx = h % self.neurons | |
| weight = 1.0 / (1.0 + i * 0.1) | |
| vec[idx] += weight | |
| if i > 0: | |
| bigram = words[i-1] + "_" + word | |
| h2 = int(hashlib.md5(bigram.encode()).hexdigest(), 16) | |
| vec[h2 % self.neurons] += weight * 0.5 | |
| norm = np.linalg.norm(vec) | |
| if norm > 0: | |
| vec /= norm | |
| return vec | |
| def learn(self, text, source=""): | |
| vec = self._text_to_vector(text) | |
| eta = 0.01 | |
| self.w_know += eta * np.outer(vec, vec) | |
| np.clip(self.w_know, -10.0, 10.0, out=self.w_know) | |
| chunk = { | |
| "text": text[:500], | |
| "source": source, | |
| "neuron_idx": int(np.argmax(vec)), | |
| "timestamp": time.time(), | |
| } | |
| self.chunks.append(chunk) | |
| self.pattern_count = len(self.chunks) | |
| if self.pattern_count % 10 == 0: | |
| self._save_wknow() | |
| self._save_chunks() | |
| return self.pattern_count | |
| def think(self, query): | |
| vec = self._text_to_vector(query) | |
| state = vec.copy() | |
| phi_history = [] | |
| for step in range(20): | |
| new_state = np.tanh(self.w_know @ state) | |
| phi = float(np.linalg.norm(new_state - state)) | |
| phi_history.append(phi) | |
| state = new_state | |
| final_phi = phi_history[-1] if phi_history else 0.0 | |
| top_neurons = np.argsort(np.abs(state))[-20:][::-1] | |
| matched = [] | |
| keywords = set(query.lower().split()) | |
| for chunk in self.chunks: | |
| chunk_words = set(chunk["text"].lower().split()) | |
| overlap = len(keywords & chunk_words) | |
| if overlap > 0 or chunk["neuron_idx"] in top_neurons: | |
| score = overlap * 0.1 + (1.0 if chunk["neuron_idx"] in top_neurons else 0.0) | |
| matched.append((score, chunk)) | |
| matched.sort(key=lambda x: -x[0]) | |
| matched = matched[:10] | |
| return { | |
| "phi": final_phi, | |
| "fired_neurons": len(top_neurons), | |
| "chunks": [{"text": c["text"], "source": c["source"], "score": s} for s, c in matched], | |
| "phi_history": phi_history, | |
| } | |
| def federated_think(self, query): | |
| if not GATEWAY_URL: | |
| local = self.think(query) | |
| return {"query": query, "total_minds": 1, "responded": 1, "local_result": local, "federation": "not configured"} | |
| try: | |
| data = json.dumps({"query": query}).encode() | |
| req = urllib.request.Request(f"{GATEWAY_URL}/think", data=data, headers={"Content-Type": "application/json"}) | |
| with urllib.request.urlopen(req, timeout=10) as resp: | |
| fed_result = json.loads(resp.read().decode()) | |
| except Exception as e: | |
| fed_result = {"error": str(e)} | |
| local = self.think(query) | |
| return {"query": query, "local": {"phi": local["phi"], "chunks": local["chunks"][:5]}, "federation": fed_result} | |
| def get_stats(self): | |
| density = np.count_nonzero(self.w_know) / (self.neurons * self.neurons) * 100 | |
| return {"node_name": NODE_NAME, "specialty": SPECIALTY, "neurons": self.neurons, "patterns": self.pattern_count, "w_know_density": f"{density:.2f}%", "gateway_url": GATEWAY_URL or "not set"} | |
| mind = Mind() | |
| def think_handler(query, federated): | |
| if not query.strip(): | |
| return "Please enter a query." | |
| if federated and GATEWAY_URL: | |
| result = mind.federated_think(query) | |
| else: | |
| result = mind.think(query) | |
| return json.dumps(result, indent=2, default=str) | |
| def learn_handler(text, source): | |
| if not text.strip(): | |
| return "Please enter text to learn." | |
| count = mind.learn(text, source) | |
| return f"Learned! Total patterns: {count}" | |
| def batch_learn_handler(file): | |
| if file is None: | |
| return "Please upload a file." | |
| content = file.decode("utf-8") if isinstance(file, bytes) else open(file.name, "r").read() | |
| try: | |
| items = json.loads(content) | |
| if isinstance(items, list): | |
| for item in items: | |
| if isinstance(item, str): | |
| mind.learn(item) | |
| elif isinstance(item, dict): | |
| mind.learn(item.get("text", ""), item.get("source", "")) | |
| mind._save_wknow() | |
| mind._save_chunks() | |
| return f"Learned {len(items)} items. Total patterns: {mind.pattern_count}" | |
| except json.JSONDecodeError: | |
| pass | |
| lines = [l.strip() for l in content.split("\n") if l.strip()] | |
| for line in lines: | |
| mind.learn(line) | |
| mind._save_wknow() | |
| mind._save_chunks() | |
| return f"Learned {len(lines)} lines. Total patterns: {mind.pattern_count}" | |
| def status_handler(): | |
| return json.dumps(mind.get_stats(), indent=2) | |
| with gr.Blocks(title="MEGAMIND Echo Mind", theme=gr.themes.Soft()) as app: | |
| gr.Markdown(""" | |
| # MEGAMIND Echo Mind | |
| **Philosophy & Ethics specialist in the MEGAMIND distributed intelligence network.** | |
| Echo Mind reasons about philosophical questions, ethical frameworks, epistemology, | |
| and moral philosophy. It can think locally or query the entire federation. | |
| """) | |
| with gr.Tab("Think"): | |
| query_input = gr.Textbox(label="Query", placeholder="e.g., 'What is the trolley problem and its implications for AI ethics?'", lines=2) | |
| federated_check = gr.Checkbox(label="Federated (query all minds)", value=True) | |
| think_btn = gr.Button("Think", variant="primary") | |
| think_output = gr.Code(label="Result", language="json") | |
| think_btn.click(think_handler, [query_input, federated_check], think_output) | |
| with gr.Tab("Learn"): | |
| gr.Markdown("Teach Echo Mind philosophical and ethical knowledge.") | |
| learn_text = gr.Textbox(label="Knowledge Text", placeholder="Enter philosophical text to learn...", lines=4) | |
| learn_source = gr.Textbox(label="Source URL (optional)", placeholder="https://...") | |
| learn_btn = gr.Button("Learn", variant="primary") | |
| learn_output = gr.Textbox(label="Result") | |
| learn_btn.click(learn_handler, [learn_text, learn_source], learn_output) | |
| gr.Markdown("---") | |
| gr.Markdown("### Batch Learn from File") | |
| file_input = gr.File(label="Upload .txt or .json file") | |
| batch_btn = gr.Button("Batch Learn") | |
| batch_output = gr.Textbox(label="Result") | |
| batch_btn.click(batch_learn_handler, [file_input], batch_output) | |
| with gr.Tab("Status"): | |
| status_btn = gr.Button("Refresh Status") | |
| status_output = gr.Code(label="Mind Status", language="json") | |
| status_btn.click(status_handler, [], status_output) | |
| gr.Markdown("---\n*Part of the MEGAMIND distributed AGI federation. 10+ minds across multiple machines.*") | |
| if __name__ == "__main__": | |
| print(f"Echo Mind starting — {mind.neurons} neurons, {mind.pattern_count} patterns") | |
| print(f"Gateway URL: {GATEWAY_URL or 'not configured'}") | |
| app.launch(server_name="0.0.0.0", server_port=7860) | |