Parti-Vision Base — Qwen3.5-9B

Parti-Vision turns a hardware idea — a sentence, a short brief, even a sketch — into a complete build blueprint.

Tell it what to build — "a USB-powered desk lamp with touch dimming" — and it returns one JSON blueprint: parts list, pin-level wiring, ordered build steps, a costed sourcing table, and an appearance spec with a ready-to-use image-generation prompt. It's the all-in-one merged model — standalone, no adapter needed. By caid-technologies.

Early research preview. For drafting and exploring ideas — not a replacement for real engineering, CAD, or safety review.

What you can give it

• A plain-English request — one or two sentences.

• A short document — a brief or notes in plain text/Markdown, pasted into the message:

  <your request>
  
  --- ATTACHED DOCUMENT: brief.md ---
  <the document text>
  --- END DOCUMENT ---
  

• A concept image — a hand-drawn sketch or product render, as a regular vision input.

Any combination works; prompt + brief + render is strongest. Convert PDFs, CAD files, or spreadsheets to text or an image first.

Try it

The model answers in JSON directly — no reasoning preamble to strip.

from unsloth import FastVisionModel

REPO = "caid-technologies/parti-vision"
model, tok = FastVisionModel.from_pretrained(REPO, load_in_4bit=False)
FastVisionModel.for_inference(model)

SYSTEM_PROMPT = (
    "You design maker/electronics products. Reply with one JSON object with exactly these "
    "10 keys: project, requirements, components, relationships, circuit, fabrication, "
    "instructions, appearance, image_generation_prompt, sourcing. Output only the JSON."
)
messages = [
    {"role": "system", "content": [{"type": "text", "text": SYSTEM_PROMPT}]},
    {"role": "user",   "content": [{"type": "text", "text": "Design a USB desk lamp with touch dimming."}]},
]
text = tok.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
inputs = tok(text=text, return_tensors="pt").to("cuda")
out = model.generate(**inputs, max_new_tokens=13000, do_sample=False, repetition_penalty=1.1)
print(tok.decode(out[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True))

💡 Blueprints are long: keep max_new_tokens high and the repetition penalty on. To include an image, add {"type": "image", "image": your_image} to the user content and pass images= to the tokenizer.

🚀 Serving it for real? Use vLLM with guided_json constrained to the blueprint schema — it takes valid-blueprint rates on unseen prompts from 61% to **97%**.

Good to know

• English prompts, maker/electronics domain. Off-topic requests still get a blueprint, not a refusal.
• Outputs are drafts, not verified engineering — roughly half have at least one design slip (a pin on the wrong net, costs slightly off, a misordered step). Re-validate in your app, and review before you solder.
• Very long plans can get cut off at the token cap; contradictory or impossible requests can produce confidently wrong blueprints.

How well it works

Tested on 60 held-out examples and 42 fresh out-of-distribution prompts, scoring every output against the blueprint schema and semantic design checks:

Valid-blueprint rate	In-distribution	Unseen realistic prompts
Plain decoding	~67%	~61%
With guided_json (recommended)	~83%	~97%

The stock base model scores 0% on the same tests.

Technical details (for ML folks)

• Base model: Qwen/Qwen3.5-9B (Apache-2.0); this repo is the fine-tune merged to 16-bit. Prefer the adapter? Use caid-technologies/parti-vision-lora.

• Output contract: one JSON object with exactly 10 top-level keys (project, requirements, components, relationships, circuit, fabrication, instructions, appearance, image_generation_prompt, sourcing); schema.json + validate.py in the repo re-check any output.

• Training: LoRA via Unsloth (r=16, α=16, bf16) over language attention+MLP layers, vision encoder frozen, then merged; 3 epochs, max seq 16384. Data: 150 synthetic records, each validated by the same schema + semantic gates, × 4 input variants (prompt / +brief / +sketch / +brief+render). Records authored by Claude Sonnet 5 and DeepSeek-V4-Pro; concept images by gpt-image-1.

• Chat template: patched to default to enable_thinking=False (JSON directly) under transformers, Unsloth, and vLLM; pass enable_thinking=True for a reasoning trace. If you override the template in vLLM, re-add chat_template_kwargs={"enable_thinking": false}.

• Evaluation (vLLM; strict parse = raw json.loads, no salvage; schema-valid = full pydantic Product; gates = pin existence, sourcing arithmetic, phase order):

  In-distribution, 60 held-out examples:

  Metric	Fine-tuned — free	Fine-tuned — guided_json	Base Qwen3.5-9B
  Strict JSON parse	0.85	0.83	0.97
  Schema-valid (Product)	0.67	0.83	0.00
  Gates-clean	0.40	0.48	0.00
  Prompt-echo fidelity	0.82	0.82	0.00

  Out-of-distribution, 42 fresh prompts (free decoding):

  kind	n	parse	schema
  realistic paraphrase	10	0.90	0.70
  new domain	10	0.90	0.70
  vague / underspecified	5	0.80	0.40
  image-grounded	6	0.83	0.50
  adversarial	7	0.43	0.29
  off-task	4	1.00	0.75

  Realistic OOD schema-valid: 0.61 free / 0.97 under guided_json. Strongest input variant (prompt + brief + render): 0.73 schema-valid / 0.93 echo, free decoding. Sampling robustness at temperature=0.7 (30 generations, 3 seeds): parse 0.97, schema-valid 0.57. Parse failures are almost all truncation at the 13k-token cap (10/126 free generations; 0 thinking-leaks, 0 markdown fences, 1 trailing-data).

• Inference: do_sample=False, repetition_penalty≈1.1, max_new_tokens≥13000; serve with vLLM guided_json for production, re-validate with validate.py, regenerate on gate failures.

@misc{parti_vision_base,
  title  = {Parti-Vision Base: Qwen3.5-9B for multimodal hardware blueprint generation},
  author = {Caid Technologies},
  year   = {2026},
  howpublished = {\url{https://huggingface.co/caid-technologies}}
}

Built with Unsloth and 🤗 Transformers / PEFT / TRL.