Njap-png
Add Agron neural-network zoo, optimisers, algorithms, schedulers and unified trainer
a311e94 | import os | |
| import json | |
| import sys | |
| import time | |
| import random | |
| import threading | |
| import subprocess | |
| import urllib.request | |
| import requests | |
| from bs4 import BeautifulSoup | |
| import torch | |
| import gradio as gr | |
| from datasets import Dataset | |
| from transformers import LlamaConfig, LlamaForCausalLM, PreTrainedTokenizerFast, Trainer, TrainingArguments, DataCollatorForLanguageModeling | |
| from safetensors.torch import load_file, save_file | |
| from agron_nets import ( | |
| ARCHITECTURES, | |
| RECIPES, | |
| algorithm_names, | |
| architecture_names, | |
| build_architecture, | |
| count_parameters, | |
| format_parameters, | |
| optimizer_names, | |
| scheduler_names, | |
| ) | |
| from agron_nets.training import AgronTrainer, TrainerConfig, get_recipe, recipe_names | |
| ROOT = os.path.dirname(os.path.abspath(__file__)) | |
| MEMORY_DIR = os.path.join(ROOT, "memory") | |
| INTERACTIONS_FILE = os.path.join(MEMORY_DIR, "interactions.jsonl") | |
| os.makedirs(MEMORY_DIR, exist_ok=True) | |
| def _pick_work_dir(): | |
| """Writable scratch dir for training artifacts (works on HF Spaces where /content may not exist).""" | |
| candidates = [os.environ.get("AGRON_WORK_DIR"), "/content", os.path.join(ROOT, "workspace")] | |
| for cand in candidates: | |
| if not cand: | |
| continue | |
| try: | |
| os.makedirs(cand, exist_ok=True) | |
| probe = os.path.join(cand, ".agron_write_probe") | |
| with open(probe, "w") as f: | |
| f.write("ok") | |
| os.remove(probe) | |
| return cand | |
| except Exception: | |
| continue | |
| return ROOT | |
| WORK_DIR = _pick_work_dir() | |
| # Deployment / runtime configuration | |
| VOICE_MODEL_ID = os.environ.get("AGRON_VOICE_MODEL", "Qwen/Qwen2.5-3B-Instruct") | |
| USE_VOICE = os.environ.get("AGRON_USE_VOICE", "1").strip().lower() not in ("0", "false", "no") | |
| AUTO_PUSH = os.environ.get("AGRON_AUTO_PUSH", "1").strip().lower() not in ("0", "false", "no") | |
| SERVER_PORT = int(os.environ.get("AGRON_PORT", "7860")) | |
| SERVER_NAME = os.environ.get("AGRON_HOST", "0.0.0.0") | |
| SHARE = os.environ.get("AGRON_SHARE", "0").strip().lower() in ("1", "true", "yes") | |
| IO_LOCK = threading.Lock() | |
| TRAIN_LOCK = threading.Lock() | |
| # --------------------------------------------------------------------------- # | |
| # Neural-network zoo selection | |
| # --------------------------------------------------------------------------- # | |
| # The reference checkpoint is a 50.3M-parameter LLaMA; the same preset is used | |
| # for every other architecture so they are directly comparable at runtime. | |
| AGRON_PRESET = dict( | |
| vocab_size=16384, | |
| hidden_size=512, | |
| intermediate_size=2048, | |
| num_hidden_layers=8, | |
| num_attention_heads=4, | |
| num_key_value_heads=4, | |
| max_position_embeddings=512, | |
| bos_token_id=0, | |
| eos_token_id=2, | |
| pad_token_id=1, | |
| tie_word_embeddings=False, | |
| ) | |
| ACTIVE_ARCH = os.environ.get("AGRON_ARCH", "llama").strip().lower() | |
| if ACTIVE_ARCH not in ARCHITECTURES: | |
| ACTIVE_ARCH = "llama" | |
| interactions = [] | |
| training_state = {"running": False, "steps": 0, "last": "idle", "count_at_train": 0} | |
| LAST_TRAIN_TIME = 0.0 | |
| def load_interactions(): | |
| global interactions | |
| interactions = [] | |
| if os.path.exists(INTERACTIONS_FILE): | |
| with open(INTERACTIONS_FILE, "r") as f: | |
| for line in f: | |
| line = line.strip() | |
| if line: | |
| try: | |
| interactions.append(json.loads(line)) | |
| except Exception: | |
| pass | |
| def git_auto_push(message, paths): | |
| """Stage `paths`, commit and push to origin (Hugging Face). Returns (ok, detail).""" | |
| if not AUTO_PUSH: | |
| return False, "auto-push disabled (AGRON_AUTO_PUSH=0)" | |
| try: | |
| for p in paths: | |
| subprocess.run(["git", "-C", ROOT, "add", "--", p], check=False) | |
| staged = subprocess.run( | |
| ["git", "-C", ROOT, "diff", "--cached", "--name-only"], | |
| capture_output=True, text=True, check=False, | |
| ).stdout.strip() | |
| if not staged: | |
| return True, "no changes to push" | |
| status = subprocess.run(["git", "-C", ROOT, "status", "--porcelain"], | |
| capture_output=True, text=True, check=True).stdout.strip() | |
| if not status: | |
| return True, "no changes to push" | |
| # make sure a committer identity exists (Spaces do not ship one) | |
| for key, val in (("user.name", "Agron"), ("user.email", "agron@users.noreply.huggingface.co")): | |
| if not subprocess.run(["git", "-C", ROOT, "config", "--get", key], | |
| capture_output=True, text=True).stdout.strip(): | |
| subprocess.run(["git", "-C", ROOT, "config", key, val], check=False) | |
| branch = subprocess.run(["git", "-C", ROOT, "rev-parse", "--abbrev-ref", "HEAD"], | |
| capture_output=True, text=True).stdout.strip() or "main" | |
| subprocess.run(["git", "-C", ROOT, "commit", "-m", message], check=True) | |
| subprocess.run(["git", "-C", ROOT, "push", "origin", f"HEAD:{branch}"], check=True) | |
| return True, f"pushed to Hugging Face ({branch})" | |
| except Exception as e: | |
| return False, f"push error: {str(e)[:150]}" | |
| TOPICS_FILE = os.path.join(MEMORY_DIR, "learned_topics.json") | |
| learned_topics = [] | |
| def load_topics(): | |
| global learned_topics | |
| learned_topics = [] | |
| if os.path.exists(TOPICS_FILE): | |
| try: | |
| with open(TOPICS_FILE, "r") as f: | |
| learned_topics = json.load(f) | |
| except Exception: | |
| learned_topics = [] | |
| def persist_topics(): | |
| global learned_topics | |
| with IO_LOCK: | |
| normalized = ["dictionary words" if str(x).startswith("dictionary words") else x for x in learned_topics] | |
| learned_topics = list(dict.fromkeys(normalized)) | |
| with open(TOPICS_FILE, "w") as f: | |
| json.dump(learned_topics, f) | |
| def persist_interaction(rec): | |
| global interactions | |
| with IO_LOCK: | |
| interactions.append(rec) | |
| with open(INTERACTIONS_FILE, "a") as f: | |
| f.write(json.dumps(rec) + "\n") | |
| def build_tokenizer(): | |
| tok = PreTrainedTokenizerFast(tokenizer_file=os.path.join(ROOT, "tokenizer.json")) | |
| tok.pad_token = "<pad>" | |
| tok.bos_token = "<s>" | |
| tok.eos_token = "</s>" | |
| tok.unk_token = "<unk>" | |
| tok.mask_token = "<mask>" | |
| return tok | |
| def build_model(arch=None, load_published=True): | |
| """Build one architecture from the zoo and load the best weights available. | |
| ``llama`` keeps loading the published ``model.safetensors`` so the shipped | |
| Agron brain is preserved. Every other architecture loads its own latest | |
| checkpoint from ``WORK_DIR`` when one exists. | |
| """ | |
| arch = (arch or ACTIVE_ARCH or "llama").strip().lower() | |
| device = "cuda" if torch.cuda.is_available() else "cpu" | |
| if arch == "llama": | |
| model, _ = build_architecture("llama", **AGRON_PRESET) | |
| weights = os.path.join(ROOT, "model.safetensors") | |
| if load_published and os.path.exists(weights): | |
| try: | |
| model.load_state_dict(load_file(weights)) | |
| print("Loaded published Agron weights:", weights) | |
| except Exception as exc: | |
| print("Published weights incompatible, using fresh init:", exc) | |
| else: | |
| model, _ = build_architecture(arch, **AGRON_PRESET) | |
| saved = os.path.join(WORK_DIR, f"agron-{arch}", "final") | |
| if load_published and os.path.exists(os.path.join(saved, "config.json")): | |
| try: | |
| from transformers import AutoModelForCausalLM | |
| model = AutoModelForCausalLM.from_pretrained(saved) | |
| print(f"Loaded {arch} checkpoint: {saved}") | |
| except Exception as exc: | |
| print(f"Could not load {arch} checkpoint, using fresh init:", exc) | |
| model.to(device) | |
| model.eval() | |
| return model, device | |
| TOKENIZER = build_tokenizer() | |
| MODEL, DEVICE = build_model() | |
| load_interactions() | |
| VOICE_ID = VOICE_MODEL_ID | |
| VOICE_TOK = None | |
| VOICE_MODEL = None | |
| if USE_VOICE: | |
| try: | |
| from transformers import AutoTokenizer as _ATok, AutoModelForCausalLM as _AModel | |
| print("Loading voice model:", VOICE_ID) | |
| VOICE_TOK = _ATok.from_pretrained(VOICE_ID) | |
| VOICE_MODEL = _AModel.from_pretrained(VOICE_ID, dtype=__import__("torch").float16, device_map="auto") | |
| VOICE_MODEL.eval() | |
| print("Voice model loaded:", VOICE_ID) | |
| except Exception as _ve: | |
| print("Voice model failed to load:", _ve) | |
| VOICE_TOK = None | |
| VOICE_MODEL = None | |
| else: | |
| print("Voice model disabled (AGRON_USE_VOICE=0) - using the native Agron base model") | |
| load_topics() | |
| if not learned_topics: | |
| learned_topics.append("base text model (WikiText-2)") | |
| persist_topics() | |
| def _normalize_history(history): | |
| pairs = [] | |
| if history and isinstance(history[0], dict): | |
| current_user = None | |
| for m in history: | |
| role = m.get("role") | |
| content = m.get("content") | |
| if role == "user": | |
| current_user = content | |
| elif role == "assistant" and current_user is not None: | |
| pairs.append((current_user, content)) | |
| current_user = None | |
| else: | |
| for h in history: | |
| if isinstance(h, (list, tuple)) and len(h) >= 2: | |
| pairs.append((h[0], h[1])) | |
| return pairs | |
| def _build_prompt(message, history): | |
| ctx_pairs = interactions[-5:] | |
| prompt = "Agron is a helpful, concise AI assistant.\n### Agron memory (learned from prior use)\n" | |
| for r in ctx_pairs: | |
| prompt += f"User: {r['user']}\nAgron: {r['assistant']}\n" | |
| prompt += "### Conversation\n" | |
| for user_msg, assistant_msg in _normalize_history(history): | |
| prompt += f"User: {user_msg}\nAgron: {assistant_msg}\n" | |
| prompt += f"User: {message}\nAgron:" | |
| return prompt | |
| DEFAULT_MAX_NEW = 192 | |
| DEFAULT_TEMP = 0.6 | |
| DEFAULT_TOP_P = 0.85 | |
| def is_bad_response(text): | |
| import re | |
| t = (text or "").strip() | |
| if len(t) < 3: | |
| return True | |
| if "@-@" in t or t.count('"') > 6: | |
| return True | |
| if re.search(r"(.{8,})\\1", t): | |
| return True | |
| words = t.split() | |
| if len(words) > 120: | |
| return True | |
| # gibberish heuristic: too many short tokens | |
| if sum(1 for w in words if len(w) <= 2) > len(words) * 0.6 and len(words) > 12: | |
| return True | |
| if text.count("was a") >= 2 or text.count(" in the ") >= 2 or text.count(" the ") >= 6: | |
| return True | |
| if "@-@" in t or t.count('"') > 4: | |
| return True | |
| return False | |
| def safe_web_answer(query): | |
| """Grounded answer built from live search results (used when the model's own reply is unusable).""" | |
| try: | |
| results = web_search(query, 3) | |
| if not results: | |
| return None | |
| lines = [] | |
| for i, r in enumerate(results): | |
| sn = (r.get("snippet") or "").strip() | |
| if len(sn) < 20: | |
| page = crawl_page(r["url"]) | |
| sn = (page[:300] + "...") if page else sn | |
| if not sn: | |
| continue | |
| lines.append(f"{i + 1}. {r['title']} — {sn} ({r['url']})") | |
| return "\n".join(lines) if lines else None | |
| except Exception: | |
| pass | |
| return None | |
| def generate_response(message, history): | |
| low = message.strip().lower().strip("!?.,") | |
| greetings = {"hello", "hi", "hey", "greetings", "howdy", "yo"} | |
| search_intent = any(k in low for k in ["search", "find", "look up", "lookup", "browse", "web"]) | |
| if search_intent: | |
| res = web_search(message, 5) | |
| if res: | |
| lines = [f"{i+1}. {r['title']} — {r.get('snippet','')} ({r['url']})" for i, r in enumerate(res)] | |
| response = "Here are live web results:\n" + "\n".join(lines) | |
| persist_interaction({"ts": __import__("time").time(), "user": message, "assistant": response}) | |
| return response | |
| else: | |
| response = "I couldn't find web results for that query. Try rephrasing it." | |
| persist_interaction({"ts": __import__("time").time(), "user": message, "assistant": response}) | |
| return response | |
| if low in greetings: | |
| response = "Hello! I'm Agron, a self-improving neural interface. How can I help you today?" | |
| persist_interaction({"ts": __import__("time").time(), "user": message, "assistant": response}) | |
| return response | |
| if low in {"who are you", "what are you", "introduce yourself"}: | |
| response = ("I'm Agron, an autonomous self-improving multi-agent AI core trained on text and dictionary " | |
| "knowledge. I learn from our conversations—ask me anything.") | |
| persist_interaction({"ts": __import__("time").time(), "user": message, "assistant": response}) | |
| return response | |
| if low in {"what did you learn", "what have you learned", "what did you learn about", "what do you know"}: | |
| parts = [] | |
| if interactions: | |
| parts.append(f"{len(interactions)} conversation exchanges (latest: '{interactions[-1]['user'][:80]}')") | |
| if learned_topics: | |
| parts.append("learned topics: " + ", ".join(learned_topics[-12:])) | |
| else: | |
| parts.append("no specialized training runs yet, but I store every conversation") | |
| response = "I've learned from you and my training sources: " + "; ".join(parts) + "." | |
| persist_interaction({"ts": __import__("time").time(), "user": message, "assistant": response}) | |
| return response | |
| # Live web context is only useful for the voice model; the base model path falls | |
| # back to a grounded search answer only when its own reply is unusable. | |
| _web_ctx = "" | |
| if VOICE_MODEL is not None: | |
| try: | |
| if len(message.strip()) >= 4: | |
| _res = web_search(message, 3) | |
| _lines = [f"- {r['title']}: {r.get('snippet','')}" for r in _res if (r.get('snippet') or '').strip()] | |
| if _lines: | |
| _web_ctx = "Web search results (live):\n" + "\n".join(_lines[:3]) | |
| except Exception: | |
| _web_ctx = "" | |
| if VOICE_MODEL is not None: | |
| mem_lines = [f"User: {r['user']}\nAgron: {r['assistant']}" for r in interactions[-3:]] | |
| mem_ctx = "\n".join(mem_lines) | |
| user_content = message | |
| if mem_ctx: | |
| user_content = f"Relevant memory:\n{mem_ctx}\n\nUser: {message}" | |
| if _web_ctx: | |
| user_content = f"{_web_ctx}\n\n{user_content}\n\nAnswer using the live web results above." | |
| _msgs = [ | |
| {"role": "system", "content": "You are Agron, a self-improving AI assistant. Reason step-by-step (premises, plan, critique, refine), then answer concisely. Use live web search results when provided. Never say you cannot search or browse. If unsure, suggest 'Search & learn web'."}, | |
| {"role": "user", "content": user_content}, | |
| ] | |
| _prompt = VOICE_TOK.apply_chat_template(_msgs, tokenize=False, add_generation_prompt=True) | |
| with IO_LOCK: | |
| _inputs = VOICE_TOK(_prompt, return_tensors="pt").to(VOICE_MODEL.device) | |
| with torch.no_grad(): | |
| _out = VOICE_MODEL.generate( | |
| **_inputs, | |
| max_new_tokens=DEFAULT_MAX_NEW, | |
| do_sample=True, | |
| temperature=0.7, | |
| top_p=0.9, | |
| repetition_penalty=1.15, | |
| ) | |
| response = VOICE_TOK.decode(_out[0][_inputs.input_ids.shape[1]:], skip_special_tokens=True).strip() | |
| else: | |
| prompt = _build_prompt(message, history) | |
| with IO_LOCK: | |
| inputs = TOKENIZER(prompt, return_tensors="pt").to(DEVICE) | |
| input_len = inputs.input_ids.shape[1] | |
| with torch.no_grad(): | |
| output = MODEL.generate( | |
| **inputs, | |
| max_new_tokens=DEFAULT_MAX_NEW, | |
| do_sample=True, | |
| temperature=DEFAULT_TEMP, | |
| top_p=DEFAULT_TOP_P, | |
| pad_token_id=1, | |
| eos_token_id=2, | |
| repetition_penalty=1.4, | |
| no_repeat_ngram_size=3, | |
| top_k=40, | |
| ) | |
| new_tokens = output[0][input_len:] | |
| response = TOKENIZER.decode(new_tokens, skip_special_tokens=True).strip() | |
| for stop in ["\n\n", "User:", "user:"]: | |
| if stop in response: | |
| response = response.split(stop)[0].strip() | |
| import re | |
| response = re.sub(r"(.{6,})\1{2,}", r"\1", response).strip() | |
| if is_bad_response(response): | |
| sw = safe_web_answer(message) | |
| response = sw if sw else "I'm not sure. Could you rephrase, or use 'Search & learn web' to teach me." | |
| persist_interaction({ | |
| "ts": time.time(), | |
| "user": message, | |
| "assistant": response, | |
| }) | |
| # adaptive trigger: self-learn from every conversation (cooldown 30s) | |
| global LAST_TRAIN_TIME | |
| if len(interactions) >= 8 and not training_state["running"] and (time.time() - LAST_TRAIN_TIME) >= 300: | |
| LAST_TRAIN_TIME = time.time() | |
| threading.Thread(target=learn_from_scratch_memory, daemon=True).start() | |
| return response | |
| def zoo_summary(): | |
| """Human-readable inventory of everything the zoo can build.""" | |
| arch_lines = "\n".join( | |
| f"- **{name}** — {ARCHITECTURES[name]['label']}: {ARCHITECTURES[name]['description']}" | |
| for name in architecture_names() | |
| ) | |
| return ( | |
| f"**{len(ARCHITECTURES)} architectures · {len(optimizer_names())} optimisers · " | |
| f"{len(algorithm_names())} algorithms · {len(scheduler_names())} schedules · " | |
| f"{len(RECIPES)} recipes**\n\n{arch_lines}" | |
| ) | |
| def _resolve_zoo(optimizer=None, scheduler=None, recipe=None, algorithms=None): | |
| """Recipe values win unless the caller explicitly overrides them.""" | |
| if recipe and recipe not in ("custom", "none", ""): | |
| entry = get_recipe(recipe) | |
| return entry["optimizer"], entry["scheduler"], list(entry["algorithms"]) | |
| return (optimizer or "adamw"), (scheduler or "cosine"), list(algorithms or []) | |
| def _lm_loader(chunks, batch_size=2, block=None): | |
| """Wrap token blocks in a DataLoader whose batches satisfy the engine.""" | |
| def collate(rows): | |
| input_ids = torch.tensor([r["input_ids"] for r in rows], dtype=torch.long) | |
| labels = input_ids.clone() | |
| labels = labels.masked_fill(labels == TOKENIZER.pad_token_id, -100) | |
| return { | |
| "input_ids": input_ids, | |
| "labels": labels, | |
| "attention_mask": torch.ones_like(input_ids), | |
| } | |
| return torch.utils.data.DataLoader(chunks, batch_size=batch_size, shuffle=True, collate_fn=collate) | |
| def reload_live_model(model_dir): | |
| """Swap the live model for the freshly saved one, whatever the architecture.""" | |
| global MODEL, DEVICE | |
| try: | |
| from transformers import AutoModelForCausalLM | |
| device = "cuda" if torch.cuda.is_available() else "cpu" | |
| fresh = AutoModelForCausalLM.from_pretrained(model_dir) | |
| fresh.to(device) | |
| fresh.eval() | |
| with IO_LOCK: | |
| MODEL = fresh | |
| DEVICE = device | |
| return True | |
| except Exception as exc: | |
| print("live reload failed:", exc) | |
| return False | |
| def switch_architecture(arch): | |
| """Rebuild the runtime brain with another architecture from the zoo.""" | |
| global MODEL, DEVICE, ACTIVE_ARCH | |
| arch = (arch or "").strip().lower() | |
| if arch not in ARCHITECTURES: | |
| return f"unknown architecture: {arch}" | |
| with IO_LOCK: | |
| MODEL, DEVICE = build_model(arch, load_published=True) | |
| ACTIVE_ARCH = arch | |
| label = ARCHITECTURES[arch]["label"] | |
| training_state["last"] = f"brain switched to {label}" | |
| return f"brain switched to {label} · {format_parameters(count_parameters(MODEL))} params on {DEVICE}" | |
| def _save_repo_weights(model_dir): | |
| """Only the llama brain maps onto the published ``model.safetensors``.""" | |
| if ACTIVE_ARCH != "llama": | |
| return False | |
| src = os.path.join(model_dir, "model.safetensors") | |
| if not os.path.exists(src): | |
| return False | |
| import shutil | |
| shutil.copyfile(src, os.path.join(ROOT, "model.safetensors")) | |
| return True | |
| def _train_chunks_with_engine(chunks, steps, out_dir, optimizer="adamw", scheduler="cosine", | |
| algorithms=None): | |
| """Fine-tune the live model in place through the Agron engine.""" | |
| os.makedirs(out_dir, exist_ok=True) | |
| trainer = AgronTrainer( | |
| MODEL, | |
| optimizer=optimizer, | |
| scheduler=scheduler, | |
| algorithms=list(algorithms or []), | |
| config=TrainerConfig(max_steps=int(steps), log_every=0, output_dir=out_dir), | |
| device=DEVICE, | |
| ) | |
| report = trainer.fit(_lm_loader(chunks, batch_size=2)) | |
| MODEL.eval() | |
| model_dir = os.path.join(out_dir, "final") | |
| MODEL.save_pretrained(model_dir) | |
| return report, model_dir | |
| def learn_from_interactions(optimizer=None, scheduler=None, recipe=None, algorithms=None, steps=30): | |
| global MODEL | |
| if not TRAIN_LOCK.acquire(blocking=False): | |
| return | |
| try: | |
| if len(interactions) < 2: | |
| training_state["last"] = "need at least 2 interactions before training" | |
| return | |
| training_state["running"] = True | |
| training_state["last"] = "training" | |
| optimizer, scheduler, algorithms = _resolve_zoo(optimizer, scheduler, recipe, algorithms) | |
| texts = [f"User: {r['user']}\nAgron: {r['assistant']}\n" for r in interactions] | |
| toks = TOKENIZER(" ".join(texts))["input_ids"] | |
| block = 64 | |
| chunks = [toks[i:i + block] for i in range(0, max(1, len(toks) - block + 1), block)] | |
| chunks = [{"input_ids": c} for c in chunks if len(c) == block] | |
| if not chunks: | |
| pad = [TOKENIZER.pad_token_id] * max(0, block - len(toks)) | |
| chunks = [{"input_ids": toks + pad}] | |
| out_dir = os.path.join(WORK_DIR, f"agron-{ACTIVE_ARCH}", "finetune") | |
| trainer = AgronTrainer( | |
| MODEL, | |
| optimizer=optimizer, | |
| scheduler=scheduler, | |
| algorithms=algorithms, | |
| config=TrainerConfig(max_steps=steps, log_every=0, output_dir=out_dir), | |
| device=DEVICE, | |
| ) | |
| report = trainer.fit(_lm_loader(chunks, batch_size=2)) | |
| model_dir = os.path.join(WORK_DIR, f"agron-{ACTIVE_ARCH}", "final") | |
| MODEL.eval() | |
| MODEL.save_pretrained(model_dir) | |
| trained_file = os.path.join(model_dir, "model.safetensors") | |
| if ACTIVE_ARCH == "llama" and os.path.exists(trained_file): | |
| import shutil | |
| shutil.copyfile(trained_file, os.path.join(ROOT, "model.safetensors")) | |
| training_state["steps"] += report["steps"] | |
| training_state["count_at_train"] = len(interactions) | |
| push_paths = [f"memory/interactions.jsonl"] | |
| if ACTIVE_ARCH == "llama": | |
| push_paths.insert(0, "model.safetensors") | |
| try: | |
| ok, detail = git_auto_push( | |
| f"Agron auto-learn ({len(interactions)} interactions, {ACTIVE_ARCH}/{optimizer})", | |
| push_paths, | |
| ) | |
| if "conversation memory" not in learned_topics: | |
| learned_topics.append("conversation memory") | |
| persist_topics() | |
| training_state["last"] = f"learned · {detail} @ {len(interactions)} interactions" | |
| except Exception as pe: | |
| training_state["last"] = f"push error: {str(pe)[:150]}" | |
| except Exception as e: | |
| training_state["last"] = f"learn error: {str(e)[:200]}" | |
| finally: | |
| training_state["running"] = False | |
| TRAIN_LOCK.release() | |
| def chat_fn(message, history): | |
| return generate_response(message, history) | |
| # ---------- UI ---------- | |
| PARTICLE_HTML = r""" | |
| <style> | |
| @import url('https://fonts.googleapis.com/css2?family=Orbitron:wght@400;700&family=VT323&display=swap'); | |
| html, body { | |
| margin: 0 !important; min-height: 100vh !important; background: radial-gradient(1200px 800px at 50% 25%, #0a1a3a 0%, #020617 70%) !important; | |
| color: #e2e8f0 !important; font-family: "Segoe UI", "Orbitron", monospace !important; | |
| } | |
| body, .gradio-container, .app { background: transparent !important; position: relative; z-index: 1; } | |
| #agron-bg-canvas { position: fixed; inset: 0; width: 100%; height: 100%; z-index: 0; } | |
| .gradio-container { | |
| max-width: 1500px !important; margin: 0 auto !important; padding: 10px 14px 24px !important; gap: 10px !important; | |
| border: 1px solid rgba(34, 211, 238, 0.4) !important; | |
| box-shadow: 0 0 40px rgba(34,211,238,0.25), inset 0 0 60px rgba(34,211,238,0.05) !important; | |
| } | |
| body::after { | |
| content: ""; position: fixed; inset: 0; pointer-events: none; z-index: 9999; | |
| background: repeating-linear-gradient(0deg, rgba(34,211,238,0.06) 0px, rgba(34,211,238,0.06) 1px, transparent 1px, transparent 3px); | |
| opacity: 0.35; mix-blend-mode: overlay; | |
| } | |
| .agron-card { | |
| background: rgba(8, 20, 45, 0.55) !important; border: 1px solid rgba(34, 211, 238, 0.35) !important; | |
| border-radius: 12px !important; backdrop-filter: blur(6px); box-shadow: 0 0 18px rgba(34,211,238,0.12) !important; | |
| padding: 8px !important; | |
| } | |
| .agron-card h1, .agron-card h2, .agron-card h3 { color: #67e8f9; text-shadow: 0 0 8px rgba(34,211,238,0.5); font-family: "Orbitron","Segoe UI",sans-serif; letter-spacing: 2px; } | |
| .agron-title { color: #67e8f9; text-shadow: 0 0 18px rgba(34,211,238,0.8); font-family: "Orbitron", "Segoe UI", sans-serif; letter-spacing: 3px; text-align: center; margin-bottom: 2px; text-transform: uppercase; } | |
| .agron-sub { color: #a5f3fc; text-align: center; font-size: 12px; opacity: 0.85; letter-spacing: 1px; } | |
| .agron-head { border: 1px solid rgba(34,211,238,0.35) !important; background: rgba(8,20,45,0.5) !important; border-radius: 12px !important; padding: 6px 12px !important; } | |
| .agron-strip textarea { color: #67e8f9 !important; background: rgba(2, 6, 23, 0.6) !important; font-family: "VT323", monospace !important; font-size: 15px !important; letter-spacing: 1px; } | |
| .agron-log textarea { color: #a5f3fc !important; background: rgba(2, 6, 23, 0.6) !important; font-family: "VT323", monospace !important; font-size: 15px !important; } | |
| .status-box textarea { color: #67e8f9 !important; background: rgba(2, 6, 23, 0.6) !important; font-family: monospace !important; } | |
| .gradio-container input, .gradio-container textarea, .gradio-container select, .block { | |
| background: rgba(2, 6, 23, 0.55) !important; color: #e2e8f0 !important; | |
| border: 1px solid rgba(34, 211, 238, 0.35) !important; border-radius: 8px !important; backdrop-filter: blur(4px) !important; | |
| } | |
| .gradio-container button { border: 1px solid #22d3ee !important; color: #22d3ee !important; background: rgba(34,211,238,0.08) !important; letter-spacing: 1px; text-transform: uppercase; } | |
| .gradio-container button:hover { background: rgba(34,211,238,0.18) !important; box-shadow: 0 0 12px rgba(34,211,238,0.35); } | |
| .gradio-container button.primary, .gradio-container button[variant="primary"] { background: rgba(34, 211, 238, 0.18) !important; font-weight: 700; } | |
| .gr-chatbot, .chatbot { background: rgba(2, 6, 23, 0.48) !important; border: 1px solid rgba(34, 211, 238, 0.35) !important; border-radius: 10px !important; } | |
| .markdown-text { font-family: "Segoe UI", "Orbitron", sans-serif !important; } | |
| .gr-group, .gr-row { min-height: 0 !important; } | |
| .tab-nav, .tabs > .tab-nav, [role="tablist"] { background: rgba(2,6,23,0.5) !important; border: 1px solid rgba(34,211,238,0.3) !important; border-radius: 10px !important; } | |
| [role="tablist"] button { color: #94a3b8 !important; border: none !important; background: transparent !important; letter-spacing: 1px !important; text-transform: uppercase; font-size: 12px !important; } | |
| [role="tablist"] button.selected { color: #22d3ee !important; background: rgba(34,211,238,0.14) !important; text-shadow: 0 0 10px rgba(34,211,238,0.8) !important; } | |
| footer, .foot { display: none !important; } | |
| @media (max-width: 1000px) { | |
| .gradio-container { max-width: 100% !important; } | |
| .gr-chatbot, .chatbot { height: 420px !important; } | |
| } | |
| </style> | |
| <canvas id="agron-bg-canvas"></canvas> | |
| """ | |
| PARTICLE_JS = r""" | |
| const canvas = document.getElementById('agron-bg-canvas'); | |
| if (canvas) { | |
| const ctx = canvas.getContext('2d'); | |
| let w, h, particles = [], mouse = {x: -9999, y: -9999}; | |
| function resize(){ w = canvas.width = window.innerWidth; h = canvas.height = window.innerHeight; } | |
| resize(); window.addEventListener('resize', resize); | |
| window.addEventListener('mousemove', e => { mouse.x = e.clientX; mouse.y = e.clientY; }); | |
| const N = 130; | |
| particles = []; | |
| for (let i=0;i<N;i++){ particles.push({x: Math.random()*w, y: Math.random()*h, vx:(Math.random()-0.5)*0.6, vy:(Math.random()-0.5)*0.6, r: Math.random()*1.6+0.6}); } | |
| function draw(){ | |
| ctx.clearRect(0,0,w,h); | |
| const t = Date.now()/1000; | |
| const cx = w/2, cy = h/2; | |
| const pulse = 0.5 + 0.5*Math.sin(t*2); | |
| const grad = ctx.createRadialGradient(cx,cy,0,cx,cy,160); | |
| grad.addColorStop(0, 'rgba(34,211,238,' + (0.35+0.15*pulse) + ')'); | |
| grad.addColorStop(1, 'rgba(34,211,238,0)'); | |
| ctx.fillStyle = grad; | |
| ctx.beginPath(); ctx.arc(cx,cy,160,0,Math.PI*2); ctx.fill(); | |
| for (let p of particles){ | |
| p.x += p.vx; p.y += p.vy; | |
| if (p.x<0||p.x>w) p.vx*=-1; | |
| if (p.y<0||p.y>h) p.vy*=-1; | |
| const dx = mouse.x - p.x, dy = mouse.y - p.y; | |
| const d = Math.hypot(dx,dy); | |
| if (d < 140){ p.vx += dx/d*0.015; p.vy += dy/d*0.015; } | |
| p.vx *= 0.99; p.vy *= 0.99; | |
| const pg = ctx.createRadialGradient(p.x,p.y,0,p.x,p.y,p.r*4); | |
| pg.addColorStop(0, 'rgba(103,232,249,0.9)'); | |
| pg.addColorStop(1, 'rgba(103,232,249,0)'); | |
| ctx.fillStyle = pg; | |
| ctx.beginPath(); ctx.arc(p.x,p.y,p.r*3,0,Math.PI*2); ctx.fill(); | |
| } | |
| for (let i=0;i<particles.length;i++){ | |
| for (let j=i+1;j<particles.length;j++){ | |
| const a=particles[i], b=particles[j]; | |
| const d = Math.hypot(a.x-b.x,a.y-b.y); | |
| if (d < 110){ | |
| ctx.strokeStyle = 'rgba(34,211,238,' + (0.25*(1-d/110)) + ')'; | |
| ctx.lineWidth = 0.8; | |
| ctx.beginPath(); ctx.moveTo(a.x,a.y); ctx.lineTo(b.x,b.y); ctx.stroke(); | |
| } | |
| } | |
| } | |
| ctx.strokeStyle = 'rgba(34,211,238,0.04)'; | |
| ctx.lineWidth = 1; | |
| for (let x=0;x<w;x+=80){ ctx.beginPath(); ctx.moveTo(x,0); ctx.lineTo(x,h); ctx.stroke(); } | |
| for (let y=0;y<h;y+=80){ ctx.beginPath(); ctx.moveTo(0,y); ctx.lineTo(w,y); ctx.stroke(); } | |
| requestAnimationFrame(draw); | |
| } | |
| draw(); | |
| } | |
| """ | |
| WORDLIST_URL = "https://raw.githubusercontent.com/dwyl/english-words/master/words_alpha.txt" | |
| def fetch_word_list(limit=500): | |
| try: | |
| with urllib.request.urlopen(WORDLIST_URL, timeout=45) as r: | |
| raw = r.read().decode("utf-8", "ignore") | |
| cand = [] | |
| seen = set() | |
| for w in raw.splitlines(): | |
| w = w.strip().lower() | |
| if 3 <= len(w) <= 10 and w.isalpha() and w not in seen: | |
| seen.add(w) | |
| cand.append(w) | |
| if len(cand) >= limit * 3: | |
| break | |
| random.shuffle(cand) | |
| return cand[:limit] | |
| except Exception as e: | |
| training_state["last"] = f"wordlist error: {str(e)[:100]}" | |
| return [] | |
| def fetch_definition(word): | |
| UA = "AgronBot/1.0 (teddy.njagi.w@gmail.com)" | |
| # Try Wiktionary extract | |
| try: | |
| r = requests.get("https://en.wiktionary.org/w/api.php", params={ | |
| "action": "query", "prop": "extracts", "explaintext": "1", | |
| "titles": word, "format": "json" | |
| }, headers={"User-Agent": UA}, timeout=20) | |
| if r.status_code == 200: | |
| page = list(r.json().get("query", {}).get("pages", {}).values()) | |
| if page: | |
| extract = page[0].get("extract", "") | |
| if extract: | |
| meaning = _parse_wiktionary(extract) | |
| if meaning: | |
| return f"{word}: {meaning}" | |
| except Exception: | |
| pass | |
| # Try Wikipedia summary | |
| try: | |
| r = requests.get("https://en.wikipedia.org/api/rest_v1/page/summary/" + word, headers={"User-Agent": UA}, timeout=20) | |
| if r.status_code == 200: | |
| ex = r.json().get("extract", "") | |
| if ex and len(ex) > 20: | |
| return f"{word}: {ex.split('.')[0]}." | |
| except Exception: | |
| pass | |
| # Fallback: ask local voice model | |
| try: | |
| if VOICE_MODEL is not None and VOICE_TOK is not None: | |
| msgs = [{"role": "system", "content": "You are a dictionary. Reply with a single concise definition for the given word, no extra text."}, | |
| {"role": "user", "content": f"Define: {word}"}] | |
| prompt = VOICE_TOK.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True) | |
| inputs = VOICE_TOK(prompt, return_tensors="pt").to(VOICE_MODEL.device) | |
| with torch.no_grad(): | |
| out = VOICE_MODEL.generate(**inputs, max_new_tokens=40, do_sample=False) | |
| txt = VOICE_TOK.decode(out[0][inputs.input_ids.shape[1]:], skip_special_tokens=True).strip() | |
| if txt and len(txt) > 8: | |
| return f"{word}: {txt.split(chr(10))[0]}" | |
| except Exception: | |
| pass | |
| return None | |
| def _parse_wiktionary(extract): | |
| lines = [ln.strip() for ln in extract.splitlines()] | |
| # find section headers for parts of speech | |
| for i, ln in enumerate(lines): | |
| if ln.startswith("===") and ln.endswith("==="): | |
| title = ln.strip("=").strip().lower() | |
| if title in {"noun", "verb", "adjective", "adverb", "pronoun", "preposition"}: | |
| # take next non-empty, non-heading line | |
| for j in range(i+1, min(i+12, len(lines))): | |
| cand = lines[j] | |
| if not cand or cand.startswith("===") or cand.startswith("===="): | |
| continue | |
| cand2 = cand.lstrip("#*:- ").strip() | |
| if len(cand2) <= 8: | |
| continue | |
| lowc = cand2.lower() | |
| if "plural" in lowc or lowc.startswith(word.lower()): | |
| continue | |
| if lowc.startswith("synonym") or lowc.startswith("see thesaurus"): | |
| continue | |
| return cand2 | |
| # fallback: first long line not a header | |
| for ln in lines: | |
| if not ln or ln.startswith("===") or ln.startswith("=="): | |
| continue | |
| cand = ln.lstrip("#*:- ").strip() | |
| if len(cand) > 12: | |
| return cand | |
| return None | |
| def learn_dictionary(): | |
| global MODEL | |
| if not TRAIN_LOCK.acquire(blocking=False): | |
| return | |
| training_state["running"] = True | |
| training_state["last"] = "fetching dictionary..." | |
| try: | |
| words = fetch_word_list(150) | |
| if not words: | |
| raise RuntimeError("could not fetch word list") | |
| lines = [] | |
| for i, w in enumerate(words): | |
| training_state["last"] = f"dictionary {i+1}/{len(words)}: {w}" | |
| d = fetch_definition(w) | |
| if d: | |
| lines.append(d) | |
| time.sleep(0.08) | |
| if len(lines) < 20: | |
| raise RuntimeError(f"too few definitions fetched ({len(lines)})") | |
| corpus = "\n".join(lines) | |
| toks = TOKENIZER(corpus)["input_ids"] | |
| block = 64 | |
| chunks = [toks[i:i+block] for i in range(0, max(1, len(toks) - block + 1), block)] | |
| chunks = [c for c in chunks if len(c) == block] | |
| if not chunks: | |
| chunks = [toks[:block] + [TOKENIZER.pad_token_id] * (block - min(block, len(toks)))] | |
| ds = [{"input_ids": c} for c in chunks] | |
| out_dir = os.path.join(WORK_DIR, "agron-dictionary") | |
| optimizer, scheduler, algorithms = _resolve_zoo() | |
| os.makedirs(out_dir, exist_ok=True) | |
| training_state["last"] = f"training on {len(lines)} definitions..." | |
| report, model_dir = _train_chunks_with_engine(ds, 80, out_dir, optimizer, scheduler, algorithms) | |
| _save_repo_weights(model_dir) | |
| # push | |
| training_state["last"] = "pushing dictionary model..." | |
| push_paths = ["memory/interactions.jsonl"] + (["model.safetensors"] if ACTIVE_ARCH == "llama" else []) | |
| ok, detail = git_auto_push( | |
| f"Agron dictionary learning ({len(lines)} words, {ACTIVE_ARCH})", | |
| push_paths, | |
| ) | |
| training_state["last"] = f"dictionary learned · {detail}" | |
| learned_topics.append("dictionary words") | |
| persist_topics() | |
| training_state["last"] = f"dictionary learned & pushed ({len(lines)} words)" | |
| except Exception as e: | |
| training_state["last"] = f"dict error: {str(e)[:150]}" | |
| finally: | |
| training_state["running"] = False | |
| TRAIN_LOCK.release() | |
| import base64 as _b64 | |
| def _decode_bing(url): | |
| try: | |
| import urllib.parse | |
| qs = urllib.parse.parse_qs(urllib.parse.urlparse(url).query) | |
| u = qs.get("u", [""])[0] | |
| if u.startswith("a1"): | |
| u = u[2:] | |
| pad = "=" * (-len(u) % 4) | |
| return _b64.b64decode(u + pad).decode() | |
| except Exception: | |
| return url | |
| def web_search(query, max_results=5): | |
| try: | |
| headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36", "Accept": "text/html"} | |
| r = requests.post("https://html.duckduckgo.com/html/", data={"q": query}, headers=headers, timeout=25) | |
| soup = BeautifulSoup(r.text, "html.parser") | |
| out = [] | |
| for res in soup.select(".result"): | |
| a = res.select_one("a.result__a") | |
| if not a: | |
| continue | |
| title = a.get_text(strip=True) | |
| link = a.get("href", "") | |
| sn = res.select_one(".result__snippet") | |
| snippet = sn.get_text(strip=True) if sn else "" | |
| if link and title: | |
| out.append({"title": title, "url": link, "snippet": snippet}) | |
| if len(out) >= max_results: | |
| break | |
| if not out: | |
| try: | |
| dr = requests.get("https://api.duckduckgo.com/", params={"q": query, "format": "json", "no_html": "1"}, headers=headers, timeout=20) | |
| dd = dr.json() | |
| if dd.get("Abstract"): | |
| out.append({"title": dd.get("Heading", query), "url": dd.get("AbstractURL", ""), "snippet": dd.get("Abstract", "")}) | |
| except Exception: | |
| pass | |
| return out | |
| except Exception as e: | |
| training_state["last"] = f"search error: {str(e)[:100]}" | |
| return [] | |
| def crawl_page(url): | |
| try: | |
| r = requests.get(url, timeout=20, headers={"User-Agent": "Mozilla/5.0"}, allow_redirects=True) | |
| if r.status_code != 200: | |
| return "" | |
| soup = BeautifulSoup(r.text, "html.parser") | |
| for tag in soup(["script", "style", "nav", "footer", "header", "noscript", "form"]): | |
| tag.decompose() | |
| text = " ".join(soup.get_text(separator=" ", strip=True).split()) | |
| return text[:2500] | |
| except Exception: | |
| return "" | |
| def learn_web(topic): | |
| global MODEL | |
| if not TRAIN_LOCK.acquire(blocking=False): | |
| return | |
| training_state["running"] = True | |
| training_state["last"] = f"searching web: {topic}" | |
| try: | |
| results = web_search(topic, 5) | |
| if not results: | |
| raise RuntimeError("no search results") | |
| lines = [] | |
| for i, res in enumerate(results): | |
| training_state["last"] = f"crawling {i+1}/{len(results)}: {res['title'][:40]}" | |
| page = crawl_page(res["url"]) | |
| lines.append(f"Topic: {topic}\nSource: {res['title']} ({res['url']})\nSnippet: {res['snippet']}\nContent: {page}") | |
| time.sleep(1) | |
| corpus = "\n\n".join(lines) | |
| if not corpus.strip(): | |
| raise RuntimeError("empty web corpus") | |
| toks = TOKENIZER(corpus)["input_ids"] | |
| block = 64 | |
| chunks = [toks[i:i+block] for i in range(0, max(1, len(toks) - block + 1), block)] | |
| chunks = [c for c in chunks if len(c) == block] | |
| if not chunks: | |
| raise RuntimeError("not enough web text") | |
| ds = [{"input_ids": c} for c in chunks] | |
| out_dir = os.path.join(WORK_DIR, "agron-web") | |
| optimizer, scheduler, algorithms = _resolve_zoo() | |
| os.makedirs(out_dir, exist_ok=True) | |
| training_state["last"] = f"training on web content for '{topic}'..." | |
| report, model_dir = _train_chunks_with_engine(ds, 60, out_dir, optimizer, scheduler, algorithms) | |
| _save_repo_weights(model_dir) | |
| training_state["last"] = "pushing web-learned model..." | |
| push_paths = ["memory/interactions.jsonl"] + (["model.safetensors"] if ACTIVE_ARCH == "llama" else []) | |
| ok, detail = git_auto_push( | |
| f"Agron web learning: {topic} ({ACTIVE_ARCH})", | |
| push_paths, | |
| ) | |
| learned_topics.append(f"web: {topic}") | |
| persist_topics() | |
| training_state["last"] = f"web learned · {detail}: {topic}" | |
| except Exception as e: | |
| training_state["last"] = f"web error: {str(e)[:150]}" | |
| finally: | |
| training_state["running"] = False | |
| TRAIN_LOCK.release() | |
| EVOLVE_STATE = {"running": False, "cycles": 0, "last_topic": "none"} | |
| def self_update(): | |
| """Pull the latest code from the Hugging Face repo (origin).""" | |
| try: | |
| subprocess.run(["git", "-C", ROOT, "fetch", "origin"], check=True, timeout=120) | |
| branch = subprocess.run(["git", "-C", ROOT, "rev-parse", "--abbrev-ref", "HEAD"], | |
| capture_output=True, text=True).stdout.strip() or "main" | |
| local = subprocess.run(["git", "-C", ROOT, "rev-parse", "HEAD"], capture_output=True, text=True, check=True).stdout.strip() | |
| remote = subprocess.run(["git", "-C", ROOT, "rev-parse", f"origin/{branch}"], capture_output=True, text=True).stdout.strip() | |
| if not remote: | |
| return f"could not resolve origin/{branch}" | |
| if local != remote: | |
| subprocess.run(["git", "-C", ROOT, "pull", "--ff-only", "origin", branch], check=True, timeout=300) | |
| return f"updated from Hugging Face ({local[:7]} -> {remote[:7]}); restart app to apply new code" | |
| return "already up to date with Hugging Face" | |
| except Exception as e: | |
| return f"update error: {str(e)[:120]}" | |
| EVOLVE_TOPICS = [ | |
| "artificial intelligence self improvement", | |
| "chain of thought reasoning", | |
| "tree of thought search", | |
| "self-consistency decoding", | |
| "recursive self improvement algorithms", | |
| "react agent pattern", | |
| "retrieval augmented generation", | |
| "algorithm design and complexity", | |
| "machine learning transformers", | |
| "python programming best practices", | |
| "data structures algorithms", | |
| "neural network training techniques", | |
| "encyclopedia general knowledge", | |
| ] | |
| def _self_evolve_worker(): | |
| EVOLVE_STATE["running"] = True | |
| i = 0 | |
| try: | |
| while EVOLVE_STATE["running"]: | |
| # evolve from conversations if enough | |
| if len(interactions) >= 4: | |
| learn_from_interactions() | |
| # learn from web on rotating topics | |
| if EVOLVE_STATE["running"]: | |
| topic = EVOLVE_TOPICS[i % len(EVOLVE_TOPICS)] | |
| i += 1 | |
| EVOLVE_STATE["last_topic"] = topic | |
| learn_web(topic) | |
| EVOLVE_STATE["cycles"] += 1 | |
| # downtime before next cycle | |
| for _ in range(300): | |
| if not EVOLVE_STATE["running"]: | |
| break | |
| time.sleep(1) | |
| except Exception as e: | |
| training_state["last"] = f"evolve error: {str(e)[:120]}" | |
| finally: | |
| EVOLVE_STATE["running"] = False | |
| def start_self_evolution(): | |
| if EVOLVE_STATE["running"]: | |
| return "self-evolution already running" | |
| threading.Thread(target=_self_evolve_worker, daemon=True).start() | |
| return "self-evolution started" | |
| def stop_self_evolution(): | |
| EVOLVE_STATE["running"] = False | |
| return "stopping self-evolution..." | |
| # ---------- Tools & dashboard ---------- | |
| TOOLS_DIR = os.path.join(MEMORY_DIR, "tools") | |
| os.makedirs(TOOLS_DIR, exist_ok=True) | |
| TOOLS_FILE = os.path.join(TOOLS_DIR, "registry.json") | |
| TOOL_REGISTRY = {} # name -> {"description":..., "code":..., "builtin": bool} | |
| def builtin_web_search(text): | |
| res = web_search(text, 5) | |
| if not res: | |
| return "No results found." | |
| return "\n".join(f"{i+1}. {r['title']} - {r.get('snippet','')} ({r['url']})" for i, r in enumerate(res)) | |
| def builtin_define(text): | |
| d = fetch_definition(text.strip()) | |
| return d if d else f"No definition found for {text}." | |
| def builtin_calc(text): | |
| try: | |
| allowed = {"__builtins__": {}} | |
| val = eval(text, allowed, {}) | |
| return str(val) | |
| except Exception as e: | |
| return f"calc error: {e}" | |
| def builtin_time(text=""): | |
| return time.strftime("%Y-%m-%d %H:%M:%S") | |
| def register_builtin_tools(): | |
| specs = [ | |
| ("web_search", "Search the web for a query.", None, builtin_web_search), | |
| ("define_word", "Define an English word.", None, builtin_define), | |
| ("calculate", "Evaluate a math expression.", None, builtin_calc), | |
| ("current_time", "Current date/time.", None, builtin_time), | |
| ] | |
| for name, desc, code, fn in specs: | |
| TOOL_REGISTRY[name] = {"description": desc, "code": None, "builtin": True, "fn": fn} | |
| def load_tools(): | |
| if os.path.exists(TOOLS_FILE): | |
| try: | |
| with open(TOOLS_FILE, "r") as f: | |
| data = json.load(f) | |
| for t in data: | |
| name = t["name"] | |
| code = t["code"] | |
| g = {} | |
| try: | |
| exec(code, g) | |
| TOOL_REGISTRY[name] = {"description": t.get("description", ""), "code": code, "builtin": False, "fn": g.get("run")} | |
| except Exception: | |
| pass | |
| except Exception: | |
| pass | |
| def save_tools(): | |
| data = [] | |
| for name, info in TOOL_REGISTRY.items(): | |
| if info.get("builtin"): | |
| continue | |
| data.append({"name": name, "description": info.get("description", ""), "code": info.get("code", "")}) | |
| with open(TOOLS_FILE, "w") as f: | |
| json.dump(data, f, indent=2) | |
| def execute_tool(name, text): | |
| info = TOOL_REGISTRY.get(name) | |
| if not info: | |
| return f"Unknown tool: {name}" | |
| try: | |
| fn = info.get("fn") | |
| if fn is None and info.get("code"): | |
| g = {} | |
| exec(info["code"], g) | |
| fn = g.get("run") | |
| info["fn"] = fn | |
| if fn is None: | |
| return "Tool has no runnable function." | |
| out = fn(text) | |
| return str(out) | |
| except Exception as e: | |
| return f"tool error: {str(e)[:200]}" | |
| def list_tool_names(): | |
| return sorted(TOOL_REGISTRY.keys()) | |
| def create_tool_from_description(desc): | |
| desc = (desc or "").strip() | |
| if not desc: | |
| return "Provide a tool description first." | |
| try: | |
| prompt = ( | |
| "You are a Python tool generator. Write a Python function named `run(input_text)` that implements this tool: " | |
| + desc.strip() | |
| + "\nReturn only a single fenced code block with the function. No explanation. The function should return a string. " | |
| + "Do not use network or file writes; only pure computation." | |
| ) | |
| msgs = [{"role": "system", "content": "You write safe, pure-Python tool functions as `run(input_text) returning str`."}, | |
| {"role": "user", "content": prompt}] | |
| p = VOICE_TOK.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True) if VOICE_TOK else None | |
| if VOICE_MODEL is not None and VOICE_TOK is not None: | |
| inputs = VOICE_TOK(p, return_tensors="pt").to(VOICE_MODEL.device) | |
| with torch.no_grad(): | |
| out = VOICE_MODEL.generate(**inputs, max_new_tokens=200, do_sample=False) | |
| raw = VOICE_TOK.decode(out[0][inputs.input_ids.shape[1]:], skip_special_tokens=True) | |
| else: | |
| raw = "" | |
| # extract code | |
| import re | |
| m = re.search(r"```(?:python)?\n(.*?)```", raw, re.S) | |
| code = m.group(1).strip() if m else raw.strip() | |
| if "def run" not in code: | |
| return "Model did not produce a runnable function. Try rephrasing the description." | |
| # compile | |
| g = {} | |
| exec(compile(code, "<tool>", "exec"), g) | |
| if not callable(g.get("run")): | |
| return "Generated code has no run() function." | |
| # quick smoke test | |
| try: | |
| _ = g["run"]("") | |
| except Exception: | |
| pass | |
| # name | |
| slug = "".join(c if c.isalnum() else "_" for c in desc.lower())[:24].strip("_") | |
| slug = slug or "tool" | |
| name = slug | |
| i = 1 | |
| while name in TOOL_REGISTRY: | |
| name = f"{slug}_{i}" | |
| i += 1 | |
| TOOL_REGISTRY[name] = {"description": desc.strip(), "code": code, "builtin": False, "fn": g["run"]} | |
| save_tools() | |
| return f"Created tool '{name}'. It is now available in the tool panel." | |
| except Exception as e: | |
| return f"tool creation error: {str(e)[:200]}" | |
| register_builtin_tools() | |
| load_tools() | |
| def learn_from_scratch_memory(arch=None, optimizer=None, scheduler=None, recipe=None, | |
| algorithms=None, steps=300): | |
| global MODEL, LAST_TRAIN_TIME, ACTIVE_ARCH | |
| if not TRAIN_LOCK.acquire(blocking=False): | |
| return | |
| training_state["running"] = True | |
| training_state["last"] = "building from-scratch corpus..." | |
| try: | |
| if len(interactions) < 6: | |
| raise RuntimeError(f"need at least 6 interactions (have {len(interactions)})") | |
| arch = (arch or ACTIVE_ARCH or "llama").strip().lower() | |
| optimizer, scheduler, algorithm_list = _resolve_zoo(optimizer, scheduler, recipe, algorithms) | |
| corpus = os.path.join(MEMORY_DIR, "scratch_corpus.txt") | |
| lines = [f"User: {r['user']}\nAgron: {r['assistant']}" for r in interactions] | |
| with open(corpus, "w", encoding="utf-8") as f: | |
| f.write("\n\n".join(lines)) | |
| out_dir = os.path.join(WORK_DIR, f"agron-scratch-{arch}") | |
| training_state["last"] = f"training {arch} from scratch on {len(interactions)} interactions..." | |
| cmd = [ | |
| sys.executable, os.path.join(ROOT, "train_from_scratch.py"), | |
| "--size", "current", "--steps", str(int(steps)), | |
| "--dataset", "file", "--file", corpus, | |
| "--output", out_dir, | |
| "--arch", arch, | |
| "--optimizer", optimizer, | |
| "--scheduler", scheduler, | |
| "--block-size", "256", | |
| ] | |
| if recipe and recipe not in ("custom", "none"): | |
| cmd += ["--recipe", recipe] | |
| for name in algorithm_list: | |
| cmd += ["--algorithm", name] | |
| subprocess.run(cmd, check=True, timeout=1800) | |
| final_dir = os.path.join(out_dir, "final") | |
| if reload_live_model(final_dir): | |
| ACTIVE_ARCH = arch | |
| if arch == "llama": | |
| import shutil | |
| shutil.copyfile(os.path.join(final_dir, "model.safetensors"), | |
| os.path.join(ROOT, "model.safetensors")) | |
| learned_topics.append(f"from-scratch {arch} model") | |
| persist_topics() | |
| training_state["last"] = "self-updating from scratch..." | |
| push_paths = ["memory/scratch_corpus.txt", "memory/learned_topics.json"] | |
| if arch == "llama": | |
| push_paths.insert(0, "model.safetensors") | |
| ok, detail = git_auto_push( | |
| f"Agron from-scratch learning ({arch}, {optimizer}, {len(interactions)} interactions)", | |
| push_paths, | |
| ) | |
| LAST_TRAIN_TIME = time.time() | |
| training_state["last"] = ( | |
| f"from-scratch {arch} learned · {detail} ({len(interactions)} interactions)" | |
| ) | |
| except Exception as e: | |
| training_state["last"] = f"from-scratch error: {str(e)[:200]}" | |
| finally: | |
| training_state["running"] = False | |
| TRAIN_LOCK.release() | |
| FACTORY_RESET_PATHS = ( | |
| [ | |
| os.path.join(WORK_DIR, n) | |
| for n in ( | |
| "agron-model", "agron-learned", "agron-web", "agron-dictionary", | |
| "agron-from-scratch-memory", "agron-scratch-small", "agron-scratch-current", | |
| ) | |
| ] | |
| + [os.path.join(WORK_DIR, f"agron-{name}") for name in architecture_names()] | |
| + [os.path.join(WORK_DIR, f"agron-scratch-{name}") for name in architecture_names()] | |
| ) | |
| def factory_reset(): | |
| global MODEL, DEVICE, ACTIVE_ARCH, interactions, learned_topics | |
| stop_self_evolution() | |
| with IO_LOCK: | |
| interactions = [] | |
| learned_topics = [] | |
| try: | |
| os.makedirs(MEMORY_DIR, exist_ok=True) | |
| open(INTERACTIONS_FILE, "w").close() | |
| json.dump([], open(TOPICS_FILE, "w")) | |
| except Exception: | |
| pass | |
| # clear tools registry | |
| try: | |
| if os.path.exists(TOOLS_FILE): | |
| os.remove(TOOLS_FILE) | |
| except Exception: | |
| pass | |
| for tn in list(TOOL_REGISTRY.keys()): | |
| if not TOOL_REGISTRY[tn].get("builtin"): | |
| del TOOL_REGISTRY[tn] | |
| # clear scratch corpus | |
| try: | |
| sc = os.path.join(MEMORY_DIR, "scratch_corpus.txt") | |
| if os.path.exists(sc): | |
| os.remove(sc) | |
| except Exception: | |
| pass | |
| # delete trained model dirs | |
| import shutil | |
| for d in FACTORY_RESET_PATHS: | |
| if os.path.exists(d): | |
| shutil.rmtree(d, ignore_errors=True) | |
| # reinitialize the active Agron architecture with fresh random weights | |
| try: | |
| MODEL, DEVICE = build_model(ACTIVE_ARCH, load_published=False) | |
| except Exception as e: | |
| training_state["last"] = f"reset model error: {str(e)[:120]}" | |
| globals()["LAST_TRAIN_TIME"] = time.time() | |
| training_state["running"] = False | |
| training_state["steps"] = 0 | |
| training_state["last"] = ( | |
| f"factory reset complete - fresh {ARCHITECTURES[ACTIVE_ARCH]['label']} initialised" | |
| ) | |
| return "factory reset complete" | |
| # ---------- status helpers ---------- | |
| ACTION_LOG = [] | |
| def log_action(msg): | |
| """Append a line to the action log and return the rendered log.""" | |
| ACTION_LOG.append(f"{time.strftime('%H:%M:%S')} {msg}") | |
| del ACTION_LOG[:-60] | |
| return "\n".join(ACTION_LOG[-14:]) | |
| def status_line(): | |
| return ( | |
| f"interactions: {len(interactions)} · tools: {len(list_tool_names())} · " | |
| f"evolve cycles: {EVOLVE_STATE['cycles']} · training: " | |
| f"{'RUNNING' if training_state['running'] else 'idle'} · {training_state['last']}" | |
| ) | |
| def system_snapshot(): | |
| try: | |
| n_params = sum(p.numel() for p in MODEL.parameters()) | |
| except Exception: | |
| n_params = 0 | |
| gpu = "" | |
| if torch.cuda.is_available(): | |
| try: | |
| gpu = f" · gpu alloc {torch.cuda.memory_allocated() / 1e9:.2f} GB" | |
| except Exception: | |
| gpu = "" | |
| voice = "on" if VOICE_MODEL is not None else "off" | |
| return ( | |
| f"params: {n_params / 1e6:.1f}M · arch: {ACTIVE_ARCH} · device: {DEVICE}{gpu} · voice model: {voice}\n" | |
| f"zoo: {len(ARCHITECTURES)} networks · {len(optimizer_names())} optimisers · " | |
| f"{len(algorithm_names())} algorithms · {len(RECIPES)} recipes\n" | |
| f"work dir: {WORK_DIR}\n" | |
| f"topics: {len(learned_topics)} · auto-push: {'on' if AUTO_PUSH else 'off'}" | |
| ) | |
| with gr.Blocks(title="Agron Neural Interface") as demo: | |
| gr.HTML(PARTICLE_HTML, js_on_load=PARTICLE_JS) | |
| with gr.Column(elem_classes="agron-head"): | |
| gr.Markdown("<h1 class='agron-title'>AGRØN NEURAL INTERFACE</h1>") | |
| gr.Markdown("<div class='agron-sub'>Self-improving multi-agent core · learning from every exchange</div>") | |
| with gr.Column(elem_classes="agron-card"): | |
| status_strip = gr.Textbox(value=status_line(), label="TELEMETRY", interactive=False, elem_classes="agron-strip", lines=2) | |
| action_log = gr.Textbox(value=log_action("Agron interface online."), label="ACTION LOG", interactive=False, elem_classes="agron-log", lines=4) | |
| with gr.Row(): | |
| with gr.Column(scale=4, elem_classes="agron-card"): | |
| gr.Markdown("<h2 class='agron-title'>💬 COMMAND CONSOLE</h2>") | |
| chatbot = gr.Chatbot(height=480, label="Agron", elem_classes="agron-chat") | |
| msg = gr.Textbox(placeholder="Speak to Agron...", label="Input", lines=2) | |
| with gr.Row(): | |
| send = gr.Button("Transmit", variant="primary") | |
| clear = gr.Button("Clear") | |
| with gr.Column(scale=2, elem_classes="agron-card"): | |
| with gr.Tabs(): | |
| with gr.Tab("SYSTEM"): | |
| sys_status = gr.Textbox(value=training_state["last"], label="Pipeline", interactive=False, elem_classes="status-box", lines=2) | |
| metrics = gr.Textbox(value=system_snapshot(), label="Diagnostics", interactive=False, lines=4) | |
| with gr.Row(): | |
| arch_dd = gr.Dropdown( | |
| choices=architecture_names(), | |
| value=ACTIVE_ARCH, | |
| label="Architecture", | |
| ) | |
| arch_btn = gr.Button("Load brain", variant="secondary") | |
| zoo_info = gr.Markdown(zoo_summary()) | |
| with gr.Tab("TOOLS"): | |
| tool_dd = gr.Dropdown(choices=list_tool_names(), value=(list_tool_names()[0] if list_tool_names() else None), label="Select tool") | |
| tool_in = gr.Textbox(placeholder="Tool input...", label="Tool input", lines=1) | |
| tool_btn = gr.Button("Run tool") | |
| tool_out = gr.Textbox(label="Tool output", interactive=False, lines=8) | |
| gr.Markdown("### Create tool") | |
| tool_desc = gr.Textbox(placeholder="Describe a new tool (pure computation)...", label="New tool description", lines=2) | |
| create_btn = gr.Button("Create tool") | |
| with gr.Tab("LEARNING"): | |
| learn_btn = gr.Button("Train now on memory") | |
| scratch_btn = gr.Button("Train from scratch (no fine-tune)") | |
| dict_btn = gr.Button("Learn dictionary words") | |
| web_topic = gr.Textbox(label="Web topic / search query", placeholder="e.g. transformer architecture", lines=1) | |
| web_btn = gr.Button("Search & learn web") | |
| with gr.Row(): | |
| recipe_dd = gr.Dropdown( | |
| choices=["custom"] + recipe_names(), | |
| value="custom", | |
| label="Recipe", | |
| ) | |
| optimizer_dd = gr.Dropdown( | |
| choices=optimizer_names(), value="adamw", label="Optimiser" | |
| ) | |
| scheduler_dd = gr.Dropdown( | |
| choices=scheduler_names(), value="cosine", label="Scheduler" | |
| ) | |
| algorithm_cb = gr.CheckboxGroup( | |
| choices=algorithm_names(), value=[], label="Algorithms (composable)" | |
| ) | |
| steps_num = gr.Number(value=300, label="Steps", precision=0) | |
| with gr.Row(): | |
| evolve_btn = gr.Button("Start self-evolution") | |
| stop_evolve_btn = gr.Button("Stop") | |
| with gr.Row(): | |
| update_btn = gr.Button("Self-update") | |
| reset_btn = gr.Button("Factory reset") | |
| def respond(message, history): | |
| message = (message or "").strip() | |
| if not message: | |
| return history, "" | |
| response = generate_response(message, history) | |
| history = history + [{"role": "user", "content": message}, {"role": "assistant", "content": response}] | |
| return history, "" | |
| def do_switch(arch): | |
| return log_action(switch_architecture(arch)), system_snapshot() | |
| def do_learn(optimizer, scheduler, recipe, algorithms, steps): | |
| if training_state["running"]: | |
| return log_action(f"training already running · {training_state['last']}") | |
| if len(interactions) < 2: | |
| return log_action(f"need at least 2 interactions (have {len(interactions)})") | |
| threading.Thread( | |
| target=learn_from_interactions, | |
| kwargs=dict(optimizer=optimizer, scheduler=scheduler, recipe=recipe, | |
| algorithms=list(algorithms or []), steps=int(steps or 30)), | |
| daemon=True, | |
| ).start() | |
| opt, sched, algos = _resolve_zoo(optimizer, scheduler, recipe, algorithms) | |
| return log_action( | |
| f"memory training started in background · {ACTIVE_ARCH}/{opt}/{sched}" | |
| + (f" · {', '.join(algos)}" if algos else "") | |
| ) | |
| def refresh_status(): | |
| return status_line(), training_state["last"], system_snapshot() | |
| send.click(respond, [msg, chatbot], [chatbot, msg]) | |
| msg.submit(respond, [msg, chatbot], [chatbot, msg]) | |
| clear.click(lambda: ([], ""), outputs=[chatbot, msg]) | |
| arch_btn.click(do_switch, arch_dd, [action_log, metrics]) | |
| def do_dict(): | |
| if training_state["running"]: | |
| return log_action("training already running") | |
| threading.Thread(target=learn_dictionary, daemon=True).start() | |
| return log_action("dictionary learning started in background") | |
| def do_web(): | |
| if training_state["running"]: | |
| return log_action("training already running") | |
| q = (web_topic.value or "").strip() | |
| if not q: | |
| return log_action("enter a topic/query first") | |
| threading.Thread(target=learn_web, args=(q,), daemon=True).start() | |
| return log_action(f"web learning started: {q}") | |
| def run_tool_fn(tool_name, tool_input): | |
| if not tool_name: | |
| return "select a tool first" | |
| return execute_tool(tool_name, tool_input or "") | |
| def create_tool_fn(desc): | |
| return log_action(create_tool_from_description(desc)) | |
| def refresh_tools(): | |
| choices = list_tool_names() | |
| return gr.Dropdown(choices=choices, value=(choices[0] if choices else None)) | |
| tool_btn.click(run_tool_fn, [tool_dd, tool_in], tool_out) | |
| create_btn.click(create_tool_fn, tool_desc, action_log) | |
| learn_btn.click(do_learn, [optimizer_dd, scheduler_dd, recipe_dd, algorithm_cb, steps_num], outputs=action_log) | |
| def do_scratch(arch, optimizer, scheduler, recipe, algorithms, steps): | |
| if training_state["running"]: | |
| return log_action("training already running") | |
| if len(interactions) < 6: | |
| return log_action(f"need at least 6 interactions (have {len(interactions)})") | |
| threading.Thread( | |
| target=learn_from_scratch_memory, | |
| kwargs=dict(arch=arch, optimizer=optimizer, scheduler=scheduler, recipe=recipe, | |
| algorithms=list(algorithms or []), steps=int(steps or 300)), | |
| daemon=True, | |
| ).start() | |
| opt, sched, algos = _resolve_zoo(optimizer, scheduler, recipe, algorithms) | |
| return log_action( | |
| f"from-scratch training started: {arch} · {opt}/{sched}" | |
| + (f" · {', '.join(algos)}" if algos else "") | |
| ) | |
| scratch_btn.click( | |
| do_scratch, | |
| [arch_dd, optimizer_dd, scheduler_dd, recipe_dd, algorithm_cb, steps_num], | |
| outputs=action_log, | |
| ) | |
| dict_btn.click(do_dict, outputs=action_log) | |
| web_btn.click(do_web, outputs=action_log) | |
| def do_evolve(): | |
| return log_action(start_self_evolution()) | |
| def do_stop_evolve(): | |
| return log_action(stop_self_evolution()) | |
| def do_update(): | |
| return log_action(self_update()) | |
| evolve_btn.click(do_evolve, outputs=action_log) | |
| stop_evolve_btn.click(do_stop_evolve, outputs=action_log) | |
| update_btn.click(do_update, outputs=action_log) | |
| reset_btn.click(lambda: log_action(factory_reset()), outputs=action_log) | |
| demo.load(refresh_status, outputs=[status_strip, sys_status, metrics]) | |
| # periodic status refresh (not true polling inside gradio, use change hook via demo load only) | |
| gr.Timer(5).tick(refresh_status, outputs=[status_strip, sys_status, metrics]) | |
| if __name__ == "__main__": | |
| demo.launch(server_name=SERVER_NAME, server_port=SERVER_PORT, share=SHARE, show_error=True) | |