| """ |
| Simu — MSKit's built-in AI assistant. |
| |
| Startup flow (fires before the very first simulation): |
| |
| Step 1 — Choose AI Brain: |
| ┌──────────────────────────────────────────────────────────────┐ |
| │ 1. untrained — Rule-based parser, instant, no download │ |
| │ 2. huggingface — SmolLM2-360M-Instruct (recommended) │ |
| │ 3. custom — Your own HF repo / local folder / .gguf │ |
| └──────────────────────────────────────────────────────────────┘ |
| |
| Step 2 — Choose Simulation Mode: |
| ┌──────────────────────────────────────────────────────────────┐ |
| │ 1. random — Simu picks a random simulation for you │ |
| │ 2. custom — You describe exactly what you want │ |
| │ 3. everything — Run ALL 6 simulations at once │ |
| └──────────────────────────────────────────────────────────────┘ |
| |
| Both selections are remembered for the session. |
| Type 'switch brain' or 'switch sim' at any time to change. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import os |
| import re |
| import json |
| import random |
| import textwrap |
| from contextlib import contextmanager, redirect_stderr, redirect_stdout |
| from pathlib import Path |
| from typing import Any, Dict, List, Optional, Tuple |
|
|
| import numpy as np |
|
|
| from .intent import parse_intent, CITIES |
|
|
| |
| |
| |
| HF_MODEL_ID = "HuggingFaceTB/SmolLM2-360M-Instruct" |
| MAX_NEW_TOKENS = 512 |
| TEMPERATURE = 0.3 |
|
|
| |
| ALL_SIM_TYPES = [ |
| "random_walk", |
| "projectile", |
| "water_flow", |
| "agent", |
| "traffic", |
| "profile", |
| ] |
|
|
| |
| |
| |
| MODE_UNTRAINED = "untrained" |
| MODE_HUGGINGFACE = "huggingface" |
| MODE_CUSTOM = "custom" |
|
|
| _BRAIN_ALIASES: Dict[str, str] = { |
| "untrained": MODE_UNTRAINED, "rules": MODE_UNTRAINED, |
| "rule": MODE_UNTRAINED, "fast": MODE_UNTRAINED, "1": MODE_UNTRAINED, |
| "huggingface": MODE_HUGGINGFACE, "hf": MODE_HUGGINGFACE, |
| "smollm": MODE_HUGGINGFACE, "smollm2": MODE_HUGGINGFACE, "2": MODE_HUGGINGFACE, |
| "custom": MODE_CUSTOM, "upload": MODE_CUSTOM, |
| "my": MODE_CUSTOM, "own": MODE_CUSTOM, "3": MODE_CUSTOM, |
| } |
|
|
| |
| |
| |
| SIMMODE_RANDOM = "random" |
| SIMMODE_CUSTOM = "custom" |
| SIMMODE_EVERYTHING = "everything" |
|
|
| _SIMMODE_ALIASES: Dict[str, str] = { |
| "random": SIMMODE_RANDOM, |
| "rand": SIMMODE_RANDOM, |
| "surprise": SIMMODE_RANDOM, |
| "random simulation": SIMMODE_RANDOM, |
| "1": SIMMODE_RANDOM, |
| "custom": SIMMODE_CUSTOM, |
| "describe": SIMMODE_CUSTOM, |
| "manual": SIMMODE_CUSTOM, |
| "choose": SIMMODE_CUSTOM, |
| "specific": SIMMODE_CUSTOM, |
| "2": SIMMODE_CUSTOM, |
| "everything": SIMMODE_EVERYTHING, |
| "all": SIMMODE_EVERYTHING, |
| "every": SIMMODE_EVERYTHING, |
| "all sims": SIMMODE_EVERYTHING, |
| "run all": SIMMODE_EVERYTHING, |
| "3": SIMMODE_EVERYTHING, |
| } |
|
|
| |
| |
| |
| _BRAIN_BANNER = """ |
| ╔══════════════════════════════════════════════════════════════╗ |
| ║ 🤖 Simu — Step 1: Choose Your AI Brain ║ |
| ╠══════════════════════════════════════════════════════════════╣ |
| ║ ║ |
| ║ 1. untrained — Rule-based parser. Instant, no download. ║ |
| ║ Great for clear, direct requests. ║ |
| ║ ║ |
| ║ 2. huggingface — SmolLM2-360M-Instruct ★ recommended ★ ║ |
| ║ Open-source LLM, ~700 MB, CPU-capable. ║ |
| ║ Handles complex / ambiguous language. ║ |
| ║ ║ |
| ║ 3. custom — Your own model. ║ |
| ║ HuggingFace repo ID, local folder, ║ |
| ║ or a .gguf file path. ║ |
| ║ ║ |
| ╚══════════════════════════════════════════════════════════════╝ |
| Type the name or number (untrained / huggingface / custom): |
| """ |
|
|
| _SIMMODE_BANNER = """ |
| ╔══════════════════════════════════════════════════════════════╗ |
| ║ 🎮 Simu — Step 2: Choose Simulation Mode ║ |
| ╠══════════════════════════════════════════════════════════════╣ |
| ║ ║ |
| ║ 1. random — Simu surprises you! ║ |
| ║ Picks a random simulation + location. ║ |
| ║ ║ |
| ║ 2. custom — You're in control. ║ |
| ║ Describe exactly what you want in ║ |
| ║ plain English and Simu will run it. ║ |
| ║ ║ |
| ║ 3. everything — Run them all. ║ |
| ║ Simu runs all 6 simulations at once ║ |
| ║ and returns every result. ║ |
| ║ ║ |
| ╚══════════════════════════════════════════════════════════════╝ |
| Type the name or number (random / custom / everything): |
| """ |
|
|
| _SIMU_SYSTEM_PROMPT = """\ |
| You are Simu, the AI assistant embedded in MSKit (Mini Simulation Kit). |
| MSKit runs terrain simulations on real-world JAXA AW3D30 elevation data |
| and live traffic from OpenTraffic + UTD19. |
| |
| Understand what simulation the user wants and reply with: |
| 1. A short friendly explanation of what you will run. |
| 2. A JSON block (```json ... ```) with simulation parameters. |
| |
| Simulations available: |
| random_walk — slope-biased terrain walk |
| projectile — ballistic trajectory over terrain |
| water_flow — D8 runoff routing |
| agent — RL terrain-navigating agent |
| traffic — road speed / congestion query |
| profile — elevation cross-section between two points |
| |
| JSON schema: |
| { |
| "sim_type": "random_walk", |
| "location": {"lat": 35.68, "lon": 139.69, "name": "Tokyo"}, |
| "params": {"steps": 500}, |
| "explanation": "Running a 500-step walk in Tokyo." |
| } |
| |
| Be friendly, concise, and accurate. You are Simu! |
| """ |
|
|
|
|
| |
| |
| |
| @contextmanager |
| def _quiet(): |
| with open(os.devnull, "w") as devnull: |
| with redirect_stdout(devnull), redirect_stderr(devnull): |
| yield |
|
|
|
|
| def _is_gguf(path: str) -> bool: |
| try: |
| with open(path, "rb") as f: |
| return f.read(4) == b"GGUF" |
| except Exception: |
| return False |
|
|
|
|
| def _random_location() -> Dict[str, Any]: |
| """Pick a random city from the known list.""" |
| name = random.choice(list(CITIES.keys())) |
| lat, lon = CITIES[name] |
| return {"lat": lat, "lon": lon, "name": name.title()} |
|
|
|
|
| def _random_params(sim_type: str) -> Dict[str, Any]: |
| """Generate sensible random params for a sim type.""" |
| if sim_type == "random_walk": |
| return {"steps": random.choice([200, 300, 500, 1000]), |
| "slope_bias": round(random.uniform(0.2, 0.9), 2)} |
| if sim_type == "projectile": |
| return {"elevation_deg": random.choice([15, 30, 45, 60, 75]), |
| "azimuth_deg": random.choice([0, 45, 90, 135, 180, 270]), |
| "speed_ms": random.choice([40, 60, 80, 100, 120])} |
| if sim_type == "water_flow": |
| return {"patch_km": random.choice([3, 5, 8, 10]), |
| "steps": random.choice([1000, 3000, 5000])} |
| if sim_type == "agent": |
| return {"steps": random.choice([100, 200, 300])} |
| if sim_type == "traffic": |
| return {} |
| if sim_type == "profile": |
| return {"steps": random.choice([100, 200])} |
| return {} |
|
|
|
|
| |
| |
| |
| class Simu: |
| """ |
| Simu — MSKit's AI assistant. |
| |
| Startup sequence (fires before the first simulation): |
| 1. Brain selection — untrained / huggingface / custom |
| 2. Simulation mode — random / custom / everything |
| |
| Parameters |
| ---------- |
| dem_loader : DEMLoader, optional |
| traffic_router : TrafficRouter, optional |
| verbose : bool |
| auto_select : str, optional |
| Pre-select brain ("untrained" | "huggingface" | "custom"). |
| auto_simmode : str, optional |
| Pre-select sim mode ("random" | "custom" | "everything"). |
| custom_model : str, optional |
| Model path/repo for custom brain mode. |
| |
| Examples |
| -------- |
| >>> from mskit import Simu |
| >>> simu = Simu() # full interactive startup |
| >>> simu = Simu(auto_select="untrained", auto_simmode="custom") |
| >>> simu = Simu(auto_select="huggingface", auto_simmode="everything") |
| |
| >>> result = simu.chat("Random walk in Tokyo for 500 steps") |
| >>> results = simu.run_all("Mount Fuji") # everything mode helper |
| """ |
|
|
| def __init__( |
| self, |
| dem_loader=None, |
| traffic_router=None, |
| verbose: bool = True, |
| auto_select: Optional[str] = None, |
| auto_simmode: Optional[str] = None, |
| custom_model: Optional[str] = None, |
| ): |
| self._dem = dem_loader |
| self._traffic = traffic_router |
| self._verbose = verbose |
| self._model = None |
| self._tokenizer = None |
| self._brain_mode: Optional[str] = None |
| self._sim_mode: Optional[str] = None |
| self._model_label = "none" |
| self._history: List[Dict[str, str]] = [] |
| self._ready = False |
| self._custom_model_path: Optional[str] = custom_model |
|
|
| |
| _brain = _BRAIN_ALIASES.get((auto_select or "").lower().strip()) |
| _smode = _SIMMODE_ALIASES.get((auto_simmode or "").lower().strip()) |
|
|
| if _brain: |
| self._apply_brain(_brain, custom_model) |
| if _smode: |
| self._sim_mode = _smode |
|
|
| if _brain and _smode: |
| self._ready = True |
|
|
| |
| |
| |
|
|
| def chat(self, message: str) -> Dict[str, Any]: |
| """ |
| Send a natural language message to Simu. |
| |
| In 'random' sim mode → ignores your text, picks a random sim. |
| In 'custom' sim mode → uses your description to pick the sim. |
| In 'everything' sim mode → runs all 6 sims, uses your location hint. |
| """ |
| if not self._ready: |
| self._startup() |
|
|
| |
| if self._sim_mode == SIMMODE_RANDOM: |
| return self._run_random_surprise() |
|
|
| |
| if self._sim_mode == SIMMODE_EVERYTHING: |
| return self._run_everything(message) |
|
|
| |
| self._print(f"\n💬 You: {message}") |
| intent, response_text, source = self._understand(message) |
|
|
| self._print(f"\n🤖 Simu: {response_text}\n") |
| self._print(f" → Sim : {intent['sim_type']} @ {intent['location']['name']}") |
| self._print(f" → Params : {intent['params']}") |
| self._print(f" → Conf : {intent['confidence']:.0%}" |
| f" [brain: {self._brain_mode}/{self._model_label}]" |
| f" [mode: {self._sim_mode}]") |
|
|
| output = None |
| if self._dem is not None or intent["sim_type"] == "traffic": |
| output = self._dispatch(intent) |
| if output and self._verbose: |
| self._print(f" → Result : {self._summarise(output)}") |
|
|
| self._history.append({"role": "user", "content": message}) |
| self._history.append({"role": "assistant", "content": response_text}) |
|
|
| return { |
| "intent": intent, |
| "response": response_text, |
| "output": output, |
| "source": source, |
| "brain": self._brain_mode, |
| "sim_mode": self._sim_mode, |
| } |
|
|
| def run(self, description: str) -> Dict[str, Any]: |
| """Alias for chat().""" |
| return self.chat(description) |
|
|
| def run_all(self, location_hint: str = "Tokyo") -> Dict[str, Any]: |
| """Shortcut: run all 6 simulations for a given location.""" |
| old_mode = self._sim_mode |
| self._sim_mode = SIMMODE_EVERYTHING |
| result = self._run_everything(location_hint) |
| self._sim_mode = old_mode |
| return result |
|
|
| def select_brain(self, mode: str, custom_model: Optional[str] = None): |
| """Programmatically select a brain.""" |
| resolved = _BRAIN_ALIASES.get(mode.lower().strip(), mode.lower().strip()) |
| self._apply_brain(resolved, custom_model) |
|
|
| def select_sim_mode(self, mode: str): |
| """Programmatically select a simulation mode.""" |
| resolved = _SIMMODE_ALIASES.get(mode.lower().strip(), mode.lower().strip()) |
| if resolved not in (SIMMODE_RANDOM, SIMMODE_CUSTOM, SIMMODE_EVERYTHING): |
| raise ValueError(f"Unknown sim mode '{mode}'. " |
| "Use: random / custom / everything") |
| self._sim_mode = resolved |
| self._print(f"✅ Simu: Simulation mode set to '{resolved}'.\n") |
|
|
| def switch_brain(self): |
| """Re-run brain selection interactively.""" |
| self._brain_mode = None |
| self._model = None |
| self._tokenizer = None |
| self._ready = False |
| self._startup() |
|
|
| def switch_sim_mode(self): |
| """Re-run simulation mode selection interactively.""" |
| self._sim_mode = None |
| self._select_sim_mode() |
|
|
| def help(self) -> str: |
| msg = textwrap.dedent(f""" |
| ╔══════════════════════════════════════════════════════╗ |
| ║ Hi! I'm Simu 👋 ║ |
| ║ MSKit's AI simulation assistant ║ |
| ╚══════════════════════════════════════════════════════╝ |
| Brain : {self._brain_mode or 'not selected'} ({self._model_label}) |
| Sim mode : {self._sim_mode or 'not selected'} |
| |
| Simulation modes: |
| random → Simu picks a surprise sim + random location |
| custom → You describe what you want in plain English |
| everything → All 6 sims run at once (just give a location) |
| |
| Sims available: random_walk · projectile · water_flow |
| agent · traffic · profile |
| |
| Example phrases (custom mode): |
| "Random walk in Tokyo for 1000 steps" |
| "Shoot a projectile from Mount Fuji east at 45° 80 m/s" |
| "Water flow in Zurich" |
| "Traffic in London" |
| "Agent from 35.6,139.7 to 35.65,139.75" |
| "Elevation profile between Berlin and Munich" |
| |
| Commands: |
| switch brain → re-pick AI model |
| switch sim → re-pick simulation mode |
| help → this message |
| quit → exit |
| """) |
| print(msg) |
| return msg |
|
|
| def reset(self): |
| """Clear conversation history (keeps brain + mode).""" |
| self._history = [] |
|
|
| |
| |
| |
|
|
| def _startup(self): |
| """Run both selection steps in order.""" |
| if self._brain_mode is None: |
| self._select_brain() |
| if self._sim_mode is None: |
| self._select_sim_mode() |
| self._ready = True |
|
|
| |
|
|
| def _select_brain(self): |
| print(_BRAIN_BANNER, flush=True) |
| while True: |
| try: |
| raw = input("› ").strip().lower() |
| except (EOFError, KeyboardInterrupt): |
| raw = "untrained" |
|
|
| mode = _BRAIN_ALIASES.get(raw) |
| if mode is None: |
| print(f" ❌ '{raw}' not recognised. " |
| "Type: untrained, huggingface, or custom.") |
| continue |
|
|
| if mode == MODE_CUSTOM: |
| path = self._ask_custom_model() |
| self._apply_brain(MODE_CUSTOM, path) |
| else: |
| self._apply_brain(mode, None) |
| break |
|
|
| def _ask_custom_model(self) -> str: |
| print(""" |
| ┌─ Custom Model ──────────────────────────────────────────────┐ |
| │ Enter ONE of: │ |
| │ • HuggingFace repo ID e.g. mistralai/Mistral-7B-... │ |
| │ • Local folder path e.g. /home/you/my-model/ │ |
| │ • Local .gguf file e.g. /home/you/mistral.gguf │ |
| └─────────────────────────────────────────────────────────────┘""") |
| while True: |
| try: |
| raw = input(" Model path / repo › ").strip() |
| except (EOFError, KeyboardInterrupt): |
| return "" |
| if raw: |
| return raw |
| print(" Please enter a value (Ctrl+C to cancel and use untrained).") |
|
|
| |
|
|
| def _select_sim_mode(self): |
| print(_SIMMODE_BANNER, flush=True) |
| while True: |
| try: |
| raw = input("› ").strip().lower() |
| except (EOFError, KeyboardInterrupt): |
| raw = "custom" |
|
|
| mode = _SIMMODE_ALIASES.get(raw) |
| if mode is None: |
| print(f" ❌ '{raw}' not recognised. " |
| "Type: random, custom, or everything.") |
| continue |
|
|
| self._sim_mode = mode |
| labels = { |
| SIMMODE_RANDOM: "Simu will surprise you with a random simulation!", |
| SIMMODE_CUSTOM: "Describe what you want and I'll run it.", |
| SIMMODE_EVERYTHING: "I'll run ALL 6 simulations at once!", |
| } |
| self._print(f"\n✅ Simu: {labels[mode]}\n") |
| break |
|
|
| |
| |
| |
|
|
| def _apply_brain(self, mode: str, custom_path: Optional[str] = None): |
| self._brain_mode = mode |
|
|
| if mode == MODE_UNTRAINED: |
| self._model = None |
| self._tokenizer = None |
| self._model_label = "rule-based" |
| self._print("\n✅ Simu: Rule-based brain ready — no download needed.\n") |
|
|
| elif mode == MODE_HUGGINGFACE: |
| self._model_label = HF_MODEL_ID |
| self._print(f"\n🔽 Simu: Downloading {HF_MODEL_ID} (~700 MB on first run)...\n") |
| self._load_transformers(HF_MODEL_ID) |
|
|
| elif mode == MODE_CUSTOM: |
| if not custom_path: |
| self._print("⚠️ No model path given — falling back to untrained.\n") |
| self._apply_brain(MODE_UNTRAINED) |
| return |
| self._model_label = custom_path |
| if custom_path.endswith(".gguf") or ( |
| Path(custom_path).is_file() and _is_gguf(custom_path) |
| ): |
| self._print(f"\n🔽 Simu: Loading GGUF '{Path(custom_path).name}'...\n") |
| self._load_gguf(custom_path) |
| else: |
| self._print(f"\n🔽 Simu: Loading HF model '{custom_path}'...\n") |
| self._load_transformers(custom_path) |
|
|
| def _load_transformers(self, model_id: str): |
| try: |
| import torch |
| from transformers import AutoTokenizer, AutoModelForCausalLM |
| token = os.environ.get("HF_TOKEN") |
| with _quiet(): |
| tok = AutoTokenizer.from_pretrained(model_id, token=token) |
| mdl = AutoModelForCausalLM.from_pretrained( |
| model_id, token=token, |
| torch_dtype=torch.float32, low_cpu_mem_usage=True, |
| ) |
| mdl.eval() |
| self._tokenizer = tok |
| self._model = mdl |
| self._model_label = model_id |
| self._print(f"✅ Simu: '{model_id}' loaded and ready!\n") |
| except ImportError: |
| self._print("⚠️ 'transformers' not installed — run: pip install mskit[llm]") |
| self._print(" Falling back to rule-based.\n") |
| self._brain_mode = MODE_UNTRAINED |
| except Exception as e: |
| self._print(f"⚠️ Could not load '{model_id}': {e}") |
| self._print(" Falling back to rule-based.\n") |
| self._brain_mode = MODE_UNTRAINED |
|
|
| def _load_gguf(self, gguf_path: str): |
| try: |
| from llama_cpp import Llama |
| with _quiet(): |
| self._model = Llama(model_path=gguf_path, n_ctx=2048, verbose=False) |
| self._model_label = Path(gguf_path).name |
| self._brain_mode = f"{MODE_CUSTOM}:gguf" |
| self._print(f"✅ Simu: GGUF '{Path(gguf_path).name}' loaded!\n") |
| except ImportError: |
| self._print("⚠️ 'llama-cpp-python' not installed — run: pip install mskit[gguf]") |
| self._print(" Falling back to rule-based.\n") |
| self._brain_mode = MODE_UNTRAINED |
| except Exception as e: |
| self._print(f"⚠️ Could not load GGUF: {e}") |
| self._print(" Falling back to rule-based.\n") |
| self._brain_mode = MODE_UNTRAINED |
|
|
| |
| |
| |
|
|
| def _run_random_surprise(self) -> Dict[str, Any]: |
| """Pick a random sim type + random city and run it.""" |
| sim_type = random.choice(ALL_SIM_TYPES) |
| location = _random_location() |
| params = _random_params(sim_type) |
|
|
| self._print(f"\n🎲 Simu: Surprise! Running a {sim_type.replace('_',' ')} " |
| f"simulation at {location['name']}...") |
| self._print(f" → Params : {params}\n") |
|
|
| intent = { |
| "sim_type": sim_type, |
| "location": location, |
| "params": params, |
| "confidence": 1.0, |
| "raw": "(random)", |
| "explanation": f"Random {sim_type} at {location['name']}.", |
| } |
|
|
| output = None |
| if self._dem is not None or sim_type == "traffic": |
| output = self._dispatch(intent) |
| if output and self._verbose: |
| self._print(f" → Result : {self._summarise(output)}") |
|
|
| return { |
| "intent": intent, |
| "response": f"🎲 Ran a random {sim_type.replace('_',' ')} at {location['name']}!", |
| "output": output, |
| "source": "random", |
| "brain": self._brain_mode, |
| "sim_mode": self._sim_mode, |
| } |
|
|
| def _run_everything(self, message: str) -> Dict[str, Any]: |
| """Run all 6 simulations. Location extracted from message or random.""" |
| from .intent import _find_location |
| loc = _find_location(message) or _random_location() |
|
|
| self._print(f"\n🌍 Simu: Running ALL 6 simulations at {loc['name']}...\n") |
|
|
| results: Dict[str, Any] = {} |
| summary_lines = [] |
|
|
| for sim_type in ALL_SIM_TYPES: |
| params = _random_params(sim_type) |
| |
| if sim_type == "agent": |
| params["target_lat"] = loc["lat"] + 0.045 |
| params["target_lon"] = loc["lon"] + 0.045 |
| if sim_type == "profile": |
| params["target_lat"] = loc["lat"] + 0.1 |
| params["target_lon"] = loc["lon"] + 0.1 |
|
|
| self._print(f" ▶ {sim_type:<12} ...", ) |
|
|
| intent = { |
| "sim_type": sim_type, |
| "location": loc, |
| "params": params, |
| "confidence": 1.0, |
| "raw": message, |
| "explanation": f"{sim_type} at {loc['name']}.", |
| } |
|
|
| try: |
| if self._dem is not None or sim_type == "traffic": |
| output = self._dispatch(intent) |
| else: |
| output = {"note": "No DEM loader — params only", **params} |
| results[sim_type] = output |
| summary_lines.append(f" ✓ {sim_type:<12} {self._summarise(output)}") |
| self._print(f" done — {self._summarise(output)}") |
| except Exception as e: |
| results[sim_type] = {"error": str(e)} |
| summary_lines.append(f" ✗ {sim_type:<12} Error: {e}") |
| self._print(f" ✗ Error: {e}") |
|
|
| summary = "\n🏁 Simu: All done!\n" + "\n".join(summary_lines) |
| self._print(summary) |
|
|
| return { |
| "intent": {"sim_type": "everything", "location": loc, "params": {}}, |
| "response": summary, |
| "output": results, |
| "source": "everything", |
| "brain": self._brain_mode, |
| "sim_mode": self._sim_mode, |
| } |
|
|
| |
| |
| |
|
|
| def _understand(self, text: str) -> Tuple[Dict, str, str]: |
| intent = parse_intent(text) |
|
|
| if self._brain_mode and "gguf" in self._brain_mode and self._model: |
| try: |
| llm_intent, resp = self._gguf_understand(text, intent) |
| return llm_intent, resp, "llm:gguf" |
| except Exception as e: |
| self._print(f" [GGUF error: {e} — using rules]") |
|
|
| elif self._model is not None and self._tokenizer is not None: |
| try: |
| llm_intent, resp = self._transformers_understand(text, intent) |
| return llm_intent, resp, "llm:transformers" |
| except Exception as e: |
| self._print(f" [LLM error: {e} — using rules]") |
|
|
| return intent, self._rules_response(intent), "rules" |
|
|
| def _transformers_understand(self, text: str, rule_intent: Dict) -> Tuple[Dict, str]: |
| messages = [{"role": "system", "content": _SIMU_SYSTEM_PROMPT}] |
| for turn in self._history[-4:]: |
| messages.append(turn) |
| messages.append({"role": "user", "content": text}) |
|
|
| chat_text = self._tokenizer.apply_chat_template( |
| messages, tokenize=False, add_generation_prompt=True, |
| ) |
| inputs = self._tokenizer(chat_text, return_tensors="pt") |
| import torch |
| with torch.no_grad(): |
| out = self._model.generate( |
| **inputs, |
| max_new_tokens=MAX_NEW_TOKENS, |
| temperature=TEMPERATURE, |
| do_sample=True, |
| pad_token_id=self._tokenizer.eos_token_id, |
| ) |
| new_tokens = out[0][inputs["input_ids"].shape[1]:] |
| response = self._tokenizer.decode(new_tokens, skip_special_tokens=True).strip() |
| return self._extract_json(response, rule_intent), response |
|
|
| def _gguf_understand(self, text: str, rule_intent: Dict) -> Tuple[Dict, str]: |
| messages = [{"role": "system", "content": _SIMU_SYSTEM_PROMPT}] |
| for turn in self._history[-4:]: |
| messages.append(turn) |
| messages.append({"role": "user", "content": text}) |
| out = self._model.create_chat_completion( |
| messages=messages, max_tokens=MAX_NEW_TOKENS, temperature=TEMPERATURE, |
| ) |
| response = out["choices"][0]["message"]["content"].strip() |
| return self._extract_json(response, rule_intent), response |
|
|
| def _extract_json(self, response: str, fallback: Dict) -> Dict: |
| m = re.search(r"```json\s*(\{.*?\})\s*```", response, re.DOTALL) |
| if not m: |
| m = re.search(r"\{[^{}]*\"sim_type\"[^{}]*\}", response, re.DOTALL) |
| if not m: |
| return fallback |
| try: |
| raw = m.group(1) if "```" in m.group(0) else m.group(0) |
| data = json.loads(raw) |
| intent = dict(fallback) |
| intent["sim_type"] = data.get("sim_type", fallback["sim_type"]) |
| if "location" in data: |
| intent["location"] = data["location"] |
| if "params" in data: |
| intent["params"] = {**fallback["params"], **data["params"]} |
| intent["confidence"] = min(fallback["confidence"] + 0.2, 1.0) |
| return intent |
| except (json.JSONDecodeError, KeyError): |
| return fallback |
|
|
| def _rules_response(self, intent: Dict) -> str: |
| sim = intent["sim_type"].replace("_", " ") |
| loc = intent["location"]["name"] |
| params = intent["params"] |
| lines = [f"Sure! Running a {sim} simulation at {loc}."] |
| if params: |
| lines.append("Parameters: " + ", ".join(f"{k}={v}" for k, v in params.items())) |
| if intent["confidence"] < 0.6: |
| lines.append("(Tip: try rephrasing if the result looks off!)") |
| return " ".join(lines) |
|
|
| |
| |
| |
|
|
| def _dispatch(self, intent: Dict) -> Optional[Dict[str, Any]]: |
| sim_type = intent["sim_type"] |
| loc = intent["location"] |
| params = intent.get("params", {}) |
| lat, lon = loc["lat"], loc["lon"] |
| try: |
| fn = { |
| "random_walk": self._run_random_walk, |
| "projectile": self._run_projectile, |
| "water_flow": self._run_water_flow, |
| "agent": self._run_agent, |
| "traffic": self._run_traffic, |
| "profile": self._run_profile, |
| }.get(sim_type) |
| return fn(lat, lon, params) if fn else {"error": f"Unknown: {sim_type}"} |
| except Exception as e: |
| return {"error": str(e), "sim_type": sim_type} |
|
|
| def _run_random_walk(self, lat, lon, params) -> Dict: |
| from ..sims.random_walk import RandomWalk |
| rw = RandomWalk(self._dem, lat, lon, |
| step_m=params.get("step_m", 300), |
| slope_bias=params.get("slope_bias", 0.5)) |
| path = rw.run(steps=params.get("steps", 500)) |
| return {"sim_type": "random_walk", "steps": len(path), |
| "total_distance_km": round(rw.total_distance_km(), 3), |
| "displacement_km": round(rw.displacement_km(), 3), |
| "elevation_gain_m": round(rw.elevation_gain_m(), 1), |
| "path_shape": list(rw.to_numpy().shape), |
| "start": (lat, lon), "end": (path[-1][0], path[-1][1])} |
|
|
| def _run_projectile(self, lat, lon, params) -> Dict: |
| from ..sims.projectile import Projectile |
| proj = Projectile(self._dem, lat, lon, |
| azimuth_deg=params.get("azimuth_deg", 90), |
| elevation_deg=params.get("elevation_deg", 45), |
| speed_ms=params.get("speed_ms", 80), |
| drag_coeff=params.get("drag_coeff", 0.0)) |
| traj = proj.run() |
| return {"sim_type": "projectile", "steps": len(traj), |
| "range_km": round(proj.range_km(), 4), |
| "flight_time_s": round(proj.flight_time(), 2), |
| "max_altitude_m": round(proj.max_altitude_m(), 1), |
| "impact": (traj[-1][0], traj[-1][1]) if traj else None, |
| "traj_shape": list(proj.to_numpy().shape)} |
|
|
| def _run_water_flow(self, lat, lon, params) -> Dict: |
| from ..sims.flow import WaterFlow |
| wf = WaterFlow(self._dem, patch_km=params.get("patch_km", 10)) |
| path = wf.run(lat, lon, max_steps=params.get("steps", 5000)) |
| return {"sim_type": "water_flow", "steps": len(path), |
| "total_descent_m": round(wf.total_descent_m(), 1), |
| "accumulation": wf.accumulation(), |
| "sink": (path[-1][0], path[-1][1]) if path else None} |
|
|
| def _run_agent(self, lat, lon, params) -> Dict: |
| from ..sims.agent import TerrainAgent |
| tlat = params.get("target_lat", lat + 0.05) |
| tlon = params.get("target_lon", lon + 0.05) |
| agent = TerrainAgent(self._dem, lat, lon, tlat, tlon, |
| step_m=params.get("step_m", 300)) |
| episode = agent.generate_episode( |
| max_steps=params.get("steps", 300), |
| policy=params.get("policy", "mixed"), |
| ) |
| arr = agent.to_numpy() |
| return {"sim_type": "agent", "steps": len(episode), |
| "reached_target": agent.reached_target(), |
| "total_reward": round(sum(r["reward"] for r in episode), 2), |
| "start": (lat, lon), "target": (tlat, tlon), |
| "episode_shape": list(arr.shape) if arr.size else [0, 7]} |
|
|
| def _run_traffic(self, lat, lon, params) -> Dict: |
| if self._traffic is None: |
| return {"error": "No TrafficRouter provided to Simu."} |
| info = self._traffic.traffic_at(lat, lon) |
| return {"sim_type": "traffic", **info.to_dict()} |
|
|
| def _run_profile(self, lat, lon, params) -> Dict: |
| tlat = params.get("target_lat", lat + 0.1) |
| tlon = params.get("target_lon", lon + 0.1) |
| steps = params.get("steps", 200) |
| dists, elevs = self._dem.elevation_profile(lat, lon, tlat, tlon, steps=steps) |
| return {"sim_type": "profile", |
| "start": (lat, lon), "end": (tlat, tlon), |
| "total_distance_km": round(float(dists[-1]), 3), |
| "min_elev_m": round(float(elevs.min()), 1), |
| "max_elev_m": round(float(elevs.max()), 1), |
| "steps": steps} |
|
|
| |
| |
| |
|
|
| def _print(self, msg: str): |
| if self._verbose: |
| print(msg, flush=True) |
|
|
| def _summarise(self, output: Dict) -> str: |
| if not output or "error" in output: |
| return f"Error: {output.get('error', '?')}" if output else "no output" |
| sim = output.get("sim_type", "?") |
| if sim == "random_walk": |
| return (f"walked {output['total_distance_km']} km, " |
| f"gain {output['elevation_gain_m']} m") |
| if sim == "projectile": |
| return (f"range {output['range_km']} km, " |
| f"flight {output['flight_time_s']} s, " |
| f"peak {output['max_altitude_m']} m") |
| if sim == "water_flow": |
| return f"{output['steps']} steps, descent {output['total_descent_m']} m" |
| if sim == "agent": |
| flag = "✓ reached" if output["reached_target"] else "✗ missed" |
| return (f"{output['steps']} steps, {flag} target, " |
| f"reward {output['total_reward']}") |
| if sim == "traffic": |
| return (f"{output.get('speed_kmh','?'):.1f} km/h " |
| f"[{output.get('congestion_level','?')}] " |
| f"src={output.get('source','?')}") |
| if sim == "profile": |
| return (f"{output['total_distance_km']} km, " |
| f"{output['min_elev_m']}–{output['max_elev_m']} m elev") |
| return str(output) |
|
|
| @property |
| def brain_mode(self) -> Optional[str]: |
| return self._brain_mode |
|
|
| @property |
| def sim_mode(self) -> Optional[str]: |
| return self._sim_mode |
|
|
| @property |
| def model_loaded(self) -> bool: |
| return self._model is not None |
|
|
|
|
| |
| |
| |
| def _cli_main(): |
| print("╔══════════════════════════════════════════════╗") |
| print("║ Simu — MSKit AI Simulation Assistant 🤖 ║") |
| print("║ Type 'help', 'switch brain', ║") |
| print("║ 'switch sim', or 'quit' ║") |
| print("╚══════════════════════════════════════════════╝\n") |
|
|
| simu = Simu(verbose=True) |
|
|
| while True: |
| try: |
| user_input = input("You: ").strip() |
| except (EOFError, KeyboardInterrupt): |
| print("\nSimu: Bye! 👋") |
| break |
| if not user_input: |
| continue |
| low = user_input.lower() |
| if low in ("quit", "exit", "bye", "q"): |
| print("Simu: Bye! 👋") |
| break |
| if low == "help": |
| simu.help() |
| continue |
| if low in ("switch brain", "change brain", "change model"): |
| simu.switch_brain() |
| continue |
| if low in ("switch sim", "switch simulation", "change sim", "change mode"): |
| simu.switch_sim_mode() |
| continue |
| simu.chat(user_input) |
|
|
