Instructions to use EzioDevio/ArduinoLLM-7B with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use EzioDevio/ArduinoLLM-7B with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="EzioDevio/ArduinoLLM-7B")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("EzioDevio/ArduinoLLM-7B")
model = AutoModelForCausalLM.from_pretrained("EzioDevio/ArduinoLLM-7B", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use EzioDevio/ArduinoLLM-7B with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "EzioDevio/ArduinoLLM-7B"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "EzioDevio/ArduinoLLM-7B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/EzioDevio/ArduinoLLM-7B

SGLang

How to use EzioDevio/ArduinoLLM-7B with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "EzioDevio/ArduinoLLM-7B" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "EzioDevio/ArduinoLLM-7B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "EzioDevio/ArduinoLLM-7B" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "EzioDevio/ArduinoLLM-7B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use EzioDevio/ArduinoLLM-7B with Docker Model Runner:
```
docker model run hf.co/EzioDevio/ArduinoLLM-7B
```

EzioDevio commited on 20 days ago

Commit

4802bdc

verified ·

1 Parent(s): f18b3b1

Upload folder using huggingface_hub

Browse files

Files changed (1) hide show

README.md +60 -39

README.md CHANGED Viewed

@@ -1,54 +1,54 @@
-# ArduinoLLM-7B
-An open-source, LoRA-tuned Qwen2.5-Coder-7B specialist for embedded systems wiring and code generation — Arduino C++, Raspberry Pi Python, MicroPython, and CircuitPython, across 9 boards (ESP32, ESP32-S3, ESP32-C3, Raspberry Pi, Raspberry Pi Pico, Arduino Uno, ESP8266, Teensy 4.0, M5Stack Core2).
-Given a component and a board, it produces a wiring table, an ASCII wiring diagram, working code, and a short explanation — in one consistent format.
-## v2: Corpus-Enhanced Training
-v1 was trained entirely on synthetic examples generated by LLMs (Claude, Gemini, and a locally-hosted Qwen2.5-Coder-32B). That approach is fast and controllable, but it has a real ceiling: a model trained only on another model's *description* of correct wiring can't be more accurate than the model that generated its training data.
-v2 adds a genuine second training stage: **continued pretraining directly on real library source code** — 240,634 real files (~2.59 billion tokens) from the actual Arduino core libraries, `micropython-lib`, and the Adafruit CircuitPython Bundle. This release trained on the first ~500 million tokens (~19% of the corpus) of that real code, then re-ran instruction fine-tuning on top to restore clean output formatting.
-### Why this matters
-Manual testing of v1 found three concrete, reproducible failure modes:
-- A wiring diagram that internally contradicted its own wiring table
-- A fabricated, non-functional I2C address-conflict "fix" using invented register names
-- A weather-station answer that invented a CO2 reading from a sensor (BME280) that cannot measure CO2
-All three were re-tested after v2 training and no longer reproduce.
-### Measured results (12-question held-out benchmark)
-| Metric | v1 (synthetic only) | v2 (corpus + synthetic) |
 |---|---|---|
 | Format compliance | 83% | **100%** |
-| Runtime-contamination-free | 100% | 100% |
-| Correct runtime API present | 92% | 92% |
-| Code syntax valid | ~100% | 100% |
-| Generation speed (RTX 5090) | 73.2 tok/s | 37.5 tok/s |
-**Known tradeoff**: v2 is currently slower than v1 due to being loaded from a locally re-merged checkpoint rather than a pre-optimized quantized repo. A faster-quantized export may follow.
-## How it was built
-1. **Dataset generation** — synthetic wiring/code examples generated via the Anthropic API, Google's Gemini API, and a locally-hosted Qwen2.5-Coder-32B (via vLLM), validated for format compliance and runtime contamination. 1,607 unique examples in `full_dataset.jsonl`.
-2. **Continued pretraining** — `prepare_pretraining_corpus.py` chunks real library source into 2048-token blocks; `train_continued_pretrain.py` runs LoRA rank-32 training with `embed_tokens`/`lm_head` unlocked (needed to absorb new vocabulary/patterns from raw code, not just new behavior).
-3. **Merge** — `merge_pretrain_checkpoint.py` combines the pretraining adapter into a standalone base model.
-4. **Instruction fine-tuning** — `train_lora.py` re-runs standard LoRA fine-tuning (rank 16, attention/MLP only) on top of the corpus-enhanced base, using the same synthetic dataset as v1.
-5. **Final merge** — `merge_final_release.py` combines both stages into the single published model.
-6. **Evaluation** — `evaluate_model.py` runs the 12-question automated benchmark; manual testing checks specific documented failure modes via `ask_model.py`.
-## Licensing note
-Built on Qwen2.5-Coder-7B-Instruct (Apache 2.0). Synthetic training data was generated using Anthropic's and Google's APIs, and a locally-run open-weight model — OpenAI and DeepSeek were deliberately not used for data generation, as both explicitly prohibit using their outputs to train competing models in their terms of service. The real-code corpus (Arduino core libraries, `micropython-lib`, CircuitPython Bundle) is used under each project's own open-source license.
-## Limitations
-- Reliable on single-component, well-represented combinations; less reliable on genuinely novel multi-sensor combinations or troubleshooting scenarios not well-represented in the training data.
-- v2 trained on only ~19% of the available real-code corpus; the remaining ~81% has not yet been used.
-- Not a substitute for checking your own wiring against a component's actual datasheet, especially for voltage-sensitive components.
 ## Usage
@@ -61,7 +61,28 @@ model, tokenizer = FastLanguageModel.from_pretrained(
     load_in_4bit=True,
 )
 FastLanguageModel.for_inference(model)
 ```
-See `ask_model.py` for a full interactive example.
-- Character LCD displays (HD44780-style, in any interface variant — parallel, I2C backpack, or claimed SPI) are currently unreliable; wiring diagrams have shown pin fabrication and internal inconsistency with the accompanying code across multiple tests. Recommend manual verification against your specific module's datasheet for these displays specifically.

+---
+license: apache-2.0
+base_model: Qwen/Qwen2.5-Coder-7B-Instruct
+tags:
+  - arduino
+  - esp32
+  - raspberry-pi
+  - micropython
+  - circuitpython
+  - embedded-systems
+  - code-generation
+  - lora
+  - continued-pretraining
+language:
+  - en
+library_name: transformers
+---
+# ArduinoLLM-7B (v2)
+A Qwen2.5-Coder-7B specialist for embedded systems wiring and code generation, covering Arduino C++, Raspberry Pi Python, MicroPython, and CircuitPython across 9 boards.
+Given a component and a board, it generates a wiring table, an ASCII wiring diagram, working code, and a short explanation of the key design decision — in one consistent format.
+## What's new in v2
+v1 was trained entirely on LLM-generated synthetic examples. v2 adds a genuine second training stage: **continued pretraining on real library source code** (~500M tokens from 240,634 real files across the Arduino core libraries, `micropython-lib`, and the Adafruit CircuitPython Bundle), followed by re-running instruction fine-tuning on top.
+**Result**: format compliance improved from 83% to 100% on a 12-question held-out benchmark, and three specific, previously-documented failure modes (an internally-inconsistent wiring diagram, a fabricated I2C conflict-resolution procedure, and an invented sensor capability) no longer reproduce.
+| Metric | v1 | v2 |
 |---|---|---|
 | Format compliance | 83% | **100%** |
+| Contamination-free | 100% | 100% |
+| Correct runtime API | 92% | 92% |
+| Syntax valid | ~100% | 100% |
+| Speed (RTX 5090) | 73.2 tok/s | 37.5 tok/s |
+v2 currently runs slower than v1 — a known tradeoff from the local re-merge process, not a quality issue. A faster-quantized export may follow.
+## Post-release findings (ongoing)
+After initial v2 publication, targeted fixes were applied for two mechanically-verified issues, now enforced by automated checks in `validate_dataset.py` rather than prompt instructions alone:
+- ESP32/ESP8266-specific macros (e.g. `IRAM_ATTR`) appearing in AVR (Arduino Uno) code
+- Resistive sensors (LDR, FSR, thermistor) wired without a required voltage-divider resistor
+Further spot-testing has surfaced two additional, not-yet-fixed patterns worth knowing about before you rely on generated wiring:
+- Occasional swapped SPI pin assignments on ESP8266, where hardware SPI pins are fixed in silicon but the generated wiring table sometimes assigns them incorrectly
+- Character LCD displays (HD44780-style, in any interface variant — parallel, I2C backpack, or claimed SPI) are currently unreliable: wiring diagrams have shown fabricated pins and internal inconsistency with the accompanying code across multiple tests
+These are documented here rather than left for users to discover. As with all outputs, verify pin assignments against your specific hardware's actual datasheet — especially for character LCDs until this is resolved.
 ## Usage
     load_in_4bit=True,
 )
 FastLanguageModel.for_inference(model)
+prompt = "How do I wire a BME280 sensor to an ESP32 over I2C, with Arduino code?"
+inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
+outputs = model.generate(**inputs, max_new_tokens=1300)
+print(tokenizer.decode(outputs[0], skip_special_tokens=True))
 ```
+## Training data
+- **Synthetic**: 1,634 unique wiring/code examples, generated via the Anthropic API, Google's Gemini API, and a locally-hosted Qwen2.5-Coder-32B, validated for format compliance, runtime contamination, AVR/ESP macro correctness, and resistive-sensor voltage-divider presence.
+- **Real corpus**: ~500M tokens (of a 2.59B-token total) from real Arduino/MicroPython/CircuitPython library source code.
+OpenAI and DeepSeek were not used, since both explicitly prohibit using their API output to train competing models.
+## Limitations
+- Most reliable on well-represented single-component combinations.
+- v2 used only ~19% of the available real-code corpus.
+- Character LCD displays are currently unreliable (see Post-release findings above).
+- Occasional SPI pin-assignment errors on ESP8266 have been observed.
+- Always verify wiring against the component's actual datasheet before connecting power.
+## Full pipeline and dataset
+See [github.com/EzioDEVio/ArduinoLLM-7B](https://github.com/EzioDEVio/ArduinoLLM-7B) for the complete training pipeline, dataset, and evaluation scripts.