AI / Agent Engineering
Five projects, one thread: bring the evidence-first discipline of physics into machine learning. A locally fine-tuned 8B astronomy LLM, a mobile GUI agent at ZTE (planner + worker A2A), a knowledge-graph & experiment-design agent with Peking University, an auditable research agent, and a lightweight survey classifier — each built to refuse claims the evidence doesn't support.
An end-to-end domain LLM: 8 GB of ADS papers distilled into a two-stage fine-tune with my own architecture tweak — QLoRA + AttnRes — then wrapped in a four-step dual-track RAG. The whole pipeline (training and 4-bit serving) runs on a single RTX 3080 Ti 12 G, and it beats GPT-4o and AstroSage-8B on domain accuracy and hallucination rate.
Top-journal literature — ApJ / MNRAS / A&A via ADS. ~8k papers · 8 GB.
Incremental pre-train (30k) → instruction tune (20k).
Hybrid recall (vector + BM25), bge rerank Top20→Top5.
vLLM, 4-bit AWQ, ~5 stable concurrent users.
Standard residual connections just add each layer's output to the last, with a fixed weight of 1. In a deep model, knowledge injected early fades before it reaches the top (the "deep-knowledge forgetting" that hurts long astronomy reasoning). AttnRes groups the 32 layers into 8 blocks and replaces that fixed accumulation with a learnable attention over depth — a block can read directly from any earlier block. Only tiny pseudo-query vectors are trainable (~10K params, +1–2 GB VRAM), zero-initialized so training never destabilizes. Toggle the mode and watch a knowledge signal survive to the top.
Each block adds only the previous block's output, so knowledge injected early is attenuated with depth — the deep-knowledge forgetting that hurts long reasoning.
A block reads directly from any earlier block. The query wn is a tiny pseudo-query — the only trainable part — zero-initialized so training starts exactly at the standard residual and never destabilizes.
Base weights W0 stay frozen & 4-bit (NF4); only the low-rank BA and the pseudo-queries update — ~10K trainable params, +1–2 GB VRAM.
Schematic of the Block-AttnRes idea: freeze the base weights, and LoRA-tune only the depth-attention pseudo-queries. On my astronomy benchmark this lifted domain-QA accuracy 86% → 89.2%, complex-reasoning 78% → 83%, and cut hallucination 9% → 6%.
Finer granularity (N=16) is marginally more accurate (90.4%) but pays full attention-cache cost. Coarser (N=2) collapses toward standard residual and drops to 84%. N = 8 keeps 89.5% while cutting the depth-attention memory to ~50% — which is exactly why the whole thing fits on a single 12 GB consumer card.
LaTeX / reference stripping by regex, a BERT relevance classifier to keep astrophysics core, and MinHash dedup (128–2048 tokens). Instruction set: 20k samples (DS v3.1 + human check) mixing single-turn / multi-turn / reasoning / tool-calls.
Extended the Qwen2.5-7B / astroMlab-8B tokenizer with 2000 domain terms. Proper-noun spelling errors dropped 18% → 3%; QA accuracy +5%.
Full fine-tune needs ≥40 G and forgets fast. Rank ablation: r=8 (attn only) 78%, r=64 (all linear) 86% — best, r=128 84%. Then AttnRes on top.
Semantic chunking + fixed-length fill lifted recall 72% → 92%; a 4-step retrieve→rerank chain and fact constraints cut hallucination to 9%, and with no reference the model declines to answer.
Hardware: a single RTX 3080 Ti 12 G · Transformers + vLLM · Chroma + SQLite.
Semantic chunking (200–800 tok) + fixed fill lifted recall 72% → 92%; multi-hop via query decomposition + parent/child blocks 58% → 70%.
60% automated (DS v3.1 scoring) + 40% blind human review by 3 astronomers over 200 samples. Click a metric to compare.
| Model | Domain acc. | Hallucination | Reasoning | VRAM |
|---|---|---|---|---|
| maoAstro AttnRes | 89.2% | 6% | 83% | 12 G |
| GPT-4o | 82% | 18% | 76% | no local |
| AstroSage-8B | 80.9% | 12% | 78% | 16 G |
At ZTE Corporation I build a phone-side GUI agent: you say what you want in natural language, and it drives the real UI — opening apps, tapping, typing, scrolling — to get it done. It is a genuine agent-to-agent (A2A) system with two specialised models: a Planner that understands your screen and installed apps and decomposes the task, and a self-trained 32B Worker that grounds each step into concrete touches. Orchestrated on the OpenClaw framework.
Reads a screenshot of the current screen and the set of installed apps, then a large LLM decomposes the request into an ordered chain of executable sub-goals — choosing which app and what to do next.
A GUI-grounding model I trained to convert one sub-goal + the current screen into a concrete action — tap, swipe, type — with pixel coordinates, then reports the resulting screen back to the Planner to close the loop.
Screens are redrawn, not screenshots — but the loop is the real one: perceive → plan → ground → act → verify, with a human gate before it spends money.
A compact 4B multimodal model perceives the live screen and the app inventory, so the plan is grounded in what's actually on your phone — not a generic script.
The 32B worker is self-trained for UI grounding: sub-goal + screenshot → exact tap / swipe / type. Splitting perception-planning from execution is what makes it a real A2A system.
Built on the OpenClaw agent framework — a typed message bus carries sub-goals down and screen states back up, with a verify-and-replan loop between the two agents.
The agent drives the actual interface end-to-end — cross-app tasks that chain several apps together, exactly the multi-step errands people don't want to do by hand.
As algorithm lead I built a materials-science research platform for battery-electrolyte R&D with Peking University. It ships as two frontends: a Lab Intelligent Agent System (a Graph-RAG assistant with Q&A, knowledge-graph and experiment-execution modes) and a Knowledge-Graph Visualization System (build, manage and quality-score the graphs). Below: the product framework, an experiment-design walkthrough, and the extraction pipeline behind it.
Graph Retrieval-Augmented System · 实验室智能体系统
图谱可视化系统 · build · manage · assess
Every triple in the graph is earned. A four-stage LLM pipeline extracts and then audits it, two dedup passes fold synonyms and PubChem CIDs together, and Leiden community detection plus LLM enrichment organize the result before it lands in Neo4j.
Schema: entity_types, relation_types, attributes
typed relations between entities
properties & measured values
score every triple: accuracy · triple-support · usefulness; drop hallucinations (θ=0.5)
abbreviation synonym graph → lexicographically-smallest canonical name
local SQLite compound-ID alignment; drop redundant abbreviation triples
graspologic partition → LLM names Top-20 members & Top-10 relations
MERGE nodes by (label,name), CREATE parallel edges, 500 triples / txn
The same architecture generalizes: literature → clean chunks → schema-based triples → audited, deduplicated, community-organized graph → Neo4j — reused across both the materials agent here and the astronomy Astro Agent below.
My open-source flagship (github.com/wangnengdejiamao/Astro_Agent): a 16-node LangGraph that resolves a target, pulls multi-survey data, models it through three mandatory iterations, audits every claim, and — only when the QA gate clears — drafts an ApJ-style manuscript. It uses filesystem-as-memory for a diff-able audit trail, and a delegation loop that turns new methods from papers into tested, registered tools by handing the implementation to a second coding agent.
Schematic of the real analysis_agent graph — node names mirror the implementation. The hard cap of three modelling iterations, two replans and two reflexion rewrites is exactly how the agent refuses to over-claim.
When a run hits "I'm missing a tool", the orchestrator doesn't invent an answer. It packages the
new method from a paper into a structured spec and delegates the implementation to Claude Code
(claude_code_delegate) as a second coding agent. The tool is only registered as a new Skill when its
tests pass — with a human review gate. Watch the hand-off.
The agent is deliberately full-stack. Hover or tap a tool to see how it's used — grouped by the four architectural layers.
Hover a tool above to see how Astro Agent uses it.
Session-level context and temporary results passed node-to-node.
Keyword search over the local white-dwarf literature — backs methodology decisions.
Entity graph + meta-graph over Neo4j / SQLite / JSON — supports method transfer and evidence chains.
Every turn emits JSON — prevents behavioural drift and keeps output predictable.
The agent builds a typed knowledge graph — 8 entity types (paper · source · WD class · survey · instrument · method · model · parameter) linked by typed relations. Shown here is the graph of my own three papers; retrieval combines BM25/vector recall with multi-hop graph traversal — pick a query (or click a node) to watch it land on an entity and pull in its connected context.
Where it started: turn every phase-folded ZTF light curve into a 224×224 image, then let a mobile-grade convolutional net read its shape. It sorts each star into EA (detached), EW (contact) or Non-EB — reaching 99.4–99.6% on 1,884 held-out curves. Pick a class and watch the forward pass; add noise and the softmax loses its nerve. Code: ztf_CNN_maoclassification.
Real pipeline: ZTF g/r photometry from IRSA, a Lomb–Scargle period, phase-folding, then a 1×224×224 render fed to GhostNet or MobileNetV2. Accuracies and the confusion matrix are the repository's reported values; the forward-pass animation is schematic.