TACHY-Compiler

TACHY-Compiler is a comprehensive deep learning compiler and platform conversion framework developed by Deeper-I. It is designed to bridge the gap between popular deep learning frameworks (like PyTorch) and the TACHY hardware accelerator runtime environment.

This compiler handles model parsing, optimization, tensor alignment, and binary generation. It robustly supports large-scale models, complex operators, and dual-checkpoint pipelines out of the box.

Key Features

• PyTorch to ONNX to TACHY: Seamless end-to-end compilation pipeline.
• Dual vs single compile: Dual (compile-dual) takes distinct prepared eval / comp (from pre + opt via deploy) and produces full NPU-runnable instructions and parameters. Single (compile-single) takes one PT/CKPT (usually scratch pre), feeds it as identical eval and comp through the same backend, and is a temporary NPU usability smoke — not opt-accuracy verification. See tachy guide compile-modes. eval allows inference verification; comp does not (compile-stage temp). pre = scratch (no transform/pruning); opt = transform and/or pruning. When pruning follows transform, dual pre must still be pre-transform scratch.
• Large Model Support: Built-in mechanisms to handle models larger than the Protobuf 2GB limit using external_data mapping.
• Robust ONNX Versioning: Automatically utilizes ONNX Opset 18 for stability, equipped with automatic version conversion and fallback mechanisms to mitigate onnxscript conversion issues.
• MCP Server Integrated: Exposes tools to LLMs and agentic frameworks via the Model Context Protocol (MCP) using FastMCP.
• Dynamic Binary Resolution: Intelligently locates dependency binaries utilizing environment variables (TACHY_UTIL_PATH) and relative package paths.

Installation

You can install TACHY-Compiler directly via PyPI:

pip install TACHY-Compiler

Requirements

• Python >= 3.8
• numpy, networkx, onnx, commentjson, ordered-set, easydict, DDesignerAPI
• (Optional) torch if utilizing the PyTorch to ONNX conversion pipeline.

CLI Usage

TACHY-Compiler provides a simple, unified command-line interface under the tachy command.

1. Compile modes (dual vs single)

tachy guide compile-modes            # goals + procedures (alias: compile-single)

Agents: MCP get_compile_modes_guide, compile_single_model, compile_dual_model.

2. Deploy dual checkpoints (pre / opt → eval / comp)

compile-dual expects prepared eval / comp models, not raw training pre / opt checkpoints. Adapt checkpoints in your environment first:

tachy guide deploy-dual              # print the full contract + checklist
tachy init-deploy --out ./deploy_dual_pt.py   # blank template (hooks to fill in)
# edit hooks, then:
python deploy_dual_pt.py pre.pt opt.pt eval.pt comp.pt

Agents can use the same guide via MCP (get_deploy_dual_guide, init_deploy_template).

3. Dual Checkpoint Compilation

Takes prepared eval and comp models and produces full NPU-runnable instructions and parameters. eval artifacts allow inference verification; comp artifacts do not (temporary files for the next compile stage). Intermediate files are automatically managed and cleaned up if requested.

tachy compile-dual \
    --eval_model ./eval_model.pth \
    --comp_model ./comp_model.pth \
    --input_shape "[1,3,224,224]" \
    --output_dir ./dual_output \
    --cleanup

Outputs will be cleanly structured into ./dual_output/final_binaries/eval/ and ./dual_output/final_binaries/comp/.

4. Single compile (NPU smoke)

Same backend as dual; pass one model for both slots:

tachy compile-single \
    --model ./model.pt \
    --input_shape "[1,3,224,224]" \
    --output_dir ./single_output

Equivalent: compile-dual with --eval_model and --comp_model set to the same path. Confirm NPU execution; then use dual for production-style deploy.

5. Single Model Pipeline Steps

If you need granular control, you can execute the pipeline steps individually.

Convert PyTorch to ONNX

tachy convert-pt2onnx ./model.pth ./model.onnx "[1,3,224,224]" False

Lint ONNX Model (--format table|markdown|json, --strict treats WARN as failure, --buffer_size N for width check)

tachy lint ./model.onnx
tachy lint ./model.onnx --suggest                   # search remedies for failed checks
tachy lint ./model.onnx --fix ./model_fixed.onnx    # repeat lint -> remedy until clean (--iterate N, default 5)

Each check lives in src/tachy_compiler/compiler/lint/rules/<id>_*.py together with its remedies (exact: same I/O, layout: host must permute the input, advisory: retraining needed). Remedies are verified by a full re-lint and an onnxruntime equivalence check. compile-dual --auto_fix applies the best remedy before ONNX → TACHY conversion.

Convert ONNX to TACHY Format

tachy convert-onnx ./model.onnx ./model.json

Compile TACHY JSON to Runtime Binaries

tachy compile ./model.json ./output_bin_dir

6. Model Context Protocol (MCP) Server

You can spin up the built-in MCP server to allow LLMs and AI Agents to compile models on your behalf.

tachy mcp

Environment Variables

• TACHY_UTIL_PATH (Optional): An absolute path to the directory containing external utility binaries (fc.out, block_4bit.out). If not set, the compiler will intelligently look for the optional directory within the installed package. Download these binaries from https://gofile.me/5NFjK/PXXLhuIqj, then set TACHY_UTIL_PATH to that directory or place them under optional/.

License

This project is licensed under the BSD-3-Clause License. See the LICENSE file for details.