diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..b9e9616c2badda8fba4ef3693ed61a654f8b1d57 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +NNGen/.env +NNGen/artifacts/ +NNGen/.venv/ +NNGen/__pycache__/ diff --git a/NNGen/.gitignore b/NNGen/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..a6c68375222aeaa7bdfcd442c512a763534441cd --- /dev/null +++ b/NNGen/.gitignore @@ -0,0 +1,89 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +*.egg-info/ +.installed.cfg +*.egg + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +Pipfile.lock + +# poetry +poetry.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Environments +.env +.venv +venv/ +ENV/ +env/ + +# VS Code +.vscode/ + +# PyCharm +.idea/ + +# Artifacts and outputs +artifacts/ +artifacts/** +*.png +*.jpg +*.jpeg + +# Secrets +app/llm/credentials.py +app/llm/credentials.json + +# Mac/Windows +.DS_Store +Thumbs.db \ No newline at end of file diff --git a/NNGen/AGENTS.md b/NNGen/AGENTS.md new file mode 100644 index 0000000000000000000000000000000000000000..7884b2b96e6498ba7166a0ded45efe880ab6ecf9 --- /dev/null +++ b/NNGen/AGENTS.md @@ -0,0 +1,38 @@ +# Repository Guidelines + +## Project Structure & Module Organization +- `app/cli.py` — CLI entry point; orchestrates a full run. +- `app/graph.py` — lightweight pipeline runner and edit loop. +- `app/nodes/` — individual agent nodes (`parser.py`, `planner.py`, `prompt_gen.py`, `gen_generate.py` [G1 skeleton], `gen_labels.py` [G2 labels], `judge.py`, `select.py`, `edit.py`, `archive.py`). Each exposes `run(state)` or similar. +- `app/prompts.py` — centralized prompts for parsing/planning/generation/judging/editing. +- `app/state.py` — typed `AppState` and artifact helpers. +- `app/llm/gemini.py` — `call_gemini(kind, **kwargs)` wrapper; uses local placeholders if no API key. +- `spec/` — example specs (e.g., `spec/vit.txt`). +- `artifacts/` — run outputs (time-stamped folders with `final.png`). + +## Setup, Run, and Development Commands +- Create env: `python -m venv .venv && source .venv/bin/activate` (Windows: `./.venv/Scripts/activate`). +- Install deps: `pip install -r requirements.txt`. +- Configure API (choose one): + - Env var: `export GEMINI_API_KEY=...` (supports `.env`). + - File: create `app/llm/credentials.py` like `credentials.example.py`. +- Run sample: `python -m app.cli --spec spec/vit.txt --K 3 --T 1`. +- Models: optionally set `GEMINI_MODEL`, `GEMINI_IMAGE_MODEL`, `GEMINI_IMAGE_EDIT_MODEL`. + +## Coding Style & Naming Conventions +- Python 3.10+, PEP8, 4-space indentation, type hints required in public APIs. +- Files: snake_case; functions: `snake_case`; classes: `PascalCase`. +- Nodes are pure where possible: read from `state`, return a new `state`; side effects limited to writing under `artifacts/`. +- Centralize prompt text in `app/prompts.py`; call models via `call_gemini` only. + +## Testing Guidelines +- No formal test suite yet. Prefer pytest with files under `tests/` named `test_*.py`. +- Minimal integration check: run the CLI and assert a `final.png` exists in the latest `artifacts/run_*` directory. + +## Commit & Pull Request Guidelines +- Use Conventional Commits: `feat:`, `fix:`, `docs:`, `refactor:`, `chore:`. +- PRs must include: purpose, linked issues, how to run, and a sample spec plus path to produced artifact (e.g., `artifacts/run_YYYYmmdd_HHMMSS/final.png`). + +## Security & Configuration Tips +- Do not commit secrets (`.env`, `app/llm/credentials.py`). Rotate keys if exposed. +- Large outputs live in `artifacts/`; avoid committing heavy assets unless necessary. diff --git a/NNGen/README.md b/NNGen/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1d7ae5abcf2a94db37b82a2f5241fc08d76a1f2f --- /dev/null +++ b/NNGen/README.md @@ -0,0 +1,80 @@ +# Multi-Agent Neural Network Diagram Generator (Skeleton) — Gemini 2.5 Flash Image + +This repository is a minimal, runnable skeleton that turns a textual NN spec into a publication-style diagram via a multi-agent pipeline: +- Parser → Planner → Prompt-Generator → Image-Generator (G1) → Label-Generator (G2) → Judge → Selector → (Editor loop) → Archivist +- All model calls flow through `call_gemini(...)`, making it easy to use Gemini 2.5 Flash for text and Gemini 2.5 Flash Image for images. + +Key additions in this version +- Two-stage generation: G1 draws the geometry-only skeleton (no text), G2 overlays labels on top of the skeleton. +- Hard violations: Judge returns actionable violations; missing labels are flagged as HARD to trigger edits reliably. +- Parallelism: G1, G2, and Judge run in parallel; set `NNG_CONCURRENCY` (default 4). +- Remote images by default: image generate/edit use Gemini 2.5 Flash Image models. If API is missing, the system can fall back to a local placeholder to stay runnable. + +## Quick Start + +1) Python 3.10+ + +2) Install deps +``` +pip install -r requirements.txt +``` + +3) Configure Gemini (choose one) +- Env var: `export GEMINI_API_KEY=YOUR_KEY` +- File: create `app/llm/credentials.py` with `GEMINI_API_KEY = "YOUR_KEY"` + +4) Run (K=candidates, T=max edit rounds) +``` +# Text mode (spec -> image) +python -m app.cli --mode text --spec spec/vit.txt --K 4 --T 1 + +# Image mode (text + image fusion/edit) +# Example: edit an existing diagram with a component replacement using a reference image +python -m app.cli --mode image --base-image path/to/base.png \ + --ref-image path/to/transformer_ref.png \ + --instructions "Replace the UNet backbone with a Transformer (DiT); keep layout, font, and colors consistent." +``` +Artifacts are saved under `artifacts/run_YYYYmmdd_HHMMSS/` with `final.png` as the chosen result. + +## Gemini 2.5 Flash Image in This Project +- G1 geometry: `gen_generate.py` calls `GEMINI_IMAGE_MODEL` (Gemini 2.5 Flash Image) to render a clean, geometry-only skeleton quickly. +- G2 labels: `gen_labels.py` uses `GEMINI_IMAGE_EDIT_MODEL` to overlay text labels onto the G1 skeleton without redrawing everything. +- Edit loop: `edit.py` performs targeted corrections via the same image model, enabling fast, iterative refinements instead of full regenerations. +- Why it matters: the model’s speed and editability make multi-round diagram refinement practical while preserving layout quality. +- Fallback: if no API key is available, the pipeline remains runnable using local placeholders generated by `app/llm/gemini.py`. + +## Models +- `GEMINI_MODEL` (default `gemini-2.5-flash`): parsing, planning, prompt generation, and judging. +- `GEMINI_IMAGE_MODEL` (recommended `gemini-2.5-flash-image` or `gemini-2.5-flash-image-preview`): image generation (G1). +- `GEMINI_IMAGE_EDIT_MODEL` (recommended `gemini-2.5-flash-image` or `gemini-2.5-flash-image-preview`): image editing (G2, Editor). +Notes: If `GEMINI_API_KEY` is not set, the pipeline uses offline placeholders to remain runnable. With an API key present, you must set valid image model env vars; errors are raised if image models are unset or calls fail (no automatic local fallback). + +## Fusion Mode (Text + Image) +- Accepts a base diagram (`--base-image`) and optional reference images (`--ref-image` repeatable) plus instructions. +- Uses Gemini 2.5 Flash Image to compose images under textual guidance – ideal for swapping a module (e.g., UNet → Transformer) while preserving style and layout. +- Outputs multiple fused candidates (`K`) and archives the first as `final.png`. + +## Structure +``` +app/ + cli.py # CLI entry (K/T/outdir) + graph.py # Orchestrator + edit loop + state.py # AppState + artifacts + prompts.py # Centralized prompts (parse/plan/G1/G2/judge/edit) + nodes/ + parser.py, planner.py, prompt_gen.py + gen_generate.py # G1 skeleton images (no text) + gen_labels.py # G2 label overlay edits + judge.py, select.py, edit.py, archive.py + llm/ + gemini.py # Unified wrapper (API + offline fallback) + credentials.example.py +spec/ + vit.txt # Example ViT spec (English) +artifacts/ # Outputs per run +``` + +## Tips +- Concurrency: `NNG_CONCURRENCY=4 python -m app.cli --spec ...` +- Tuning: Start with `K=4, T=1`; increase `T` for more correction rounds. +- Debug: image calls write `*.resp.txt`/`*.meta.json` alongside outputs (can be removed later if undesired). diff --git a/NNGen/app.py b/NNGen/app.py new file mode 100644 index 0000000000000000000000000000000000000000..a2be705c44ea0aa58e84e50d3e4b6e25d63d3c20 --- /dev/null +++ b/NNGen/app.py @@ -0,0 +1,9 @@ +from __future__ import annotations + +# Hugging Face Spaces entrypoint for Gradio +# Exposes a global `demo` variable that HF will serve. + +from scripts.gradio_app import app as create_app + +demo = create_app() + diff --git a/NNGen/app/__init__.py b/NNGen/app/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0c1debe0b503337bdf7186431b5c50d855b8dc44 --- /dev/null +++ b/NNGen/app/__init__.py @@ -0,0 +1 @@ +# empty package marker diff --git a/NNGen/app/cli.py b/NNGen/app/cli.py new file mode 100644 index 0000000000000000000000000000000000000000..099300db6a04b58b81ba3b3e8defff0f6e40056c --- /dev/null +++ b/NNGen/app/cli.py @@ -0,0 +1,55 @@ +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +from .graph import run_pipeline, run_fusion_pipeline +from .state import AppState + + +def main() -> None: + parser = argparse.ArgumentParser(description="NN Diagram Multi-Agent Pipeline") + parser.add_argument("--mode", type=str, choices=["text", "image"], default="text", help="'text' (spec→image) or 'image' (text+image fusion/edit)") + parser.add_argument("--spec", type=str, required=False, help="Path to .txt user prompt or .json spec (text mode)") + parser.add_argument("--K", type=int, default=4, help="Number of candidates") + parser.add_argument("--T", type=int, default=1, help="Max edit rounds") + parser.add_argument("--outdir", type=str, default="", help="Output directory (optional)") + parser.add_argument("--base-image", type=str, default="", help="Base image to edit (image mode)") + parser.add_argument("--ref-image", action="append", default=None, help="Additional reference image(s) (repeatable)") + parser.add_argument("--instructions", type=str, default="", help="Edit/fusion instructions (image mode)") + args = parser.parse_args() + + state: AppState = {"K": int(args.K), "T": int(args.T), "outdir": args.outdir or ""} + + if args.mode == "text": + if not args.spec: + raise SystemExit("--spec is required in text mode") + spec_path = Path(args.spec) + if not spec_path.exists(): + raise SystemExit(f"Spec file not found: {spec_path}") + if spec_path.suffix.lower() == ".json": + state["spec"] = json.loads(spec_path.read_text()) + else: + state["user_text"] = spec_path.read_text() + final_state = run_pipeline(state) + else: + # image fusion/edit mode + base_image = args.base_image.strip() + ref_images = args.ref_image or [] + if not base_image and not ref_images: + raise SystemExit("image mode requires --base-image and/or at least one --ref-image") + if base_image: + if not Path(base_image).exists(): + raise SystemExit(f"Base image not found: {base_image}") + state["base_image"] = base_image + valid_refs = [p for p in ref_images if p and Path(p).exists()] + state["ref_images"] = valid_refs + state["instructions"] = args.instructions or "Compose and update the figure to reflect the requested component changes while keeping overall style consistent." + final_state = run_fusion_pipeline(state) + + print(f"Artifacts saved under: {final_state['outdir']}") + + +if __name__ == "__main__": + main() diff --git a/NNGen/app/graph.py b/NNGen/app/graph.py new file mode 100644 index 0000000000000000000000000000000000000000..ca7633328b51b645d1b0c9321ea5559e1c43710a --- /dev/null +++ b/NNGen/app/graph.py @@ -0,0 +1,82 @@ +from __future__ import annotations + +from datetime import datetime +from pathlib import Path +from typing import Callable + +from .state import AppState +from .nodes import parser, planner, prompt_gen, gen_generate, gen_labels, judge, select, edit, archive +from .nodes import gen_fusion + + +def run_pipeline(state: AppState) -> AppState: + # ensure outdir + outdir = Path(state.get("outdir") or _default_outdir()) + outdir.mkdir(parents=True, exist_ok=True) + state["outdir"] = str(outdir) + state["round"] = int(state.get("round", 0)) + + # 1) parse → 2) plan → 3) prompts → 4) generate (skeleton) → 5) generator_2 (labels) → 6) judge → 7) select + state = parser.run(state) + state = planner.run(state) + state = prompt_gen.run(state) + state = gen_generate.run(state) + state = gen_labels.run(state) + state = judge.run(state) + state = select.run(state) + + # 8) edit loop (if hard violations or any violations, and round < T) + T = int(state.get("T", 0)) + while (state.get("hard_violations") or state.get("violations")) and state.get("round", 0) < T: + state["round"] = int(state.get("round", 0)) + 1 + state = edit.apply_edits(state) + # re-judge best image + state = _judge_best_only(state) + state = select.run(state) + + # 9) archive + state = archive.run(state) + return state + + +def run_fusion_pipeline(state: AppState) -> AppState: + # ensure outdir + outdir = Path(state.get("outdir") or _default_outdir()) + outdir.mkdir(parents=True, exist_ok=True) + state["outdir"] = str(outdir) + state["round"] = int(state.get("round", 0)) + + # Generate fused candidates from images + text instructions + state = gen_fusion.run(state) + + # If we have candidates, select first as best; optionally judge later + if state.get("images"): + state["best_image"] = state["images"][0] + + # Archive results (final.png etc.) + state = archive.run(state) + return state + + +def _judge_best_only(state: AppState) -> AppState: + # Only score the current best image again + from .llm.gemini import call_gemini + + if not state.get("best_image"): + return state + res = call_gemini("judge", image_path=state["best_image"].path, spec=state.get("spec", {})) + vios = list(res.get("violations", [])) + hard = [v for v in vios if str(v).strip().lower().startswith("hard:")] + if not hard: + hard = [v for v in vios if ("labels" in str(v).lower() and "missing" in str(v).lower())] + state["scores"] = [{ + "image_path": state["best_image"].path, + "score": float(res.get("score", 0.0)), + "violations": vios, + }] + state["hard_violations"] = hard + return state + + +def _default_outdir() -> str: + return f"artifacts/run_{datetime.now().strftime('%Y%m%d_%H%M%S')}" diff --git a/NNGen/app/llm/credentials.example.py b/NNGen/app/llm/credentials.example.py new file mode 100644 index 0000000000000000000000000000000000000000..ab6be33d677c2259552d69da80de428b89dda712 --- /dev/null +++ b/NNGen/app/llm/credentials.example.py @@ -0,0 +1,4 @@ +# Copy this file to credentials.py and fill in your key. + +GEMINI_API_KEY = "YOUR_GEMINI_API_KEY" + diff --git a/NNGen/app/llm/gemini.py b/NNGen/app/llm/gemini.py new file mode 100644 index 0000000000000000000000000000000000000000..d86ef44bb72e92c66c60374db7ba9cfe8c2bdd11 --- /dev/null +++ b/NNGen/app/llm/gemini.py @@ -0,0 +1,788 @@ +from __future__ import annotations + +import base64 +import json +import os +import random +import shutil +from pathlib import Path +from typing import Any, Dict, List, Optional +import os as _os + +try: + # optional local credentials file + from . import credentials # type: ignore +except Exception: + credentials = None # type: ignore + +# Load .env if present to populate environment variables +try: + from dotenv import load_dotenv # type: ignore + + load_dotenv() # searches for .env in CWD/parents +except Exception: + pass + +def _get_api_key() -> Optional[str]: + key = os.getenv("GEMINI_API_KEY") + if key: + return key + if credentials and getattr(credentials, "GEMINI_API_KEY", None): + return credentials.GEMINI_API_KEY # type: ignore + # Optional: read from ~/.config/gemini/api_key + try: + cfg_path = Path.home() / ".config" / "gemini" / "api_key" + if cfg_path.exists(): + return cfg_path.read_text().strip() + except Exception: + pass + return None + + +def call_gemini(kind: str, **kwargs) -> Dict[str, Any]: + """Unified entry for Gemini calls. + + kind: one of {"parse", "plan", "prompt_generate", "image_generate", "judge", "image_edit", "image_fuse"} + kwargs: payload for the corresponding action + + If API key is missing or a call fails, falls back to deterministic local placeholders + so the pipeline remains runnable offline. + """ + api_key = _get_api_key() + if not api_key: + # Simplified behavior: if no API key, always use local placeholders + return _local_placeholder(kind, **kwargs) + + # With an API key present, call the real service and surface errors directly + return _real_gemini(kind, api_key=api_key, **kwargs) + + +def _local_placeholder(kind: str, **kwargs) -> Dict[str, Any]: + # Deterministic pseudo behavior for offline usage + rng = random.Random(42) + + if kind == "parse": + user_text = kwargs.get("user_text", "") + # Very rough parse: split by arrows/lines → nodes & edges + lines = [ln.strip() for ln in user_text.splitlines() if ln.strip()] + nodes = [f"N{i}:{ln[:24]}" for i, ln in enumerate(lines)] or ["Input", "Conv", "FC", "Softmax"] + edges = [[i, i + 1] for i in range(len(nodes) - 1)] + spec = {"nodes": nodes, "edges": edges, "constraints": {"arrows": "left_to_right"}} + return {"spec": spec} + + if kind == "plan": + spec = kwargs.get("spec", {}) + spec_text = ( + "Neural Net Diagram\n" + + f"Nodes: {len(spec.get('nodes', []))}\n" + + f"Edges: {len(spec.get('edges', []))}\n" + + f"Constraints: {spec.get('constraints', {})}\n" + ) + return {"spec_text": spec_text} + + if kind == "prompt_generate": + K = int(kwargs.get("K", 3)) + spec_text = kwargs.get("spec_text", "") + layouts = ["left-right", "top-down", "circular", "grid", "hierarchical"] + colors = ["blue", "green", "purple", "orange", "teal"] + prompts = [ + f"Draw NN diagram ({spec_text[:40]}...) layout={layouts[i % len(layouts)]} color={colors[i % len(colors)]} seed={i}" + for i in range(K) + ] + return {"prompts": prompts} + + if kind == "image_generate": + prompts: List[str] = kwargs.get("prompts", []) + outdir: str = kwargs.get("outdir", "artifacts") + paths: List[str] = [] + for i, p in enumerate(prompts): + pth = Path(outdir) / f"candidate_{i}.png" + _write_placeholder_diagram(pth, with_labels=False) + paths.append(str(pth)) + return {"paths": paths} + + if kind == "judge": + image_path: str = kwargs.get("image_path") + # produce a stable pseudo-score based on filename + base = sum(ord(c) for c in Path(image_path).name) % 100 + score = 0.5 + (base / 200.0) + # fake violations: if filename has odd index + violations: List[str] = [] + try: + idx = int(Path(image_path).stem.split("_")[-1]) + if idx % 2 == 1: + violations = ["typo: layer name", "arrow: wrong direction"] + except Exception: + pass + # If still skeleton (no 'labeled_' in name), mark missing labels as HARD + name = Path(image_path).name.lower() + # Heuristic for offline mode: consider labeled or edited images as having labels + if ("labeled_" not in name) and ("edited_" not in name): + violations = ["HARD: labels: missing"] + violations + return {"score": score, "violations": violations} + + if kind == "image_edit": + image_path: str = kwargs.get("image_path") + out_path: str = kwargs.get("out_path") + instructions: str = kwargs.get("instructions", "") + # Extract labels from instructions if present + import re + labels = re.findall(r'\d+\s*:\s*"([^"]+)"', instructions) + if not labels: + # fallback: quoted strings + labels = re.findall(r'"([^"]+)"', instructions) + # standardize + labels = [l.strip() for l in labels if l.strip()] + _write_placeholder_diagram(Path(out_path), with_labels=True, labels=labels) + return {"path": out_path} + + raise ValueError(f"Unsupported kind={kind}") + + +def _write_1x1_png(path: Path) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + # 1x1 black pixel PNG + png_bytes = base64.b64decode( + b"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAA" \ + b"AAC0lEQVR42mP8/xcAAwMB/ax4u6kAAAAASUVORK5CYII=" + ) + with open(path, "wb") as f: + f.write(png_bytes) + + +def _write_placeholder_diagram(path: Path, *, with_labels: bool, labels: Optional[List[str]] = None) -> None: + """Generate a simple skeleton diagram (and optionally labels). + + If Pillow is available, draw with anti-aliased vectors and real text; + otherwise fall back to a pure-stdlib bitmap renderer. + """ + try: + from PIL import Image, ImageDraw, ImageFont # type: ignore + _write_placeholder_diagram_pil(path, with_labels=with_labels, labels=labels) + return + except Exception: + pass + + # Fallback: stdlib bitmap renderer + # White background, 3px black strokes, arrows, dashed group + import zlib, struct, binascii + + W, H = 1200, 420 + # initialize white canvas + pixels: List[List[List[int]]] = [[[255, 255, 255] for _ in range(W)] for _ in range(H)] + + def set_px(x: int, y: int, c: tuple[int, int, int]): + if 0 <= x < W and 0 <= y < H: + pixels[y][x][0] = c[0] + pixels[y][x][1] = c[1] + pixels[y][x][2] = c[2] + + def draw_line(x0: int, y0: int, x1: int, y1: int, c=(0, 0, 0), t: int = 3): + dx = abs(x1 - x0) + sx = 1 if x0 < x1 else -1 + dy = -abs(y1 - y0) + sy = 1 if y0 < y1 else -1 + err = dx + dy + while True: + for ox in range(-t // 2, t // 2 + 1): + for oy in range(-t // 2, t // 2 + 1): + set_px(x0 + ox, y0 + oy, c) + if x0 == x1 and y0 == y1: + break + e2 = 2 * err + if e2 >= dy: + err += dy + x0 += sx + if e2 <= dx: + err += dx + y0 += sy + + def draw_rect(x: int, y: int, w: int, h: int, c=(0, 0, 0), t: int = 3, dashed: bool = False): + def dash_points(x0, y0, x1, y1): + # Bresenham plus on/off dashes + dx = abs(x1 - x0) + sx = 1 if x0 < x1 else -1 + dy = -abs(y1 - y0) + sy = 1 if y0 < y1 else -1 + err = dx + dy + on = True + step = 0 + period = 10 + points = [] + while True: + if on: + points.append((x0, y0)) + step = (step + 1) % period + if step == 0: + on = not on + if x0 == x1 and y0 == y1: + break + e2 = 2 * err + if e2 >= dy: + err += dy + x0 += sx + if e2 <= dx: + err += dx + y0 += sy + return points + + if dashed: + for (x0, y0, x1, y1) in [ + (x, y, x + w, y), + (x + w, y, x + w, y + h), + (x + w, y + h, x, y + h), + (x, y + h, x, y), + ]: + for px, py in dash_points(x0, y0, x1, y1): + for ox in range(-t // 2, t // 2 + 1): + for oy in range(-t // 2, t // 2 + 1): + set_px(px + ox, py + oy, c) + else: + draw_line(x, y, x + w, y, c, t) + draw_line(x + w, y, x + w, y + h, c, t) + draw_line(x + w, y + h, x, y + h, c, t) + draw_line(x, y + h, x, y, c, t) + + def draw_arrow(x0: int, y0: int, x1: int, y1: int, c=(0, 0, 0)): + draw_line(x0, y0, x1, y1, c, 3) + # simple arrow head + vx, vy = x1 - x0, y1 - y0 + length = max((vx * vx + vy * vy) ** 0.5, 1.0) + ux, uy = vx / length, vy / length + # perpendicular + px, py = -uy, ux + ah = 10 # head length + aw = 6 # head width + hx, hy = int(x1 - ux * ah), int(y1 - uy * ah) + lx, ly = int(hx + px * aw), int(hy + py * aw) + rx, ry = int(hx - px * aw), int(hy - py * aw) + draw_line(x1, y1, lx, ly, c, 2) + draw_line(x1, y1, rx, ry, c, 2) + + # layout + margin_x, margin_y = 60, 140 + box_w, box_h = 220, 90 + gap = 90 + y = margin_y + xs = [margin_x + i * (box_w + gap) for i in range(4)] + + # dashed group around middle two blocks + group_x = xs[1] - 20 + group_y = y - 20 + group_w = box_w * 2 + gap + 40 + group_h = box_h + 40 + draw_rect(group_x, group_y, group_w, group_h, c=(140, 140, 140), t=2, dashed=True) + + # blocks + for idx, x in enumerate(xs): + draw_rect(x, y, box_w, box_h, c=(0, 0, 0), t=2) + if with_labels: + # draw simple 5x7 bitmap text using ASCII-only; non-ASCII removed + label = None + if labels and idx < len(labels): + label = labels[idx] + _draw_label_text(pixels, x, y, box_w, box_h, label) + + # arrows between blocks (center-right to center-left) + cy = y + box_h // 2 + for i in range(3): + x0 = xs[i] + box_w + x1 = xs[i + 1] + draw_arrow(x0 + 4, cy, x1 - 4, cy, c=(0, 0, 0)) + + # write PNG + def png_chunk(tag: bytes, data: bytes) -> bytes: + return struct.pack(">I", len(data)) + tag + data + struct.pack(">I", binascii.crc32(tag + data) & 0xFFFFFFFF) + + raw = bytearray() + for row in pixels: + raw.append(0) # filter type 0 + for r, g, b in row: + raw.extend((r & 255, g & 255, b & 255)) + comp = zlib.compress(bytes(raw), level=9) + sig = b"\x89PNG\r\n\x1a\n" + ihdr = struct.pack(">IIBBBBB", W, H, 8, 2, 0, 0, 0) # 8-bit, truecolor RGB + png = sig + png_chunk(b"IHDR", ihdr) + png_chunk(b"IDAT", comp) + png_chunk(b"IEND", b"") + path.parent.mkdir(parents=True, exist_ok=True) + with open(path, "wb") as f: + f.write(png) + + # end _write_placeholder_diagram + + +def _write_placeholder_diagram_pil(path: Path, *, with_labels: bool, labels: Optional[List[str]] = None) -> None: + from PIL import Image, ImageDraw, ImageFont # type: ignore + + W, H = 1280, 480 + img = Image.new("RGB", (W, H), (255, 255, 255)) + draw = ImageDraw.Draw(img) + + margin_x, margin_y = 80, 160 + box_w, box_h = 240, 110 + gap = 110 + y = margin_y + xs = [margin_x + i * (box_w + gap) for i in range(4)] + + # dashed group + group_x = xs[1] - 24 + group_y = y - 24 + group_w = box_w * 2 + gap + 48 + group_h = box_h + 48 + draw.rounded_rectangle([group_x, group_y, group_x + group_w, group_y + group_h], radius=14, outline=(150, 150, 150), width=2) + # manual dash overlay + # top and bottom dashed + def dashed_line(p0, p1, dash=12, gaplen=8, width=2, fill=(150, 150, 150)): + from math import hypot + (x0, y0), (x1, y1) = p0, p1 + dx, dy = x1 - x0, y1 - y0 + length = (dx * dx + dy * dy) ** 0.5 + if length == 0: + return + ux, uy = dx / length, dy / length + dist = 0.0 + on = True + while dist < length: + l = dash if on else gaplen + nx0 = x0 + ux * dist + ny0 = y0 + uy * dist + nx1 = x0 + ux * min(length, dist + l) + ny1 = y0 + uy * min(length, dist + l) + if on: + draw.line([(nx0, ny0), (nx1, ny1)], fill=fill, width=width) + dist += l + on = not on + + dashed_line((group_x, group_y), (group_x + group_w, group_y), width=2) + dashed_line((group_x, group_y + group_h), (group_x + group_w, group_y + group_h), width=2) + dashed_line((group_x, group_y), (group_x, group_y + group_h), width=2) + dashed_line((group_x + group_w, group_y), (group_x + group_w, group_y + group_h), width=2) + + # blocks + for x in xs: + draw.rounded_rectangle([x, y, x + box_w, y + box_h], radius=12, outline=(0, 0, 0), width=3) + + # arrows + cy = y + box_h // 2 + for i in range(3): + x0 = xs[i] + box_w + 6 + x1 = xs[i + 1] - 6 + draw.line([(x0, cy), (x1, cy)], fill=(0, 0, 0), width=3) + # head + ah, aw = 14, 8 + draw.line([(x1, cy), (x1 - ah, cy - aw)], fill=(0, 0, 0), width=3) + draw.line([(x1, cy), (x1 - ah, cy + aw)], fill=(0, 0, 0), width=3) + + # labels + if with_labels: + # pick font + try: + font = ImageFont.truetype("DejaVuSans.ttf", 22) + except Exception: + font = ImageFont.load_default() + fallback = ["PATCH EMBED", "+ CLS + POSENC", "ENCODER xL", "CLASS HEAD"] + for i, x in enumerate(xs): + text = None + if labels and i < len(labels): + text = labels[i] + if not text or not isinstance(text, str) or not text.strip(): + text = fallback[i % len(fallback)] + # center text + tw, th = draw.textlength(text, font=font), font.size + 6 + tx = x + (box_w - tw) / 2 + ty = y + (box_h - th) / 2 + draw.text((tx, ty), text, fill=(40, 40, 40), font=font, align="center") + + path.parent.mkdir(parents=True, exist_ok=True) + img.save(path) + + +def _draw_label_text(pixels: List[List[List[int]]], x: int, y: int, w: int, h: int, label: Optional[str]) -> None: + # Render up to two lines of ASCII uppercase text inside a box using a 5x7 bitmap font + import re + inner_x = x + 10 + inner_y = y + 10 + inner_w = w - 20 + inner_h = h - 20 + if inner_w <= 0 or inner_h <= 0: + return + if not label: + # fallback: generic placeholders + label = "BLOCK" + # Normalize to ASCII upper + text = label.upper() + # allow only A-Z, 0-9, space and '-' + text = re.sub(r"[^A-Z0-9 \-]", " ", text) + if not text.strip(): + text = "BLOCK" + # simple wrap by width + scale = 3 # enlarge 5x7 glyphs for readability + char_w = 6 * scale # 5px glyph +1px spacing + max_chars = max(1, inner_w // char_w) + words = text.split() + lines: List[str] = [] + line = "" + for wtok in words: + token = wtok + if line: + candidate = line + " " + token + else: + candidate = token + if len(candidate) <= max_chars: + line = candidate + else: + if line: + lines.append(line) + line = token + else: + # force cut + lines.append(token[:max_chars]) + line = token[max_chars:] + if line: + lines.append(line) + # limit to 2 lines for clarity + lines = lines[:2] + # vertical centering + total_h = len(lines) * ((7 * scale) + scale) - scale + start_y = inner_y + (inner_h - total_h) // 2 + + for i, ln in enumerate(lines): + # center each line horizontally + line_w = len(ln) * (6 * scale) + start_x = inner_x + max(0, (inner_w - line_w) // 2) + draw_text_5x7(pixels, start_x, start_y + i * ((7 * scale) + scale), ln, color=(40, 40, 40), scale=scale) + + +_FONT_5x7: Dict[str, List[str]] = { + 'A': ["01110","10001","10001","11111","10001","10001","10001"], + 'B': ["11110","10001","11110","10001","10001","10001","11110"], + 'C': ["01111","10000","10000","10000","10000","10000","01111"], + 'D': ["11110","10001","10001","10001","10001","10001","11110"], + 'E': ["11111","10000","11110","10000","10000","10000","11111"], + 'F': ["11111","10000","11110","10000","10000","10000","10000"], + 'G': ["01110","10000","10000","10111","10001","10001","01110"], + 'H': ["10001","10001","11111","10001","10001","10001","10001"], + 'I': ["11111","00100","00100","00100","00100","00100","11111"], + 'J': ["00111","00010","00010","00010","10010","10010","01100"], + 'K': ["10001","10010","10100","11000","10100","10010","10001"], + 'L': ["10000","10000","10000","10000","10000","10000","11111"], + 'M': ["10001","11011","10101","10101","10001","10001","10001"], + 'N': ["10001","11001","10101","10011","10001","10001","10001"], + 'O': ["01110","10001","10001","10001","10001","10001","01110"], + 'P': ["11110","10001","10001","11110","10000","10000","10000"], + 'Q': ["01110","10001","10001","10001","10101","10010","01101"], + 'R': ["11110","10001","10001","11110","10100","10010","10001"], + 'S': ["01111","10000","10000","01110","00001","00001","11110"], + 'T': ["11111","00100","00100","00100","00100","00100","00100"], + 'U': ["10001","10001","10001","10001","10001","10001","01110"], + 'V': ["10001","10001","10001","10001","01010","01010","00100"], + 'W': ["10001","10001","10001","10101","10101","11011","10001"], + 'X': ["10001","01010","00100","00100","01010","10001","10001"], + 'Y': ["10001","01010","00100","00100","00100","00100","00100"], + 'Z': ["11111","00001","00010","00100","01000","10000","11111"], + '0': ["01110","10001","10011","10101","11001","10001","01110"], + '1': ["00100","01100","00100","00100","00100","00100","01110"], + '2': ["01110","10001","00001","00010","00100","01000","11111"], + '3': ["11110","00001","00001","00110","00001","00001","11110"], + '4': ["00010","00110","01010","10010","11111","00010","00010"], + '5': ["11111","10000","11110","00001","00001","10001","01110"], + '6': ["00110","01000","10000","11110","10001","10001","01110"], + '7': ["11111","00001","00010","00100","01000","01000","01000"], + '8': ["01110","10001","10001","01110","10001","10001","01110"], + '9': ["01110","10001","10001","01111","00001","00010","01100"], + '-': ["00000","00000","00000","11111","00000","00000","00000"], + ' ': ["00000","00000","00000","00000","00000","00000","00000"], +} + + +def draw_text_5x7(pixels: List[List[List[int]]], x: int, y: int, text: str, color=(60, 60, 60), scale: int = 1) -> None: + max_y = len(pixels) - 1 + max_x = len(pixels[0]) - 1 if pixels else -1 + + def set_px(px: int, py: int): + if 0 <= px <= max_x and 0 <= py <= max_y: + pixels[py][px][0] = color[0] + pixels[py][px][1] = color[1] + pixels[py][px][2] = color[2] + + cx = x + for ch in text: + glyph = _FONT_5x7.get(ch, _FONT_5x7[' ']) + for gy, row in enumerate(glyph): + for gx, bit in enumerate(row): + if bit == '1': + # draw scaled pixel + for sy in range(scale): + for sx in range(scale): + set_px(cx + gx * scale + sx, y + gy * scale + sy) + cx += 6 * scale # 5px width + spacing + + +# ------------------------- Real Google GenAI calls ------------------------- + +def _real_gemini(kind: str, *, api_key: str, **kwargs) -> Dict[str, Any]: + import google.generativeai as genai + + genai.configure(api_key=api_key) + + # Model names are configurable via env with safe defaults. + # You can set GEMINI_MODEL to your provisioned model, e.g. "gemini-2.0-flash-exp" or "gemini-1.5-flash". + text_model_name = os.getenv("GEMINI_MODEL", "gemini-1.5-flash") + image_model_name = os.getenv("GEMINI_IMAGE_MODEL", "") # e.g. "imagen-3.0-generate" + image_edit_model_name = os.getenv("GEMINI_IMAGE_EDIT_MODEL", "") # e.g. "imagen-3.0-edit" + + if kind == "parse": + from .. import prompts as _p + prompt = _p.build_parse_prompt() + user_text = kwargs.get("user_text", "") + model = genai.GenerativeModel(text_model_name) + resp = model.generate_content([prompt, user_text]) + content = _first_text(resp) + data = _robust_json(content) + if not isinstance(data, dict): + raise ValueError("parse: model did not return JSON dict") + return {"spec": data} + + if kind == "plan": + spec = kwargs.get("spec", {}) + from .. import prompts as _p + prompt = _p.build_plan_prompt() + model = genai.GenerativeModel(text_model_name) + resp = model.generate_content([prompt, json.dumps(spec, ensure_ascii=False)]) + spec_text = _first_text(resp) + return {"spec_text": spec_text.strip()} + + if kind == "prompt_generate": + K = int(kwargs.get("K", 3)) + spec_text = kwargs.get("spec_text", "") + from .. import prompts as _p + prompt = _p.build_promptgen_prompt(K, spec_text) + model = genai.GenerativeModel(text_model_name) + resp = model.generate_content(prompt) + content = _first_text(resp) + arr = _robust_json(content) + if not isinstance(arr, list): + # fallback: split lines + arr = [ln.strip("- ") for ln in content.splitlines() if ln.strip()][:K] + return {"prompts": arr[:K]} + + if kind == "image_generate": + prompts: List[str] = kwargs.get("prompts", []) + outdir: str = kwargs.get("outdir", "artifacts") + if not image_model_name: + raise ValueError("GEMINI_IMAGE_MODEL is not set. Please set it to a valid image model (e.g., 'gemini-2.5-flash-image' or 'gemini-2.5-flash-image-preview').") + try: + from concurrent.futures import ThreadPoolExecutor, as_completed + + Path(outdir).mkdir(parents=True, exist_ok=True) + max_workers = max(1, min(len(prompts), int(_os.getenv("NNG_CONCURRENCY", "4")))) + + def _gen_one(i: int, p: str) -> str: + # new model per thread to avoid cross-thread state issues + mdl = genai.GenerativeModel(model_name=image_model_name) + resp = mdl.generate_content(p, request_options={"timeout": 180}) + try: + (Path(outdir) / f"candidate_{i}.resp.txt").write_text(str(resp)) + except Exception: + pass + img_bytes, mime = _first_image_bytes(resp) + if not img_bytes: + raise ValueError("image model did not return image bytes; see *.resp.txt") + ext = ".png" if mime == "image/png" else ".jpg" + pth = Path(outdir) / f"candidate_{i}{ext}" + with open(pth, "wb") as f: + f.write(img_bytes) + with open(str(pth) + ".meta.json", "w", encoding="utf-8") as mf: + mf.write(json.dumps({"source": "gemini", "mime": mime, "bytes": len(img_bytes)}, ensure_ascii=False)) + return str(pth) + + futures = [] + with ThreadPoolExecutor(max_workers=max_workers) as ex: + for i, p in enumerate(prompts): + futures.append(ex.submit(_gen_one, i, p)) + # preserve order by index + results = [None] * len(prompts) + for fut in as_completed(futures): + # find index by result path name + path = fut.result() + stem = Path(path).stem + try: + idx = int(stem.split("_")[-1]) + except Exception: + idx = 0 + results[idx] = path + # fill any missing in order fallback + paths: List[str] = [r or "" for r in results] + return {"paths": paths} + except Exception: + raise + + if kind == "judge": + image_path: str = kwargs.get("image_path") + spec = kwargs.get("spec", {}) + model = genai.GenerativeModel(text_model_name) + from .. import prompts as _p + judge_prompt = _p.build_judge_prompt() + image_part = _image_part_from_path(image_path) + resp = model.generate_content([ + {"text": judge_prompt}, + {"text": json.dumps(spec, ensure_ascii=False)}, + image_part, + ]) + content = _first_text(resp) + data = _robust_json(content) + if not isinstance(data, dict): + raise ValueError("judge: non-JSON") + score = float(max(0.0, min(1.0, data.get("score", 0.0)))) + violations = list(data.get("violations", [])) + return {"score": score, "violations": violations} + + if kind == "image_edit": + image_path: str = kwargs.get("image_path") + out_path: str = kwargs.get("out_path") + instructions: str = kwargs.get("instructions", "") + ref_images: List[str] = list(kwargs.get("ref_images", []) or []) + if not image_edit_model_name: + raise ValueError("GEMINI_IMAGE_EDIT_MODEL is not set. Please set it to a valid image edit model (e.g., 'gemini-2.5-flash-image' or 'gemini-2.5-flash-image-preview').") + try: + model = genai.GenerativeModel(model_name=image_edit_model_name) + base_img = _image_part_from_path(image_path) + from .. import prompts as _p + parts = [{"text": _p.build_image_edit_prompt(instructions)}, base_img] + for rp in ref_images: + try: + parts.append(_image_part_from_path(rp)) + except Exception: + continue + resp = model.generate_content(parts, request_options={"timeout": 120}) + try: + out_p = Path(out_path) + out_p.parent.mkdir(parents=True, exist_ok=True) + (out_p.parent / (out_p.stem + ".resp.txt")).write_text(str(resp)) + except Exception: + pass + img_bytes, mime = _first_image_bytes(resp) + if not img_bytes: + raise ValueError("image edit returned no image; see *.resp.txt for raw response") + ext = ".png" if mime == "image/png" else ".jpg" + out_p = Path(out_path) + out_p.parent.mkdir(parents=True, exist_ok=True) + with open(out_p, "wb") as f: + f.write(img_bytes) + with open(str(out_p) + ".meta.json", "w", encoding="utf-8") as mf: + mf.write(json.dumps({"source": "gemini", "mime": mime, "bytes": len(img_bytes)}, ensure_ascii=False)) + return {"path": str(out_p)} + except Exception as e: + # surface error rather than fallback, per user's requirement to avoid local rendering + raise + + if kind == "image_fuse": + # Create a new image by composing multiple reference images under textual instructions + out_path: str = kwargs.get("out_path") + instructions: str = kwargs.get("instructions", "") + ref_images: List[str] = list(kwargs.get("ref_images", []) or []) + if not image_model_name: + raise ValueError("GEMINI_IMAGE_MODEL is not set. Please set it to a valid image model (e.g., 'gemini-2.5-flash-image' or 'gemini-2.5-flash-image-preview').") + try: + model = genai.GenerativeModel(model_name=image_model_name) + from .. import prompts as _p + parts = [{"text": _p.build_image_fusion_prompt(instructions)}] + for rp in ref_images: + try: + parts.append(_image_part_from_path(rp)) + except Exception: + continue + resp = model.generate_content(parts, request_options={"timeout": 120}) + try: + out_p = Path(out_path) + out_p.parent.mkdir(parents=True, exist_ok=True) + (out_p.parent / (out_p.stem + ".resp.txt")).write_text(str(resp)) + except Exception: + pass + img_bytes, mime = _first_image_bytes(resp) + if not img_bytes: + raise ValueError("image fuse returned no image; see *.resp.txt for raw response") + out_p = Path(out_path) + out_p.parent.mkdir(parents=True, exist_ok=True) + with open(out_p, "wb") as f: + f.write(img_bytes) + with open(str(out_p) + ".meta.json", "w", encoding="utf-8") as mf: + mf.write(json.dumps({"source": "gemini", "mime": mime, "bytes": len(img_bytes)}, ensure_ascii=False)) + return {"path": str(out_p)} + except Exception: + raise + + raise ValueError(f"Unsupported kind={kind}") + + +def _first_text(resp: Any) -> str: + try: + if hasattr(resp, "text"): + return resp.text + # Some SDK versions: candidates[0].content.parts[0].text + cands = getattr(resp, "candidates", []) + if cands: + parts = getattr(cands[0], "content", None) + if parts and getattr(parts, "parts", None): + for part in parts.parts: + if getattr(part, "text", None): + return part.text + return str(resp) + except Exception: + return str(resp) + + +def _first_image_bytes(resp: Any) -> tuple[bytes | None, str]: + # Try to walk through content parts and return first inline image bytes + try: + # Newer SDK: resp.candidates[].content.parts[].inline_data + cands = getattr(resp, "candidates", []) + for c in cands or []: + content = getattr(c, "content", None) + parts = getattr(content, "parts", None) if content else None + for part in parts or []: + inline = getattr(part, "inline_data", None) + if inline and getattr(inline, "data", None): + data = inline.data + mime = getattr(inline, "mime_type", "image/png") + if isinstance(data, bytes): + return data, mime + # some versions may base64-encode + try: + return base64.b64decode(data), mime + except Exception: + pass + return None, "" + except Exception: + return None, "" + + +def _image_part_from_path(path: str) -> Dict[str, Any]: + # google-generativeai accepts dict with mime_type and data bytes for images + p = Path(path) + mime = "image/png" if p.suffix.lower() == ".png" else "image/jpeg" + data = p.read_bytes() + return {"mime_type": mime, "data": data} + + +def _robust_json(text: str) -> Any: + # Try parse whole, then attempt to extract first {...} or [...] block + try: + return json.loads(text) + except Exception: + pass + # crude extraction + start = text.find("{") + end = text.rfind("}") + if start != -1 and end != -1 and end > start: + try: + return json.loads(text[start : end + 1]) + except Exception: + pass + start = text.find("[") + end = text.rfind("]") + if start != -1 and end != -1 and end > start: + try: + return json.loads(text[start : end + 1]) + except Exception: + pass + return {} diff --git a/NNGen/app/nodes/__init__.py b/NNGen/app/nodes/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d2754673a91835cea4a473934030f0ea8801cc5d --- /dev/null +++ b/NNGen/app/nodes/__init__.py @@ -0,0 +1 @@ +from . import parser, planner, prompt_gen, gen_generate, gen_labels, judge, select, edit, archive diff --git a/NNGen/app/nodes/archive.py b/NNGen/app/nodes/archive.py new file mode 100644 index 0000000000000000000000000000000000000000..303bf7945c708259c9314bd44206b367e418b5dd --- /dev/null +++ b/NNGen/app/nodes/archive.py @@ -0,0 +1,35 @@ +from __future__ import annotations + +import json +from pathlib import Path + +from ..state import AppState + + +def run(state: AppState) -> AppState: + outdir = Path(state["outdir"]) # ensured by CLI + outdir.mkdir(parents=True, exist_ok=True) + + # dump spec + if state.get("spec"): + (outdir / "spec.json").write_text(json.dumps(state["spec"], ensure_ascii=False, indent=2)) + if state.get("spec_text"): + (outdir / "spec.txt").write_text(state["spec_text"]) + + # dump prompts + if state.get("prompts"): + (outdir / "prompts.json").write_text(json.dumps(state["prompts"], ensure_ascii=False, indent=2)) + + # dump scores + if state.get("scores"): + (outdir / "scores.json").write_text(json.dumps(state["scores"], ensure_ascii=False, indent=2)) + + # copy/rename final image + if state.get("best_image"): + src = Path(state["best_image"].path) + dst = outdir / "final.png" + if src.exists(): + dst.write_bytes(src.read_bytes()) + + return state + diff --git a/NNGen/app/nodes/edit.py b/NNGen/app/nodes/edit.py new file mode 100644 index 0000000000000000000000000000000000000000..e829fce6b5b9a0be7d03ca653c7739ddc64061d9 --- /dev/null +++ b/NNGen/app/nodes/edit.py @@ -0,0 +1,80 @@ +from __future__ import annotations + +from pathlib import Path +from typing import Dict + +from ..llm.gemini import call_gemini +from ..state import AppState + + +def _labels_from_spec(state: AppState) -> list[str]: + spec = state.get("spec", {}) or {} + raw_nodes = spec.get("nodes", []) or [] + labels: list[str] = [] + for n in raw_nodes: + label = None + if isinstance(n, str): + # strip index prefixes like "N0: ..." + parts = n.split(":", 1) + label = parts[1].strip() if len(parts) == 2 else n.strip() + elif isinstance(n, dict): + label = n.get("label") or n.get("name") or n.get("id") + if label: + labels.append(str(label)) + # dedupe sequential exact repeats only when later mapping by order still makes sense + return labels + + +def _ascii_friendly_labels(state: AppState) -> list[str]: + labels = _labels_from_spec(state) + def is_ascii(s: str) -> bool: + try: + s.encode('ascii') + return True + except Exception: + return False + if not labels or sum(1 for l in labels if is_ascii(l)) == 0: + return [ + "PATCH EMBEDDING", + "CLS + POSENC", + "ENCODER xL", + "CLASS HEAD", + ] + return labels + + +def plan_edits(state: AppState) -> str: + hard_violations = [str(v) for v in state.get("hard_violations", [])] + violations = [str(v) for v in state.get("violations", [])] + # If judge reports missing labels (prefer HARD), provide an add-labels instruction + hv = hard_violations or violations + if any(("labels" in v.lower() and "missing" in v.lower()) for v in hv): + labels = _labels_from_spec(state) + numbered = "\n".join([f"{i+1}: \"{lbl}\"" for i, lbl in enumerate(labels)]) or "(no labels provided)" + return ( + "Add text labels INSIDE each rectangular block without changing geometry, arrows, spacing, sizes, or colors. " + "Map labels in left→right, top→bottom order; reuse identical labels for repeated blocks. " + "Use a clean sans-serif font in solid black or dark gray, consistent size.\n" + f"Labels list:\n{numbered}" + ) + + # Default: targeted fixes based on judge violations, but always provide labels list to preserve text in offline mode + fixes = "; ".join(violations) if violations else "typos, arrow direction, spacing/legibility, and style compliance" + labels = _ascii_friendly_labels(state) + numbered = "\n".join([f"{i+1}: \"{lbl}\"" for i, lbl in enumerate(labels)]) or "(no labels provided)" + return ( + f"Fix the following issues precisely: {fixes}. " + "Do not move or reshape elements. Only adjust text (content/position/size), arrow direction styles, and minimal styling to reach paper standards.\n" + f"Labels list:\n{numbered}" + ) + + +def apply_edits(state: AppState) -> AppState: + if not state.get("best_image"): + return state + src = state["best_image"].path + out_path = str(Path(state["outdir"]) / f"edited_round_{state.get('round', 0)}.png") + _ = call_gemini("image_edit", image_path=src, out_path=out_path, instructions=plan_edits(state)) + # replace best_image with edited one + state["best_image"].path = out_path # type: ignore + return state diff --git a/NNGen/app/nodes/gen_fusion.py b/NNGen/app/nodes/gen_fusion.py new file mode 100644 index 0000000000000000000000000000000000000000..84d0930e03e309d6eab9463844c54b4ab65781d1 --- /dev/null +++ b/NNGen/app/nodes/gen_fusion.py @@ -0,0 +1,73 @@ +from __future__ import annotations + +import os +from concurrent.futures import ThreadPoolExecutor, as_completed +from pathlib import Path +from typing import Dict, List + +from ..llm.gemini import call_gemini +from ..state import AppState, ImageArtifact + + +def run(state: AppState) -> AppState: + """Generate K fused candidates by composing reference images under instructions. + + Expected in state: + - outdir: str + - K: int + - base_image: optional path (treated as first ref image if present) + - ref_images: optional list[str] + - instructions: str + """ + outdir = Path(state["outdir"]) # ensured by graph + K = int(state.get("K", 3)) + instructions: str = str(state.get("instructions", "")).strip() + + # prepare reference list + refs: List[str] = [] + if state.get("base_image"): + refs.append(str(state["base_image"])) + for r in state.get("ref_images", []) or []: + if r and str(r) not in refs: + refs.append(str(r)) + + if not refs: + raise ValueError("Fusion mode requires at least one reference image (base or ref_images)") + + max_workers = max(1, min(K, int(os.getenv("NNG_CONCURRENCY", "4")))) + + def _fuse_one(i: int) -> str: + out_path = str(outdir / f"fused_candidate_{i}.png") + # Use image_edit if base image is provided; otherwise image_fuse + if state.get("base_image"): + call_gemini( + "image_edit", + image_path=str(state["base_image"]), + out_path=out_path, + instructions=f"Variant {i}: {instructions}", + ref_images=[p for p in refs if p != str(state["base_image"])], + ) + else: + call_gemini( + "image_fuse", + out_path=out_path, + instructions=f"Variant {i}: {instructions}", + ref_images=refs, + ) + return out_path + + paths: List[str] = [""] * K + with ThreadPoolExecutor(max_workers=max_workers) as ex: + futures = [ex.submit(_fuse_one, i) for i in range(K)] + for fut in as_completed(futures): + p = fut.result() + try: + idx = int(Path(p).stem.split("_")[-1]) + except Exception: + idx = 0 + paths[idx] = p + + images = [ImageArtifact(prompt=instructions, path=pth) for pth in paths if pth] + state["images"] = images + return state + diff --git a/NNGen/app/nodes/gen_generate.py b/NNGen/app/nodes/gen_generate.py new file mode 100644 index 0000000000000000000000000000000000000000..f8b64e9a470ab2dbece5e00af4198829fbf2fd24 --- /dev/null +++ b/NNGen/app/nodes/gen_generate.py @@ -0,0 +1,16 @@ +from __future__ import annotations + +from typing import Dict, List + +from ..llm.gemini import call_gemini +from ..state import AppState, ImageArtifact + + +def run(state: AppState) -> AppState: + prompts: List[str] = state.get("prompts", []) + res: Dict = call_gemini("image_generate", prompts=prompts, outdir=state["outdir"]) + paths = res.get("paths", []) + images = [ImageArtifact(prompt=p, path=pth) for p, pth in zip(prompts, paths)] + state["images"] = images + return state + diff --git a/NNGen/app/nodes/gen_labels.py b/NNGen/app/nodes/gen_labels.py new file mode 100644 index 0000000000000000000000000000000000000000..3dc5bf8dcec46815d7a254df6e8fa68206495056 --- /dev/null +++ b/NNGen/app/nodes/gen_labels.py @@ -0,0 +1,60 @@ +from __future__ import annotations + +from pathlib import Path +from typing import List +import os +from concurrent.futures import ThreadPoolExecutor, as_completed + +from ..llm.gemini import call_gemini +from ..state import AppState, ImageArtifact +from .edit import _labels_from_spec # reuse label extraction + + +def run(state: AppState) -> AppState: + images: List[ImageArtifact] = state.get("images", []) or [] + if not images: + return state + + labels = _labels_from_spec(state) + # Fallback to ASCII-friendly defaults if labels are missing or mostly non-ASCII + def _is_mostly_ascii(s: str) -> bool: + try: + s.encode('ascii') + return True + except Exception: + return False + if not labels or sum(1 for l in labels if _is_mostly_ascii(l)) == 0: + labels = [ + "PATCH EMBEDDING", + "CLS + POSENC", + "ENCODER xL", + "CLASS HEAD", + ] + numbered = "\n".join([f"{i+1}: \"{lbl}\"" for i, lbl in enumerate(labels)]) or "(no labels provided)" + + instructions = ( + "Add labels INSIDE each rectangular block. Do not move/resize/add/remove shapes or arrows; keep layout, spacing, and colors unchanged. " + "Map labels in left→right, top→bottom order; reuse identical labels for repeated blocks. Use each label string exactly as given (no translation or paraphrase). " + "Typography: clean sans-serif, readable size, centered within blocks; at most two short lines; avoid covering arrows; no legends or titles. " + "If block count ≠ label count, do NOT add/remove shapes; place labels sequentially on existing blocks.\n" + f"Labels list:\n{numbered}" + ) + + outdir = Path(state["outdir"]) if state.get("outdir") else Path("artifacts") + max_workers = max(1, min(len(images), int(os.getenv("NNG_CONCURRENCY", "4")))) + results: List[ImageArtifact | None] = [None] * len(images) + + def _label_one(i: int, im: ImageArtifact) -> tuple[int, str]: + src = im.path + out_path = str(outdir / f"labeled_candidate_{i}.png") + _ = call_gemini("image_edit", image_path=src, out_path=out_path, instructions=instructions) + return i, out_path + + with ThreadPoolExecutor(max_workers=max_workers) as ex: + futures = [ex.submit(_label_one, i, im) for i, im in enumerate(images)] + for fut in as_completed(futures): + i, out_path = fut.result() + results[i] = ImageArtifact(prompt=images[i].prompt, path=out_path, meta={"stage": "labels"}) + + state["images"] = [im for im in results if im is not None] + return state diff --git a/NNGen/app/nodes/judge.py b/NNGen/app/nodes/judge.py new file mode 100644 index 0000000000000000000000000000000000000000..0b4e0b76017c23334803d82ba26c3c1b96dba68c --- /dev/null +++ b/NNGen/app/nodes/judge.py @@ -0,0 +1,46 @@ +from __future__ import annotations + +from typing import Dict, List +import os +from concurrent.futures import ThreadPoolExecutor, as_completed + +from ..llm.gemini import call_gemini +from ..state import AppState, ScoreItem + + +def run(state: AppState) -> AppState: + images = list(state.get("images", [])) + if not images: + state["scores"] = [] + return state + + max_workers = max(1, min(len(images), int(os.getenv("NNG_CONCURRENCY", "4")))) + results: List[ScoreItem | None] = [None] * len(images) + + def _judge_one(i: int) -> tuple[int, Dict]: + im = images[i] + res: Dict = call_gemini("judge", image_path=im.path, spec=state.get("spec", {})) + return i, res + + with ThreadPoolExecutor(max_workers=max_workers) as ex: + futures = [ex.submit(_judge_one, i) for i in range(len(images))] + for fut in as_completed(futures): + try: + i, res = fut.result() + im = images[i] + results[i] = { + "image_path": im.path, + "score": float(res.get("score", 0.0)), + "violations": list(res.get("violations", [])), + } + except Exception as e: + im = images[futures.index(fut)] if fut in futures else None + path = im.path if im else "" + results[i] = { + "image_path": path, + "score": 0.0, + "violations": [f"judge error: {e}"] + } + + state["scores"] = [s for s in results if s is not None] + return state diff --git a/NNGen/app/nodes/parser.py b/NNGen/app/nodes/parser.py new file mode 100644 index 0000000000000000000000000000000000000000..7e033c3e01ad28ceeafb2f997384d440c1b5501c --- /dev/null +++ b/NNGen/app/nodes/parser.py @@ -0,0 +1,15 @@ +from __future__ import annotations + +from typing import Dict + +from ..llm.gemini import call_gemini +from ..state import AppState + + +def run(state: AppState) -> AppState: + if state.get("spec"): + return state + res: Dict = call_gemini("parse", user_text=state.get("user_text", "")) + state["spec"] = res.get("spec", {}) + return state + diff --git a/NNGen/app/nodes/planner.py b/NNGen/app/nodes/planner.py new file mode 100644 index 0000000000000000000000000000000000000000..701705e042b40217265f3951b4e322445227575d --- /dev/null +++ b/NNGen/app/nodes/planner.py @@ -0,0 +1,15 @@ +from __future__ import annotations + +from typing import Dict + +from ..llm.gemini import call_gemini +from ..state import AppState + + +def run(state: AppState) -> AppState: + if state.get("spec_text"): + return state + res: Dict = call_gemini("plan", spec=state.get("spec", {})) + state["spec_text"] = res.get("spec_text", "") + return state + diff --git a/NNGen/app/nodes/prompt_gen.py b/NNGen/app/nodes/prompt_gen.py new file mode 100644 index 0000000000000000000000000000000000000000..d2b29f529ce973751231887190700c985905a418 --- /dev/null +++ b/NNGen/app/nodes/prompt_gen.py @@ -0,0 +1,15 @@ +from __future__ import annotations + +from typing import Dict + +from ..llm.gemini import call_gemini +from ..state import AppState + + +def run(state: AppState) -> AppState: + if state.get("prompts"): + return state + res: Dict = call_gemini("prompt_generate", spec_text=state.get("spec_text", ""), K=state.get("K", 3)) + state["prompts"] = res.get("prompts", []) + return state + diff --git a/NNGen/app/nodes/select.py b/NNGen/app/nodes/select.py new file mode 100644 index 0000000000000000000000000000000000000000..2f0fbb567d3e8cdfde0944098b78912d055eb08a --- /dev/null +++ b/NNGen/app/nodes/select.py @@ -0,0 +1,30 @@ +from __future__ import annotations + +from pathlib import Path +from typing import List + +from ..state import AppState, ImageArtifact + + +def run(state: AppState) -> AppState: + scores = sorted(state.get("scores", []), key=lambda s: s["score"], reverse=True) + if not scores: + return state + best = scores[0] + best_img_path = best["image_path"] + # find the corresponding ImageArtifact + best_image: ImageArtifact | None = None + for im in state.get("images", []): + if im.path == best_img_path: + best_image = im + break + vios = [str(v) for v in best.get("violations", [])] + # Identify hard violations: explicit HARD marker or labels missing heuristic + hard = [v for v in vios if v.strip().lower().startswith("hard:")] + if not hard: + hard = [v for v in vios if ("labels" in v.lower() and "missing" in v.lower())] + + state["best_image"] = best_image + state["violations"] = vios + state["hard_violations"] = hard + return state diff --git a/NNGen/app/prompts.py b/NNGen/app/prompts.py new file mode 100644 index 0000000000000000000000000000000000000000..7fb2a4ea7b25a26eee6467d27a4d9c1fe9a9b968 --- /dev/null +++ b/NNGen/app/prompts.py @@ -0,0 +1,65 @@ +from __future__ import annotations + + +def build_parse_prompt() -> str: + return ( + "You are a strict parser for neural network architecture specs. " + "Input is natural language. Return ONLY a JSON object with fields: " + "nodes: string[], edges: [fromIndex, toIndex][], constraints: object. " + "No prose." + ) + + +def build_plan_prompt() -> str: + return ( + "Given a structured NN spec (JSON), produce a concise, fillable template text " + "that preserves nodes, edges, and key constraints for diagram rendering. " + "Emphasize left-to-right flow, explicit layer counts, and unambiguous labels." + ) + + +def build_promptgen_prompt(K: int, spec_text: str) -> str: + # Stage G1: lighter, cleaner skeleton-only prompts (no hard stylistic numbers) + return ( + "Create K concise prompts for an image model to draw ONLY the skeleton of a neural network diagram (no text).\n" + "Aim for a clean paper-figure look: flat 2D, simple shapes, balanced margins, and a calm palette. Use rectangles for modules and clear left→right arrows.\n" + "If the spec implies repetition (e.g., Encoder × L), you may show a dashed grouping around the repeated blocks. Avoid flashy effects (no 3D or heavy glow).\n" + "Return ONLY a JSON array of exactly K strings; each item is one full prompt for image generation.\n" + f"K={K}.\n" + f"Spec (summary):\n{spec_text}\n" + "Each prompt must mention: 'skeleton-only, no text'." + ) + + +def build_judge_prompt() -> str: + # Judge content & style, optimized for two-stage (skeleton→labels) flow + return ( + "You are a strict publication-figure QA judge. Given a spec (JSON) and a NN diagram image, " + "evaluate (A) Content correctness and (B) Paper-style compliance.\n" + "(A) Content (0.6): required modules present; edges/arrows reflect correct order; arrows left→right; labels exist and are spelled correctly; " + "layer count L indicated when applicable. If the image has no labels, include violation EXACTLY 'HARD: labels: missing'.\n" + "(B) Style (0.4): flat 2D; white background; minimal color (black/gray + ≤2 accents); no gradients/3D/glow/shadows/neon; " + "consistent stroke width; consistent sans-serif font; adequate spacing; dashed boxes for repeated blocks; high print readability.\n" + "Return ONLY strict JSON: {score: number in [0,1], violations: string[]}. Violations must be concrete and actionable." + ) + + +def build_image_edit_prompt(instructions: str) -> str: + # G2 and later edits: add/adjust labels only; keep geometry fixed (light constraints) + base = ( + "Add or adjust labels INSIDE each block, without changing any shapes, arrows, layout, spacing, or colors. " + "Keep a clean, readable look: flat 2D, simple sans-serif font, good contrast, and consistent size across blocks. " + "Center labels within blocks; use at most two short lines; avoid covering arrows; do not add legends or titles. " + "Use each label string exactly as provided (no translation or paraphrase). " + ) + return base + f"Instructions: {instructions}" + + +def build_image_fusion_prompt(instructions: str) -> str: + # Compose multiple images guided by text while preserving key visual constraints + return ( + "Compose a new, clean technical diagram by integrating the following reference images. " + "Preserve the overall paper-style look: flat 2D, white background, minimal color, consistent line width, and sans-serif text. " + "Follow the instructions precisely; keep geometry aligned and readable; avoid extra decorations. " + f"Instructions: {instructions}" + ) diff --git a/NNGen/app/state.py b/NNGen/app/state.py new file mode 100644 index 0000000000000000000000000000000000000000..766f9788524204bc10f9b82cedd7127e73fef2dc --- /dev/null +++ b/NNGen/app/state.py @@ -0,0 +1,33 @@ +from __future__ import annotations + +from dataclasses import dataclass, field +from typing import Any, Dict, List, Optional, TypedDict + + +class ScoreItem(TypedDict): + image_path: str + score: float + violations: List[str] + + +@dataclass +class ImageArtifact: + prompt: str + path: str + meta: Dict[str, Any] = field(default_factory=dict) + + +class AppState(TypedDict, total=False): + user_text: str + spec: Dict[str, Any] + spec_text: str + K: int + T: int + round: int + prompts: List[str] + images: List[ImageArtifact] + scores: List[ScoreItem] + best_image: Optional[ImageArtifact] + violations: List[str] + hard_violations: List[str] + outdir: str diff --git a/NNGen/demo.ipynb b/NNGen/demo.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..28b36ea9987301f7612b73c3899cdb9cfc5629c0 --- /dev/null +++ b/NNGen/demo.ipynb @@ -0,0 +1,229 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "608d1397", + "metadata": {}, + "source": [ + "# NNGen Demo — Gemini 2.5 Flash Image\n", + "\n", + "Interactive demo to generate a neural network diagram from a natural language prompt.\n", + "- Uses the multi-agent pipeline (`parser → planner → prompt-gen → G1 → G2 → judge → select → edit loop → archive`).\n", + "- All model calls go through `app.llm.gemini.call_gemini`. If `GEMINI_API_KEY` is not set, the pipeline falls back to local placeholders so the demo still runs.\n", + "- For image generation/editing, set `GEMINI_IMAGE_MODEL`/`GEMINI_IMAGE_EDIT_MODEL` (e.g., `gemini-2.5-flash-image` or `gemini-2.5-flash-image-preview`).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d0fde396", + "metadata": {}, + "outputs": [], + "source": [ + "# Imports\n", + "from app.graph import run_pipeline\n", + "from app.state import AppState\n", + "from pathlib import Path\n", + "from IPython.display import Image, display\n", + "import os, json\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "82eb3482", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GEMINI_MODEL= gemini-2.5-flash\n", + "GEMINI_IMAGE_MODEL= gemini-2.5-flash-image-preview\n", + "GEMINI_IMAGE_EDIT_MODEL= gemini-2.5-flash-image-preview\n" + ] + } + ], + "source": [ + "# Optional: configure models here if not set in environment (.env is supported).\n", + "# os.environ.setdefault(\"GEMINI_MODEL\", \"gemini-2.5-flash\")\n", + "# os.environ.setdefault(\"GEMINI_IMAGE_MODEL\", \"gemini-2.5-flash-image\")\n", + "# os.environ.setdefault(\"GEMINI_IMAGE_EDIT_MODEL\", \"gemini-2.5-flash-image\")\n", + "print(\"GEMINI_MODEL=\", os.getenv(\"GEMINI_MODEL\", \"(default)\"))\n", + "print(\"GEMINI_IMAGE_MODEL=\", os.getenv(\"GEMINI_IMAGE_MODEL\", \"(default)\"))\n", + "print(\"GEMINI_IMAGE_EDIT_MODEL=\", os.getenv(\"GEMINI_IMAGE_EDIT_MODEL\", \"(default)\"))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c33a905d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Enter your NN spec prompt (blank for sample):\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + " Generate a high-level diagram of a Vision Transformer (ViT): - Input: 224×224 RGB image - Patch Embedding: split into 16×16 patches and apply a linear projection - Add CLS token and positional encoding - Transformer Encoder stack: Multi-Head Self-Attention + MLP + residual + LayerNorm (repeat L layers) - Classification head: take CLS token for linear classification Layout requirements: left-to-right flow; clear arrow directions; correct spelling of all labels; show the number of layers L; keep colors readable.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Configured: K=4, T=1\n" + ] + } + ], + "source": [ + "# Enter a natural language NN spec (leave blank to use the sample in spec/vit.txt).\n", + "print(\"Enter your NN spec prompt (blank for sample):\")\n", + "user_text = input().strip()\n", + "if not user_text:\n", + " user_text = Path('spec/vit.txt').read_text()\n", + "\n", + "# Number of candidates (K) and max edit rounds (T)\n", + "K = 4\n", + "T = 1\n", + "print(f\"Configured: K={K}, T={T}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d94411eb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Artifacts directory: artifacts\\run_20250907_070203\n" + ] + } + ], + "source": [ + "# Run the multi-agent pipeline\n", + "state: AppState = {\n", + " 'K': K,\n", + " 'T': T,\n", + " 'user_text': user_text,\n", + " 'outdir': '' # use timestamped default\n", + "}\n", + "final_state = run_pipeline(state)\n", + "print('Artifacts directory:', final_state['outdir'])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "691e6714", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Display the final image\n", + "final_path = Path(final_state['outdir']) / 'final.png'\n", + "if final_path.exists():\n", + " display(Image(filename=str(final_path)))\n", + "else:\n", + " print('final.png not found at', final_path)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "48c31cab", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- spec.txt ---\n", + "```\n", + "[Input: 224x224 RGB Image]\n", + " -> [Patch Embedding (16x16 patches, Linear Projection)]\n", + " -> [Add CLS Token & Positional Encoding]\n", + " -> [Transformer Encoder (L Layers: MHA + MLP + Residual + LayerNorm)]\n", + " -> [Classification Head (Linear, uses CLS token)]\n", + "\n", + "**Fillable Details:**\n", + "* **L**: \n", + "```\n", + "--- scores.json ---\n", + "[\n", + " {\n", + " \"image_path\": \"artifacts\\\\run_20250907_070203\\\\edited_round_1.png\",\n", + " \"score\": 0.5,\n", + " \"violations\": [\n", + " \"Content correctness: The internal structure of the 'Transformer Encoder' block (within the dashed box) is conceptually incorrect for a standard Transformer architecture. The arrangement of MHA, MLP, Residual connections, and LayerNorm components does not accurately reflect the typical data flow and configuration.\",\n", + " \"Labels: Spelling error 'LayerNemj' should be 'LayerNorm'.\",\n", + " \"Labels: Spelling error 'MtIA' should be 'MHA'.\",\n", + " \"Minimal color: Used 5 distinct accent colors (light blue, yellow, orange, light green, purple) when the specification requires a maximum of 2 accent colors.\"\n", + " ]\n", + " }\n", + "]\n" + ] + } + ], + "source": [ + "# (Optional) Inspect outputs: spec and scoring\n", + "spec_txt = Path(final_state['outdir']) / 'spec.txt'\n", + "scores_json = Path(final_state['outdir']) / 'scores.json'\n", + "if spec_txt.exists():\n", + " print('--- spec.txt ---')\n", + " print(spec_txt.read_text())\n", + "if scores_json.exists():\n", + " print('--- scores.json ---')\n", + " print(scores_json.read_text())\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1d9bd457-bbcb-4803-ac78-1879933fe773", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/NNGen/notebooks/demo.ipynb b/NNGen/notebooks/demo.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..c227d4327aa0997bbda202d37795ffb16875d0c7 --- /dev/null +++ b/NNGen/notebooks/demo.ipynb @@ -0,0 +1,151 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0ce88361", + "metadata": {}, + "source": [ + "# NNGen Demo — Gemini 2.5 Flash Image\n", + "\n", + "Interactive demo to generate a neural network diagram from a natural language prompt.\n", + "- Uses the multi-agent pipeline (`parser → planner → prompt-gen → G1 → G2 → judge → select → edit loop → archive`).\n", + "- All model calls go through `app.llm.gemini.call_gemini`. If `GEMINI_API_KEY` is not set, the pipeline falls back to local placeholders so the demo still runs.\n", + "- For image generation/editing, set `GEMINI_IMAGE_MODEL`/`GEMINI_IMAGE_EDIT_MODEL` (e.g., `gemini-2.5-flash-image` or `gemini-2.5-flash-image-preview`).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a0f6490c", + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'app'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# Imports\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mapp\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mgraph\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m run_pipeline\n\u001b[32m 3\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mapp\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mstate\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m AppState\n\u001b[32m 4\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpathlib\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Path\n", + "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'app'" + ] + } + ], + "source": [ + "# Imports\n", + "from app.graph import run_pipeline\n", + "from app.state import AppState\n", + "from pathlib import Path\n", + "from IPython.display import Image, display\n", + "import os, json\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "722a09d3", + "metadata": {}, + "outputs": [], + "source": [ + "# Optional: configure models here if not set in environment (.env is supported).\n", + "# os.environ.setdefault(\"GEMINI_MODEL\", \"gemini-2.5-flash\")\n", + "# os.environ.setdefault(\"GEMINI_IMAGE_MODEL\", \"gemini-2.5-flash-image\")\n", + "# os.environ.setdefault(\"GEMINI_IMAGE_EDIT_MODEL\", \"gemini-2.5-flash-image\")\n", + "print(\"GEMINI_MODEL=\", os.getenv(\"GEMINI_MODEL\", \"(default)\"))\n", + "print(\"GEMINI_IMAGE_MODEL=\", os.getenv(\"GEMINI_IMAGE_MODEL\", \"(default)\"))\n", + "print(\"GEMINI_IMAGE_EDIT_MODEL=\", os.getenv(\"GEMINI_IMAGE_EDIT_MODEL\", \"(default)\"))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "61aacffe", + "metadata": {}, + "outputs": [], + "source": [ + "# Enter a natural language NN spec (leave blank to use the sample in spec/vit.txt).\n", + "print(\"Enter your NN spec prompt (blank for sample):\")\n", + "user_text = input().strip()\n", + "if not user_text:\n", + " user_text = Path('spec/vit.txt').read_text()\n", + "\n", + "# Number of candidates (K) and max edit rounds (T)\n", + "K = 4\n", + "T = 1\n", + "print(f\"Configured: K={K}, T={T}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f6c28bb1", + "metadata": {}, + "outputs": [], + "source": [ + "# Run the multi-agent pipeline\n", + "state: AppState = {\n", + " 'K': K,\n", + " 'T': T,\n", + " 'user_text': user_text,\n", + " 'outdir': '' # use timestamped default\n", + "}\n", + "final_state = run_pipeline(state)\n", + "print('Artifacts directory:', final_state['outdir'])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a402a108", + "metadata": {}, + "outputs": [], + "source": [ + "# Display the final image\n", + "final_path = Path(final_state['outdir']) / 'final.png'\n", + "if final_path.exists():\n", + " display(Image(filename=str(final_path)))\n", + "else:\n", + " print('final.png not found at', final_path)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f7518a91", + "metadata": {}, + "outputs": [], + "source": [ + "# (Optional) Inspect outputs: spec and scoring\n", + "spec_txt = Path(final_state['outdir']) / 'spec.txt'\n", + "scores_json = Path(final_state['outdir']) / 'scores.json'\n", + "if spec_txt.exists():\n", + " print('--- spec.txt ---')\n", + " print(spec_txt.read_text())\n", + "if scores_json.exists():\n", + " print('--- scores.json ---')\n", + " print(scores_json.read_text())\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/NNGen/requirements.txt b/NNGen/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..c613fdcb3823ae54daa9ba9b698a2015a5f6e16e --- /dev/null +++ b/NNGen/requirements.txt @@ -0,0 +1,4 @@ +langgraph>=0.2.0 +google-generativeai>=0.7.0 +python-dotenv>=1.0.1 +gradio>=4.32.0 diff --git a/NNGen/runtime.txt b/NNGen/runtime.txt new file mode 100644 index 0000000000000000000000000000000000000000..55090899d0334b0210fdd7f30ea9b2e23e6fce59 --- /dev/null +++ b/NNGen/runtime.txt @@ -0,0 +1 @@ +python-3.10 diff --git a/NNGen/scripts/gradio_app.py b/NNGen/scripts/gradio_app.py new file mode 100644 index 0000000000000000000000000000000000000000..dbc6f19e1bba1a910d0252f0d7e2abb9ed9c4eeb --- /dev/null +++ b/NNGen/scripts/gradio_app.py @@ -0,0 +1,103 @@ +from __future__ import annotations + +import os +import shutil +from pathlib import Path +from typing import List, Tuple + +import gradio as gr + +from app.graph import run_pipeline, run_fusion_pipeline +from app.state import AppState + + +def _zip_outdir(outdir: str) -> str: + out = Path(outdir) + if not out.exists(): + return "" + zip_path = str(out) + ".zip" + # remove if exists + try: + if Path(zip_path).exists(): + Path(zip_path).unlink() + except Exception: + pass + shutil.make_archive(str(out), "zip", root_dir=str(out)) + return zip_path + + +def run_text_mode(user_text: str, K: int, T: int, make_zip: bool) -> Tuple[str, List[str], str, str]: + state: AppState = {"K": int(K), "T": int(T), "user_text": user_text or "", "outdir": ""} + final_state = run_pipeline(state) + outdir = final_state["outdir"] + # Collect candidates if present + candidates = [im.path for im in (final_state.get("images") or [])] + final_img = str(Path(outdir) / "final.png") + zip_path = _zip_outdir(outdir) if make_zip else "" + return final_img, candidates, outdir, zip_path + + +def run_image_mode(base_image, ref_images, instructions: str, K: int, make_zip: bool) -> Tuple[str, List[str], str, str]: + state: AppState = {"K": int(K), "T": 0, "outdir": "", "instructions": instructions or ""} + if base_image is not None: + state["base_image"] = base_image if isinstance(base_image, str) else base_image.name + refs: List[str] = [] + for f in (ref_images or []): + p = f if isinstance(f, str) else getattr(f, "name", None) + if p: + refs.append(p) + state["ref_images"] = refs + + final_state = run_fusion_pipeline(state) + outdir = final_state["outdir"] + candidates = [im.path for im in (final_state.get("images") or [])] + final_img = str(Path(outdir) / "final.png") + zip_path = _zip_outdir(outdir) if make_zip else "" + return final_img, candidates, outdir, zip_path + + +def app() -> gr.Blocks: + with gr.Blocks(title="NNGen — Gemini 2.5 Flash Image") as demo: + gr.Markdown(""" + # NNGen — Gemini 2.5 Flash Image + - Text mode: enter a natural language spec to generate a diagram (G1/G2/judge/edit). + - Image mode: edit/fuse images with textual instructions (e.g., replace UNet with Transformer). + - Offline works with placeholders if no `GEMINI_API_KEY` is set. With an API key, set `GEMINI_IMAGE_MODEL` and `GEMINI_IMAGE_EDIT_MODEL`. + """) + + with gr.Tab("Text Mode"): + user_text = gr.Textbox(label="NN spec (text)", lines=10, placeholder="Describe the architecture... e.g., Transformer encoder-decoder with cross-attention...") + with gr.Row(): + K = gr.Slider(1, 6, value=4, step=1, label="K candidates") + T = gr.Slider(0, 3, value=1, step=1, label="Max edit rounds (T)") + zip_output = gr.Checkbox(value=False, label="Zip outputs") + run_btn = gr.Button("Generate") + final_img = gr.Image(label="final.png", type="filepath") + gallery = gr.Gallery(label="Candidates").style(grid=4) + outdir = gr.Textbox(label="Artifacts directory", interactive=False) + zip_file = gr.File(label="Download run.zip", interactive=False) + + run_btn.click(run_text_mode, inputs=[user_text, K, T, zip_output], outputs=[final_img, gallery, outdir, zip_file]) + + with gr.Tab("Image Mode (Fusion/Edit)"): + base = gr.Image(label="Base image (optional)", type="filepath") + refs = gr.Files(label="Reference images (0..N)") + instr = gr.Textbox(label="Instructions", lines=4, placeholder="Replace the UNet backbone with a Transformer (DiT); keep layout, fonts, colors, arrows, and dashed groups unchanged.") + with gr.Row(): + K2 = gr.Slider(1, 6, value=4, step=1, label="K candidates") + zip_output2 = gr.Checkbox(value=False, label="Zip outputs") + run_btn2 = gr.Button("Compose / Edit") + final_img2 = gr.Image(label="final.png", type="filepath") + gallery2 = gr.Gallery(label="Fused Candidates").style(grid=4) + outdir2 = gr.Textbox(label="Artifacts directory", interactive=False) + zip_file2 = gr.File(label="Download run.zip", interactive=False) + + run_btn2.click(run_image_mode, inputs=[base, refs, instr, K2, zip_output2], outputs=[final_img2, gallery2, outdir2, zip_file2]) + + return demo + + +if __name__ == "__main__": + port = int(os.getenv("PORT", "7860")) + app().launch(server_name="0.0.0.0", server_port=port) + diff --git a/NNGen/spec/transformer.txt b/NNGen/spec/transformer.txt new file mode 100644 index 0000000000000000000000000000000000000000..f0da5d158368e87db50b25f8edc055bfe3d0cffe --- /dev/null +++ b/NNGen/spec/transformer.txt @@ -0,0 +1,32 @@ +Title: Transformer Encoder–Decoder (Machine Translation) + +Instructions: +- Produce a clean paper-style architecture diagram: flat 2D, white background, minimal color (black/gray + ≤2 accent colors), no gradients/3D/shadows. +- Layout left→right. Clear arrows indicate data flow. +- Draw boxes for major modules and show grouping for repeated layers. +- Text labels should be concise and capitalized (e.g., EMBEDDING, ENCODER xN, DECODER xN). + +Architecture: +- Input: tokenized source sentence +- Source Embedding + Positional Encoding +- Encoder (N layers): + - Multi-Head Self-Attention + - Add & LayerNorm + - Feed-Forward (MLP) + - Add & LayerNorm +- Target: previous target tokens (for training) +- Target Embedding + Positional Encoding +- Decoder (N layers): + - Masked Multi-Head Self-Attention + - Add & LayerNorm + - Cross-Attention (attends to Encoder outputs) + - Add & LayerNorm + - Feed-Forward (MLP) + - Add & LayerNorm +- Output: Linear + Softmax + +Style details: +- Use a dashed rounded rectangle to group the N repeated layers on both encoder and decoder. +- Keep arrows straight. Left→right overall; show a connection from Encoder outputs to the Cross-Attention in Decoder. +- If space is tight, abbreviate labels (e.g., SELF-ATTN, CROSS-ATTN, FFN). + diff --git a/NNGen/spec/vit.txt b/NNGen/spec/vit.txt new file mode 100644 index 0000000000000000000000000000000000000000..654b19405c3e74ae71ee65c74e7ef6fcb14ce1ac --- /dev/null +++ b/NNGen/spec/vit.txt @@ -0,0 +1,7 @@ +Generate a high-level diagram of a Vision Transformer (ViT): +- Input: 224×224 RGB image +- Patch Embedding: split into 16×16 patches and apply a linear projection +- Add CLS token and positional encoding +- Transformer Encoder stack: Multi-Head Self-Attention + MLP + residual + LayerNorm (repeat L layers) +- Classification head: take CLS token for linear classification +Layout requirements: left-to-right flow; clear arrow directions; correct spelling of all labels; show the number of layers L; keep colors readable.