Files

267 lines
10 KiB
Python

"""Export FINN QCNN checkpoint to QONNX and FINN-ready ONNX.
Run this in an environment that has brevitas, qonnx and FINN installed.
Windows can usually export the QONNX file if brevitas is installed; the FINN
cleanup/conversion steps are expected to run inside the FINN Linux container.
"""
from __future__ import annotations
import argparse
import json
import os
import sys
from pathlib import Path
import numpy as np
import torch
def configure_stdio() -> None:
for stream in (sys.stdout, sys.stderr):
if hasattr(stream, "reconfigure"):
stream.reconfigure(encoding="utf-8", errors="replace")
configure_stdio()
SCRIPT_DIR = Path(__file__).resolve().parent
PROJECT_ROOT = SCRIPT_DIR.parent
PC_TRAINING_DIR = PROJECT_ROOT / "pc_training"
if str(PC_TRAINING_DIR) not in sys.path:
sys.path.insert(0, str(PC_TRAINING_DIR))
from finn_qcnn import create_finn_qcnn_from_checkpoint # noqa: E402
from train_finn_qcnn import FINNImageDataset # noqa: E402
def require_import(module_name: str, install_hint: str):
try:
return __import__(module_name, fromlist=["*"])
except Exception as exc:
raise ImportError(f"Missing {module_name}. {install_hint}") from exc
def load_model(checkpoint_path: Path) -> tuple[torch.nn.Module, dict]:
checkpoint = torch.load(checkpoint_path, map_location="cpu")
model = create_finn_qcnn_from_checkpoint(checkpoint)
model.load_state_dict(checkpoint["model_state_dict"])
model.eval()
return model, checkpoint
def export_qonnx(model: torch.nn.Module, output_path: Path, input_size: int) -> None:
require_import("brevitas", "Install with: pip install brevitas qonnx")
try:
from brevitas.export import export_qonnx as brevitas_export_qonnx
except Exception as exc:
raise ImportError(
"brevitas.export.export_qonnx is unavailable in this Brevitas version. "
"Use a FINN-compatible Brevitas release."
) from exc
output_path.parent.mkdir(parents=True, exist_ok=True)
dummy_input = torch.rand(1, 3, input_size, input_size)
brevitas_export_qonnx(
model,
export_path=str(output_path),
input_t=dummy_input,
)
print(f"QONNX exported: {output_path}")
def cleanup_qonnx(input_path: Path, output_path: Path) -> None:
"""Best-effort QONNX cleanup. API names vary across FINN/QONNX versions."""
require_import("qonnx", "Run inside FINN Docker or install qonnx.")
from qonnx.core.modelwrapper import ModelWrapper
from qonnx.transformation.general import GiveReadableTensorNames, GiveUniqueNodeNames, RemoveStaticGraphInputs
from qonnx.transformation.infer_shapes import InferShapes
model = ModelWrapper(str(input_path))
for transform in (
InferShapes(),
GiveUniqueNodeNames(),
GiveReadableTensorNames(),
RemoveStaticGraphInputs(),
):
model = model.transform(transform)
output_path.parent.mkdir(parents=True, exist_ok=True)
model.save(str(output_path))
print(f"QONNX cleaned: {output_path}")
def convert_to_finn(input_path: Path, output_path: Path) -> bool:
"""Convert QONNX quant nodes to FINN dialect when FINN is available."""
try:
__import__("finn")
from finn.transformation.qonnx.convert_qonnx_to_finn import ConvertQONNXtoFINN
from qonnx.core.modelwrapper import ModelWrapper
from qonnx.transformation.general import GiveReadableTensorNames, GiveUniqueNodeNames
from qonnx.transformation.infer_shapes import InferShapes
except Exception as exc:
print(f"FINN conversion skipped: {exc}")
return False
model = ModelWrapper(str(input_path))
for transform in (
ConvertQONNXtoFINN(),
InferShapes(),
GiveUniqueNodeNames(),
GiveReadableTensorNames(),
):
model = model.transform(transform)
output_path.parent.mkdir(parents=True, exist_ok=True)
model.save(str(output_path))
print(f"FINN ONNX exported: {output_path}")
return True
@torch.no_grad()
def evaluate_pytorch(model: torch.nn.Module, data_dir: Path, input_size: int) -> dict:
dataset = FINNImageDataset(data_dir, input_size=input_size, augment=False)
if len(dataset) == 0:
return {"num_images": 0, "accuracy": 0.0}
correct = 0
class_correct = [0] * 10
class_total = [0] * 10
for image, label in dataset:
logits = model(image.unsqueeze(0))
pred = int(logits.argmax(dim=1).item())
correct += int(pred == label)
class_total[label] += 1
if pred == label:
class_correct[label] += 1
return {
"num_images": len(dataset),
"accuracy": 100.0 * correct / len(dataset),
"class_correct": class_correct,
"class_total": class_total,
}
def _create_onnx_runner(onnx_path: Path):
"""Prefer QONNX execution, then fall back to ONNX Runtime for plain ONNX."""
try:
from qonnx.core.modelwrapper import ModelWrapper
from qonnx.core.onnx_exec import execute_onnx
wrapped = ModelWrapper(str(onnx_path))
input_name = wrapped.graph.input[0].name
def run_qonnx(array: np.ndarray) -> np.ndarray:
outputs = execute_onnx(wrapped, {input_name: array})
first_output = wrapped.graph.output[0].name
return np.asarray(outputs[first_output])
return run_qonnx, "qonnx"
except Exception as qonnx_exc:
try:
import onnxruntime as ort
session = ort.InferenceSession(str(onnx_path), providers=["CPUExecutionProvider"])
input_name = session.get_inputs()[0].name
def run_ort(array: np.ndarray) -> np.ndarray:
return np.asarray(session.run(None, {input_name: array})[0])
return run_ort, "onnxruntime"
except Exception as ort_exc:
raise RuntimeError(
f"No executable ONNX/QONNX runner is available. "
f"QONNX error: {qonnx_exc}; ONNX Runtime error: {ort_exc}"
) from ort_exc
def evaluate_onnx_argmax(onnx_path: Path, model: torch.nn.Module, data_dir: Path, input_size: int) -> dict:
try:
runner, runner_name = _create_onnx_runner(onnx_path)
except Exception as exc:
print(f"ONNX/QONNX comparison skipped: {exc}")
return {"available": False, "reason": str(exc)}
dataset = FINNImageDataset(data_dir, input_size=input_size, augment=False)
if len(dataset) == 0:
return {"available": True, "runner": runner_name, "num_images": 0, "top1_match": 0.0}
matches = 0
max_abs_diff = 0.0
for image, _label in dataset:
array = image.unsqueeze(0).numpy().astype(np.float32)
torch_logits = model(image.unsqueeze(0)).detach().numpy()
onnx_logits = runner(array)
matches += int(int(torch_logits.argmax()) == int(onnx_logits.argmax()))
max_abs_diff = max(max_abs_diff, float(np.max(np.abs(torch_logits - onnx_logits))))
return {
"available": True,
"runner": runner_name,
"num_images": len(dataset),
"top1_match": 100.0 * matches / len(dataset),
"max_abs_diff": max_abs_diff,
}
def main() -> int:
parser = argparse.ArgumentParser(description="Export FINN QCNN to QONNX/FINN ONNX")
parser.add_argument("--checkpoint", default="../data/models/finn_qcnn_best.pth")
parser.add_argument("--qonnx_out", default="../data/models/finn_qcnn_qonnx.onnx")
parser.add_argument("--clean_qonnx_out", default="../data/models/finn_qcnn_qonnx_clean.onnx")
parser.add_argument("--finn_out", default="../data/models/finn_qcnn_finn.onnx")
parser.add_argument("--val_dir", default="../data/processed/val")
parser.add_argument("--metrics_out", default="../results/finn_qcnn_export_metrics.json")
parser.add_argument("--skip_finn_conversion", action="store_true")
args = parser.parse_args()
checkpoint_path = (SCRIPT_DIR / args.checkpoint).resolve() if not os.path.isabs(args.checkpoint) else Path(args.checkpoint)
qonnx_out = (SCRIPT_DIR / args.qonnx_out).resolve() if not os.path.isabs(args.qonnx_out) else Path(args.qonnx_out)
clean_qonnx_out = (SCRIPT_DIR / args.clean_qonnx_out).resolve() if not os.path.isabs(args.clean_qonnx_out) else Path(args.clean_qonnx_out)
finn_out = (SCRIPT_DIR / args.finn_out).resolve() if not os.path.isabs(args.finn_out) else Path(args.finn_out)
val_dir = (SCRIPT_DIR / args.val_dir).resolve() if not os.path.isabs(args.val_dir) else Path(args.val_dir)
metrics_out = (SCRIPT_DIR / args.metrics_out).resolve() if not os.path.isabs(args.metrics_out) else Path(args.metrics_out)
if not checkpoint_path.exists():
print(f"Checkpoint not found: {checkpoint_path}")
print("Train first: python pc_training/train_finn_qcnn.py --data_dir ../data/processed")
return 2
model, checkpoint = load_model(checkpoint_path)
config = checkpoint.get("model_config", model.config())
input_size = int(config.get("input_size", 128))
print(f"Loaded checkpoint: {checkpoint_path}")
print(f"Best validation accuracy in checkpoint: {checkpoint.get('best_acc', 'unknown')}")
print(f"Model config: {json.dumps(config, indent=2)}")
export_qonnx(model, qonnx_out, input_size)
cleanup_qonnx(qonnx_out, clean_qonnx_out)
finn_converted = False
if not args.skip_finn_conversion:
finn_converted = convert_to_finn(clean_qonnx_out, finn_out)
metrics = {
"checkpoint": str(checkpoint_path),
"qonnx": str(qonnx_out),
"clean_qonnx": str(clean_qonnx_out),
"finn_onnx": str(finn_out) if finn_converted else None,
"finn_converted": finn_converted,
"model_config": config,
"checkpoint_best_acc": checkpoint.get("best_acc"),
"pytorch_val": evaluate_pytorch(model, val_dir, input_size),
}
metrics["qonnx_argmax_match"] = evaluate_onnx_argmax(clean_qonnx_out, model, val_dir, input_size)
metrics_out.parent.mkdir(parents=True, exist_ok=True)
with metrics_out.open("w", encoding="utf-8") as f:
json.dump(metrics, f, indent=2, ensure_ascii=False)
print(f"Export metrics written: {metrics_out}")
match = metrics["qonnx_argmax_match"].get("top1_match")
if match is not None and match < 98.0:
print(f"Warning: PyTorch/QONNX top-1 match is below 98%: {match:.2f}%")
return 0
if __name__ == "__main__":
raise SystemExit(main())