IQ.Pilot Prebuilt Release @ 27f668a

iqpilot/selfdrive/iqmodeld/models/runners/__init__.py

@@ -0,0 +1,3 @@
+"""
+Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos/
+"""

iqpilot/selfdrive/iqmodeld/models/runners/model_runner.py

@@ -0,0 +1,231 @@
+"""
+Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos
+"""
+import os
+import pickle as _pk
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+from iqpilot.cereal import custom
+from iqpilot.common.swaglog import cloudlog
+from iqpilot.system.hardware import TICI
+from iqpilot.system.hardware.hw import Paths as _hw_paths
+from iqpilot.selfdrive.iqmodeld.models.helpers import get_active_bundle as _fetch_bundle
+from iqpilot.selfdrive.iqmodeld.models.combined_artifact import has_combined_split_artifact
+
+# ---- runtime type surface (native OpenCL/frame handles resolve to Any off-device) ----
+if TYPE_CHECKING:
+  from iqpilot.selfdrive.iqmodeld.native.iqmodel_pyx import GpuMemorySlot, RoadProjector
+else:
+  def _resolve_native_types() -> tuple[Any, Any]:
+    try:
+      from iqpilot.selfdrive.iqmodeld.native.iqmodel_pyx import GpuMemorySlot as iq_clmem
+      from iqpilot.selfdrive.iqmodeld.native.iqmodel_pyx import RoadProjector as iq_frame
+      return iq_clmem, iq_frame
+    except (ModuleNotFoundError, ImportError):
+      return Any, Any
+
+  GpuMemorySlot, RoadProjector = _resolve_native_types()
+
+NumpyDict = dict[str, np.ndarray]
+ShapeDict = dict[str, tuple[int, ...]]
+SliceDict = dict[str, slice]
+CLMemDict = dict[str, GpuMemorySlot]
+FrameDict = dict[str, RoadProjector]
+
+ModelType = custom.IQModelManager.Model.Type
+Model = custom.IQModelManager.Model
+
+SEND_RAW_PRED = os.getenv("SEND_RAW_PRED")
+CUSTOM_MODEL_PATH = _hw_paths.model_root()
+
+_META_FIELDS = ("input_shapes", "output_slices")
+
+USBGPU = "USBGPU" in os.environ
+
+
+def _configure_accelerator():
+  """Point tinygrad at the right backend. Must run before tinygrad is imported,
+  which is why it fires at module import."""
+  backend, extra = ("QCOM" if TICI else "CPU"), {}
+  if USBGPU:
+    backend, extra = "AMD", {"AMD_IFACE": "USB"}
+  elif TICI:
+    extra = {"QCOM_PRIORITY": "8"}
+  os.environ["DEV"] = backend
+  os.environ.update(extra)
+
+
+_configure_accelerator()
+
+
+# real metadata pkls are a few KB; anything bigger is a model artifact wrongly
+# referenced as metadata (pre-fix manifests self-referenced the artifact), and
+# unpickling it here double-loads the model onto the GPU
+_META_MAX_BYTES = 1 << 20
+
+
+def load_artifact_metadata(metadata_filename):
+  """Read one artifact's metadata pkl: (input shapes, output slices)."""
+  try:
+    path = os.path.join(CUSTOM_MODEL_PATH, metadata_filename)
+    if os.path.getsize(path) > _META_MAX_BYTES:
+      cloudlog.error(f"metadata pkl {metadata_filename} is artifact-sized, refusing to unpickle it")
+      return tuple({} for _ in _META_FIELDS)
+    with open(path, 'rb') as fh:
+      blob = _pk.load(fh)
+    return tuple(blob.get(field, {}) for field in _META_FIELDS)
+  except Exception:
+    cloudlog.exception(f"unreadable metadata pkl {metadata_filename}, continuing without it")
+    return tuple({} for _ in _META_FIELDS)
+
+
+@dataclass
+class ArtifactSpec:
+  """One model of the active bundle plus its unpacked metadata."""
+  model: Any
+  metadata: Any = None
+  input_shapes: ShapeDict = field(default_factory=dict)
+  output_slices: SliceDict = field(default_factory=dict)
+
+  def __post_init__(self):
+    self.metadata = self.model.metadata
+    if self.metadata:
+      self.input_shapes, self.output_slices = load_artifact_metadata(self.metadata.fileName)
+
+
+# kept name: some runners annotate against the old alias
+ModelData = ArtifactSpec
+
+
+class RunnerRoot:
+  """Shared root of the runner hierarchy.
+
+  Both ModelRunner and the per-model parser mixins (model_types.py) inherit
+  this, so the concrete `TinygradRunner(ModelRunner, *Tinygrad)` diamond keeps
+  one consistent parser registry + slice implementation.
+  """
+
+  parser_method_dict: dict
+  _model_data: "ArtifactSpec | None"
+
+  def _slice_outputs(self, model_outputs):
+    raise NotImplementedError
+
+
+class ModelRunner(RunnerRoot):
+  """Base for the tinygrad/ONNX runners.
+
+  Owns the active bundle's ArtifactSpecs and the shared slice/parse plumbing;
+  subclasses provide input staging (prepare_inputs) and execution (_run_model).
+  """
+
+  # False for fused runners, which warp + manage temporal buffers inside the JIT
+  uses_opencl_warp = True
+
+  def __init__(self):
+    active = _fetch_bundle()
+    if not active:
+      raise ValueError("runner started without an active model bundle")
+
+    self.models = {spec.type.raw: ArtifactSpec(spec) for spec in _qcom_models(active)}
+    self.is_20hz_3d = False
+    self.is_20hz = active.is20hz
+    self.inputs = {}
+    self.parser_method_dict = {}
+    self._model_data = None            # active spec for the current operation
+    self._parser = self._constants = None
+
+  def _active_spec(self):
+    spec = self._model_data
+    if spec is None:
+      raise ValueError("Model data is not available. Ensure the model is loaded correctly.")
+    return spec
+
+  # views proxied straight off the active artifact spec; kept out of the class
+  # body (served via __getattr__) so the read surface stays data-driven
+  _SPEC_VIEW = frozenset(("input_shapes", "output_slices"))
+
+  def __getattr__(self, name):
+    if name == "constants":
+      return self._constants
+    if name == "vision_input_names":
+      return list(self._active_spec().input_shapes)
+    if name in ModelRunner._SPEC_VIEW:
+      return getattr(self._active_spec(), name)
+    raise AttributeError(name)
+
+  def prepare_inputs(self, imgs_cl, numpy_inputs, frames):
+    """Stage image + numpy inputs for inference; implemented per backend."""
+    raise NotImplementedError
+
+  def _run_model(self):
+    """Execute inference over the staged inputs; implemented per backend."""
+    raise NotImplementedError
+
+  def run_model(self):
+    # parsing happens inside each backend's _run_model
+    return self._run_model()
+
+  def _slice_outputs(self, model_outputs):
+    """Split the flat output vector into named views per the artifact's slice table."""
+    sliced = {}
+    for tag, span in self._active_spec().output_slices.items():
+      sliced[tag] = model_outputs[np.newaxis, span]
+    if SEND_RAW_PRED:
+      sliced["raw_pred"] = model_outputs.copy()
+    return sliced
+
+
+# ---- runner selection (which backend to build for the active bundle) ----------
+
+def _qcom_models(bundle) -> list:
+  # usbeMac artifacts ride along in a bundle for the eGPU host; they are never
+  # loaded on QCOM and must not affect runner classification
+  return [m for m in bundle.models if m.type.raw != ModelType.usbeMac]
+
+
+def _single_artifact_prefix(bundle, prefix: str) -> bool:
+  models = _qcom_models(bundle)
+  return len(models) == 1 and models[0].artifact.fileName.startswith(prefix)
+
+
+def _is_fused_bundle(bundle) -> bool:
+  return _single_artifact_prefix(bundle, "driving_fused_")
+
+
+def _is_supercombo_bundle(bundle) -> bool:
+  return _single_artifact_prefix(bundle, "driving_supercombo_")
+
+
+def _is_split_bundle(bundle) -> bool:
+  present = {m.type.raw for m in _qcom_models(bundle)}
+  split_kinds = {ModelType.vision, ModelType.policy, ModelType.offPolicy, ModelType.onPolicy}
+  return not present.isdisjoint(split_kinds)
+
+
+def get_model_runner() -> "ModelRunner":
+  """Build the runner backend that fits the active bundle (supercombo / fused /
+  combined-split / split / single). Concrete runners are imported lazily so one
+  backend failing to load can't take down the others at import time."""
+  from iqpilot.selfdrive.iqmodeld.models.runners.tinygrad.tinygrad_runner import (TinygradRunner,
+                                                                                             TinygradSplitRunner)
+  bundle = _fetch_bundle()
+  # an eMac-only bundle (no QCOM-loadable models) runs the stock default on
+  # device; the big host serves the bundle's precompiled artifact
+  if not (bundle and bundle.models and _qcom_models(bundle)):
+    return TinygradRunner(ModelType.supercombo)
+
+  if _is_supercombo_bundle(bundle):
+    from iqpilot.selfdrive.iqmodeld.models.runners.tinygrad.supercombo_runner import TinygradSupercomboRunner
+    return TinygradSupercomboRunner()
+  if _is_fused_bundle(bundle):
+    from iqpilot.selfdrive.iqmodeld.models.runners.tinygrad.fused_runner import TinygradFusedRunner
+    return TinygradFusedRunner()
+  if _is_split_bundle(bundle) and has_combined_split_artifact(bundle):
+    from iqpilot.selfdrive.iqmodeld.models.runners.tinygrad.combined_split_runner import TinygradCombinedSplitRunner
+    return TinygradCombinedSplitRunner()
+  if _is_split_bundle(bundle):
+    return TinygradSplitRunner()
+  return TinygradRunner(_qcom_models(bundle)[0].type.raw)

iqpilot/selfdrive/iqmodeld/models/runners/tinygrad/__init__.py

@@ -0,0 +1,3 @@
+"""
+Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos/
+"""

iqpilot/selfdrive/iqmodeld/models/runners/tinygrad/combined_split_runner.py

@@ -0,0 +1,245 @@
+"""
+Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos/
+"""
+
+from __future__ import annotations
+
+import os
+import pickle
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+from iqpilot.selfdrive.iqmodeld.models.combined_artifact import resolve_combined_split_artifact
+from iqpilot.selfdrive.iqmodeld.models.helpers import get_active_bundle
+from iqpilot.selfdrive.iqmodeld.models.runners.model_runner import NumpyDict, ShapeDict, SliceDict
+from iqpilot.selfdrive.iqmodeld.models.runners.model_runner import ModelRunner
+from iqpilot.selfdrive.iqmodeld.models.split_model_constants import SplitModelConstants
+from iqpilot.selfdrive.iqmodeld.parser import PhaseParser
+
+
+def _tinygrad_imports():
+  from tinygrad.device import Device
+  from tinygrad.tensor import Tensor
+  return Tensor, Device
+
+
+def _phase_roles(meta_by_role: dict[str, dict]) -> list[str]:
+  return [name for name in meta_by_role if name != "vision"]
+
+
+def _phase_desire_key(policy_shapes: dict[str, tuple[int, ...]]) -> str:
+  for key in policy_shapes:
+    if key.startswith("desire"):
+      return key
+  raise KeyError("No desire-like key found in policy inputs")
+
+
+def _phase_image_keys(vision_shapes: dict[str, tuple[int, ...]]) -> tuple[str, str]:
+  names = sorted(name for name in vision_shapes if "img" in name)
+  road_key = next((name for name in names if "big" not in name), None)
+  wide_key = next((name for name in names if "big" in name), None)
+  if road_key is None or wide_key is None:
+    raise ValueError(f"Unable to resolve road/wide image keys from {list(vision_shapes)}")
+  return road_key, wide_key
+
+
+def _base_policy_keys(policy_shapes: dict[str, tuple[int, ...]]) -> set[str]:
+  desired_key = _phase_desire_key(policy_shapes)
+  return {desired_key, "features_buffer", "traffic_convention", "action_t"}
+
+
+def _slice_map(raw_blob: np.ndarray, slices: dict[str, slice]) -> NumpyDict:
+  return {name: raw_blob[np.newaxis, section] for name, section in slices.items() if name != "pad"}
+
+
+class TinygradCombinedSplitRunner(ModelRunner):
+  uses_opencl_warp: bool = False
+
+  def __init__(self):
+    super().__init__()
+    self._constants = SplitModelConstants
+    self._parser = PhaseParser()
+    self._bundle = get_active_bundle()
+    self._artifact_path = resolve_combined_split_artifact(self._bundle)
+    if self._artifact_path is None:
+      raise FileNotFoundError("No IQ combined split artifact is available for the active bundle")
+
+    with open(self._artifact_path, "rb") as artifact:
+      runtime_package: dict[Any, Any] = pickle.load(artifact)
+
+    self._meta_by_role = runtime_package.get("meta_by_role", runtime_package.get("metadata", {}))
+    self._policy_roles = runtime_package.get("roles", _phase_roles(self._meta_by_role))
+    self._camera_programs = {
+      camera_key: spec
+      for camera_key, spec in runtime_package.items()
+      if isinstance(camera_key, tuple) and isinstance(spec, dict)
+    }
+    self._execute_bundle = runtime_package.get("execute_bundle", runtime_package.get("run_policy"))
+    self._frame_stride = int(runtime_package.get("frame_stride", runtime_package.get("frame_skip", 1)))
+
+    if "vision" not in self._meta_by_role:
+      raise ValueError("Combined split artifact is missing vision metadata")
+    if not self._policy_roles:
+      raise ValueError("Combined split artifact is missing policy roles")
+    if self._execute_bundle is None:
+      raise ValueError("Combined split artifact is missing execute_bundle")
+
+    self._vision_meta = self._meta_by_role["vision"]
+    self._primary_policy_meta = self._meta_by_role[self._policy_roles[0]]
+    self._desired_key = _phase_desire_key(self._primary_policy_meta["input_shapes"])
+    self._road_key, self._wide_key = _phase_image_keys(self._vision_meta["input_shapes"])
+    self._extra_policy_keys = [
+      key for key in self._primary_policy_meta["input_shapes"]
+      if key not in _base_policy_keys(self._primary_policy_meta["input_shapes"])
+    ]
+
+    self._queue_tensors: dict[str, Any] | None = None
+    self._numpy_state: dict[str, np.ndarray] | None = None
+    self._camera_shape: tuple[int, int] | None = None
+    self._blob_cache: dict[tuple[str, int], Any] = {}
+    self._last_desire = np.zeros(self._primary_policy_meta["input_shapes"][self._desired_key][2], dtype=np.float32)
+
+  @property
+  def vision_input_names(self) -> list[str]:
+    return [self._road_key, self._wide_key]
+
+  @property
+  def input_shapes(self) -> ShapeDict:
+    merged: ShapeDict = dict(self._vision_meta["input_shapes"])
+    for role in self._policy_roles:
+      merged.update(self._meta_by_role[role]["input_shapes"])
+    return merged
+
+  @property
+  def output_slices(self) -> SliceDict:
+    merged: SliceDict = dict(self._vision_meta["output_slices"])
+    for role in self._policy_roles:
+      merged.update(self._meta_by_role[role]["output_slices"])
+    return merged
+
+  def prepare_inputs(self, imgs_cl, numpy_inputs, frames):
+    raise RuntimeError("Combined split runner manages its own warp + queue state; use run_fused()")
+
+  def _frame_blob(self, stream_name: str, buf):
+    Tensor, Device = _tinygrad_imports()
+    raw_frame = np.frombuffer(buf.data, dtype=np.uint8)
+    cache_key = (stream_name, raw_frame.ctypes.data)
+    tensor = self._blob_cache.get(cache_key)
+    if tensor is None:
+      tensor = Tensor.from_blob(raw_frame.ctypes.data, (raw_frame.size,), dtype="uint8", device=Device.DEFAULT)
+      self._blob_cache[cache_key] = tensor
+    return tensor
+
+  def _allocate_runtime_state(self, camera_width: int, camera_height: int) -> None:
+    if self._queue_tensors is not None and self._camera_shape == (camera_width, camera_height):
+      return
+    if (camera_width, camera_height) not in self._camera_programs:
+      raise RuntimeError(f"No combined split kernels available for {camera_width}x{camera_height}")
+
+    Tensor, Device = _tinygrad_imports()
+    vision_shapes = self._vision_meta["input_shapes"]
+    policy_shapes = self._primary_policy_meta["input_shapes"]
+
+    image_shape = vision_shapes[self._road_key]
+    frame_history = image_shape[1] // 6
+    queue_depth = self._frame_stride * (frame_history - 1) + 1
+    frame_queue_shape = (queue_depth, 6, image_shape[2], image_shape[3])
+
+    feature_shape = policy_shapes["features_buffer"]
+    desired_shape = policy_shapes[self._desired_key]
+    traffic_shape = policy_shapes["traffic_convention"]
+    action_shape = policy_shapes.get("action_t", traffic_shape)
+
+    numpy_state = {
+      "tfm": np.zeros((3, 3), dtype=np.float32),
+      "big_tfm": np.zeros((3, 3), dtype=np.float32),
+      "desire": np.zeros(desired_shape[2], dtype=np.float32),
+      "traffic_convention": np.zeros(traffic_shape, dtype=np.float32),
+      "action_t": np.zeros(action_shape, dtype=np.float32),
+    }
+    for key in self._extra_policy_keys:
+      numpy_state[key] = np.zeros(policy_shapes[key], dtype=np.float32)
+
+    queue_tensors = {
+      "img_q": Tensor(np.zeros(frame_queue_shape, dtype=np.uint8), device=Device.DEFAULT).contiguous().realize(),
+      "big_img_q": Tensor(np.zeros(frame_queue_shape, dtype=np.uint8), device=Device.DEFAULT).contiguous().realize(),
+      "feat_q": Tensor(
+        np.zeros((self._frame_stride * (feature_shape[1] - 1) + 1, feature_shape[0], feature_shape[2]), dtype=np.float32),
+        device=Device.DEFAULT,
+      ).contiguous().realize(),
+      "desire_q": Tensor(
+        np.zeros((self._frame_stride * desired_shape[1], desired_shape[0], desired_shape[2]), dtype=np.float32),
+        device=Device.DEFAULT,
+      ).contiguous().realize(),
+      **{name: Tensor(value, device="NPY").realize() for name, value in numpy_state.items()},
+    }
+
+    self._queue_tensors = queue_tensors
+    self._numpy_state = numpy_state
+    self._camera_shape = (camera_width, camera_height)
+
+  def _policy_inputs(self) -> dict[str, Any]:
+    assert self._queue_tensors is not None
+    tensor_names = ["feat_q", "desire_q", "desire", "traffic_convention", "action_t", *self._extra_policy_keys]
+    return {name: self._queue_tensors[name] for name in tensor_names if name in self._queue_tensors}
+
+  def _merge_policy_outputs(self, raw_outputs: tuple[Any, ...]) -> NumpyDict:
+    outputs = self._parser.parse_vision_outputs(
+      _slice_map(raw_outputs[0].numpy().flatten(), self._vision_meta["output_slices"])
+    )
+
+    has_on_policy = any(role == "on_policy" for role in self._policy_roles)
+    for role_name, tensor_out in zip(self._policy_roles, raw_outputs[1:], strict=True):
+      parsed = self._parser.parse_policy_outputs(
+        _slice_map(tensor_out.numpy().flatten(), self._meta_by_role[role_name]["output_slices"])
+      )
+      if role_name == "off_policy" and has_on_policy:
+        parsed.pop("plan", None)
+      outputs.update(parsed)
+
+    if "planplus" in outputs and "plan" in outputs:
+      outputs["plan"] = outputs["plan"] + outputs["planplus"]
+    return outputs
+
+  def run_fused(self, bufs: dict, transforms: dict[str, np.ndarray], numpy_inputs: NumpyDict) -> NumpyDict:
+    main_buf = bufs[self._road_key]
+    self._allocate_runtime_state(main_buf.width, main_buf.height)
+    assert self._queue_tensors is not None and self._numpy_state is not None and self._camera_shape is not None
+
+    self._numpy_state["tfm"][:] = transforms[self._road_key]
+    self._numpy_state["big_tfm"][:] = transforms[self._wide_key]
+
+    current_desire = numpy_inputs[self._desired_key].copy()
+    current_desire[0] = 0
+    self._numpy_state["desire"][:] = np.where(current_desire - self._last_desire > 0.99, current_desire, 0)
+    self._last_desire[:] = current_desire
+
+    if "traffic_convention" in numpy_inputs:
+      self._numpy_state["traffic_convention"][:] = numpy_inputs["traffic_convention"]
+    if "action_t" in numpy_inputs:
+      self._numpy_state["action_t"][:] = numpy_inputs["action_t"]
+    for key in self._extra_policy_keys:
+      if key in numpy_inputs:
+        self._numpy_state[key][:] = numpy_inputs[key]
+
+    stage_inputs = self._camera_programs[self._camera_shape].get("stage_inputs", self._camera_programs[self._camera_shape].get("warp_enqueue"))
+    if stage_inputs is None:
+      raise RuntimeError("Combined split artifact camera entry is missing stage_inputs")
+
+    staged_main, staged_wide = stage_inputs(
+      img_q=self._queue_tensors["img_q"],
+      big_img_q=self._queue_tensors["big_img_q"],
+      tfm=self._queue_tensors["tfm"],
+      big_tfm=self._queue_tensors["big_tfm"],
+      frame=self._frame_blob(self._road_key, bufs[self._road_key]),
+      big_frame=self._frame_blob(self._wide_key, bufs[self._wide_key]),
+    )
+    raw_outputs = self._execute_bundle(img=staged_main, big_img=staged_wide, **self._policy_inputs())
+    if not isinstance(raw_outputs, tuple):
+      raw_outputs = (raw_outputs,)
+    return self._merge_policy_outputs(raw_outputs)
+
+  def _run_model(self) -> NumpyDict:
+    raise RuntimeError("Combined split runner executes through run_fused()")

iqpilot/selfdrive/iqmodeld/models/runners/tinygrad/fused_runner.py

@@ -0,0 +1,178 @@
+"""
+Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos/
+"""
+from __future__ import annotations
+
+import os
+import pickle
+from typing import Any
+
+import numpy as np
+
+from iqpilot.selfdrive.iqmodeld.models.runners.model_runner import (
+    CUSTOM_MODEL_PATH, NumpyDict, ShapeDict, SliceDict,
+)
+from iqpilot.selfdrive.iqmodeld.models.runners.model_runner import ModelRunner
+from iqpilot.selfdrive.iqmodeld.models.split_model_constants import SplitModelConstants
+from iqpilot.selfdrive.iqmodeld.parser import PhaseParser
+
+
+def _tinygrad_imports():
+    from tinygrad.tensor import Tensor
+    from tinygrad.device import Device
+    return Tensor, Device
+
+
+WARP_DEV = os.getenv('WARP_DEV')
+
+
+class TinygradFusedRunner(ModelRunner):
+    uses_opencl_warp: bool = False
+
+    def __init__(self):
+        super().__init__()
+
+        self._constants = SplitModelConstants
+        self._parser = PhaseParser()
+
+        if len(self.models) != 1:
+            raise ValueError(f"fused bundle must have exactly one artifact, got {list(self.models)}")
+        self._model_data = next(iter(self.models.values()))
+
+        pkl_path = os.path.join(CUSTOM_MODEL_PATH, self._model_data.model.artifact.fileName)
+        with open(pkl_path, 'rb') as f:
+            self._fused: dict[Any, Any] = pickle.load(f)
+
+        self._vision_meta = self._fused['metadata']['vision']
+        self._on_meta = self._fused['metadata']['on_policy']
+        self._off_meta = self._fused['metadata']['off_policy']
+        self._run_policy = self._fused['run_policy']
+        self._warp_jits: dict[tuple[int, int], Any] = {k: v for k, v in self._fused.items() if isinstance(k, tuple)}
+        if not self._warp_jits:
+            raise ValueError("fused pkl has no warp JITs")
+
+        self._frame_skip: int = int(self._fused.get('frame_skip', 4))
+
+        self._queues: dict[str, Any] | None = None
+        self._npy_buffers: dict[str, np.ndarray] | None = None
+        self._cam_resolution: tuple[int, int] | None = None
+        self._blob_cache: dict[tuple[str, int], Any] = {}
+
+    def _frame_tensor(self, key, buf):
+        Tensor, Device = _tinygrad_imports()
+        arr = np.frombuffer(buf.data, dtype=np.uint8)
+        ck = (key, arr.ctypes.data)
+        t = self._blob_cache.get(ck)
+        if t is None:
+            t = Tensor.from_blob(arr.ctypes.data, (arr.size,), dtype='uint8', device=Device.DEFAULT)
+            self._blob_cache[ck] = t
+        return t
+
+    @property
+    def vision_input_names(self) -> list[str]:
+        return ['img', 'big_img']
+
+    @property
+    def input_shapes(self) -> ShapeDict:
+        return {**self._vision_meta['input_shapes'], **self._on_meta['input_shapes']}
+
+    @property
+    def output_slices(self) -> SliceDict:
+        merged: SliceDict = {}
+        for src in (self._vision_meta['output_slices'], self._on_meta['output_slices'], self._off_meta['output_slices']):
+            merged.update({k: v for k, v in src.items() if k != 'pad'})
+        return merged
+
+    def prepare_inputs(self, imgs_cl, numpy_inputs, frames):
+        raise RuntimeError("fused runner has no OpenCL path; use run_fused()")
+
+    def _ensure_queues(self, cam_w: int, cam_h: int) -> None:
+        if self._queues is not None and self._cam_resolution == (cam_w, cam_h):
+            return
+        if (cam_w, cam_h) not in self._warp_jits:
+            raise RuntimeError(f"no warp JIT for {cam_w}x{cam_h}; have {sorted(self._warp_jits)}")
+
+        Tensor, Device = _tinygrad_imports()
+        img_shape = self._vision_meta['input_shapes']['img']
+        fb = self._on_meta['input_shapes']['features_buffer']
+        dp = self._on_meta['input_shapes']['desire_pulse']
+        n_frames = img_shape[1] // 6
+        img_buf_shape = (self._frame_skip * (n_frames - 1) + 1, 6, img_shape[2], img_shape[3])
+
+        zeros_u8 = lambda shp: Tensor(np.zeros(shp, dtype=np.uint8), device=Device.DEFAULT).contiguous().realize()
+        zeros_f32 = lambda shp: Tensor(np.zeros(shp, dtype=np.float32), device=Device.DEFAULT).contiguous().realize()
+
+        self._queues = {
+            'img_q':     zeros_u8(img_buf_shape),
+            'big_img_q': zeros_u8(img_buf_shape),
+            'feat_q':    zeros_f32((self._frame_skip * (fb[1] - 1) + 1, fb[0], fb[2])),
+            'desire_q':  zeros_f32((self._frame_skip * dp[1], dp[0], dp[2])),
+        }
+        on_shapes = self._on_meta['input_shapes']
+        captured = self._run_policy.captured
+        jit_shapes = {
+            name: tuple(int(s) for s in view.shape)
+            for name, (view, _vars, _dtype, _device) in zip(captured.expected_names, captured.expected_input_info)
+        }
+
+        def policy_input_shape(name):
+            shape = on_shapes.get(name, jit_shapes.get(name))
+            if shape is None:
+                raise ValueError(f"fused pkl declares no shape for policy input {name}")
+            return shape
+
+        self._npy_buffers = {
+            'desire':             np.zeros(dp[2], dtype=np.float32),
+            'traffic_convention': np.zeros(policy_input_shape('traffic_convention'), dtype=np.float32),
+            'tfm':                np.zeros((3, 3), dtype=np.float32),
+            'big_tfm':            np.zeros((3, 3), dtype=np.float32),
+        }
+        if 'action_t' in jit_shapes:
+            self._npy_buffers['action_t'] = np.zeros(policy_input_shape('action_t'), dtype=np.float32)
+        self._cam_resolution = (cam_w, cam_h)
+
+    def run_fused(self, bufs: dict, transforms: dict[str, np.ndarray], numpy_inputs: NumpyDict) -> NumpyDict:
+        Tensor, Device = _tinygrad_imports()
+
+        main_buf = bufs['img']
+        self._ensure_queues(main_buf.width, main_buf.height)
+        assert self._queues is not None and self._npy_buffers is not None
+
+        desire_key = next((k for k in numpy_inputs if k.startswith('desire')), None)
+        if desire_key is not None:
+            self._npy_buffers['desire'][:] = numpy_inputs[desire_key]
+        if 'traffic_convention' in numpy_inputs:
+            self._npy_buffers['traffic_convention'][:] = numpy_inputs['traffic_convention']
+        if 'action_t' in numpy_inputs and 'action_t' in self._npy_buffers:
+            self._npy_buffers['action_t'][:] = numpy_inputs['action_t']
+        self._npy_buffers['tfm'][:] = transforms['img']
+        self._npy_buffers['big_tfm'][:] = transforms['big_img']
+
+        npy = lambda key: Tensor(self._npy_buffers[key], device='NPY')
+
+        frame = self._frame_tensor('img', bufs['img'])
+        big_frame = self._frame_tensor('big_img', bufs['big_img'])
+
+        warp_jit = self._warp_jits[self._cam_resolution]
+        img, big_img = warp_jit(img_q=self._queues['img_q'], big_img_q=self._queues['big_img_q'],
+                                tfm=npy('tfm'), big_tfm=npy('big_tfm'), frame=frame, big_frame=big_frame)
+
+        policy_inputs = dict(
+            img=img, big_img=big_img, feat_q=self._queues['feat_q'], desire_q=self._queues['desire_q'],
+            desire=npy('desire'), traffic_convention=npy('traffic_convention'))
+        if 'action_t' in self._npy_buffers:
+            policy_inputs['action_t'] = npy('action_t')
+        vision_out_t, on_out_t, off_out_t = self._run_policy(**policy_inputs)
+
+        def _slice(tensor_out, meta) -> NumpyDict:
+            flat = tensor_out.numpy().flatten()
+            return {k: flat[np.newaxis, sl] for k, sl in meta['output_slices'].items() if k != 'pad'}
+
+        parsed: NumpyDict = {}
+        parsed.update(self._parser.parse_vision_outputs(_slice(vision_out_t, self._vision_meta)))
+        parsed.update(self._parser.parse_policy_outputs(_slice(off_out_t, self._off_meta)))
+        parsed.update(self._parser.parse_policy_outputs(_slice(on_out_t, self._on_meta)))
+        return parsed
+
+    def _run_model(self) -> NumpyDict:
+        raise RuntimeError("fused path goes through run_fused(), not _run_model()")

iqpilot/selfdrive/iqmodeld/models/runners/tinygrad/model_types.py

@@ -0,0 +1,60 @@
+"""
+Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos/
+"""
+
+from __future__ import annotations
+
+from abc import ABC
+from collections.abc import Callable
+
+import numpy as np
+
+from iqpilot.selfdrive.iqmodeld.models.runners.model_runner import ModelType, NumpyDict
+from iqpilot.selfdrive.iqmodeld.models.runners.model_runner import RunnerRoot
+from iqpilot.selfdrive.iqmodeld.parser import ArchiveParser, PhaseParser
+
+
+class _ParserRole(RunnerRoot, ABC):
+  def _bind_parser_role(self,
+                        selector: int,
+                        parser_builder: Callable[[], object],
+                        projector: Callable[[object, NumpyDict], NumpyDict]) -> None:
+    parser = parser_builder()
+    self.parser_method_dict[selector] = lambda model_blob: projector(parser, self._slice_outputs(model_blob))
+
+
+def _phase_policy(parser: PhaseParser, sliced_outputs: NumpyDict) -> NumpyDict:
+  return parser.parse_policy_outputs(sliced_outputs)
+
+
+def _phase_vision(parser: PhaseParser, sliced_outputs: NumpyDict) -> NumpyDict:
+  return parser.parse_vision_outputs(sliced_outputs)
+
+
+def _archive_combined(parser: ArchiveParser, sliced_outputs: NumpyDict) -> NumpyDict:
+  return parser.parse_outputs(sliced_outputs)
+
+
+class OffPolicyTinygrad(_ParserRole, ABC):
+  def __init__(self):
+    self._bind_parser_role(ModelType.offPolicy, PhaseParser, _phase_policy)
+
+
+class OnPolicyTinygrad(_ParserRole, ABC):
+  def __init__(self):
+    self._bind_parser_role(ModelType.onPolicy, PhaseParser, _phase_policy)
+
+
+class PolicyTinygrad(_ParserRole, ABC):
+  def __init__(self):
+    self._bind_parser_role(ModelType.policy, PhaseParser, _phase_policy)
+
+
+class VisionTinygrad(_ParserRole, ABC):
+  def __init__(self):
+    self._bind_parser_role(ModelType.vision, PhaseParser, _phase_vision)
+
+
+class SupercomboTinygrad(_ParserRole, ABC):
+  def __init__(self):
+    self._bind_parser_role(ModelType.supercombo, ArchiveParser, _archive_combined)

iqpilot/selfdrive/iqmodeld/models/runners/tinygrad/supercombo_runner.py

@@ -0,0 +1,339 @@
+"""
+Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos/
+"""
+from __future__ import annotations
+
+import hashlib
+import math
+import os
+import pickle
+import re
+from typing import Any
+
+import numpy as np
+
+from iqpilot.common.params import Params
+from iqpilot.selfdrive.iqmodeld.models.runners.model_runner import CUSTOM_MODEL_PATH, NumpyDict, ShapeDict, SliceDict
+from iqpilot.selfdrive.iqmodeld.models.runners.model_runner import ModelRunner
+from iqpilot.selfdrive.iqmodeld.models.split_model_constants import SplitModelConstants
+from iqpilot.selfdrive.iqmodeld.parser import PhaseParser
+
+
+def _tinygrad_imports():
+    from tinygrad.tensor import Tensor
+    from tinygrad.device import Device
+    return Tensor, Device
+
+
+def _captured_queue_depth(warp_jit: Any) -> int | None:
+    captured = getattr(warp_jit, "captured", None)
+    infos = getattr(captured, "expected_input_info", None)
+    if not infos or len(infos) < 2:
+        return None
+
+    view_repr = repr(infos[1][0])
+    dims = [int(val) for val in re.findall(r"arg=(\d+)", view_repr)]
+    return dims[0] if len(dims) >= 4 else None
+
+
+def _captured_devices(warp_jit: Any) -> set[str]:
+    captured = getattr(warp_jit, "captured", None)
+    infos = getattr(captured, "expected_input_info", None)
+    if not infos:
+        return set()
+
+    devices: set[str] = set()
+    for info in infos:
+        if isinstance(info, tuple) and len(info) >= 4 and isinstance(info[3], str):
+            devices.add(info[3])
+    return devices
+
+
+def _captured_expected_names(jit_obj: Any) -> list[str]:
+    captured = getattr(jit_obj, "captured", None)
+    names = getattr(captured, "expected_names", None)
+    return list(names) if names else []
+
+
+def _file_sha256(path: str) -> str:
+    digest = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _is_jit_arg_mismatch(err: BaseException) -> bool:
+    return "args mismatch in JIT" in str(err)
+
+
+class TinygradSupercomboRunner(ModelRunner):
+    uses_opencl_warp: bool = False
+
+    def __init__(self):
+        super().__init__()
+        self._constants = SplitModelConstants
+        self._parser = PhaseParser()
+
+        if len(self.models) != 1:
+            raise ValueError(f"supercombo bundle must have exactly one artifact, got {list(self.models)}")
+        self._model_data = next(iter(self.models.values()))
+
+        pkl_path = os.path.join(CUSTOM_MODEL_PATH, self._model_data.model.artifact.fileName)
+        self._pkl_path = pkl_path
+        self._expected_sha256 = getattr(getattr(self._model_data.model.artifact, "downloadUri", None), "sha256", "") or ""
+        self._verify_artifact_file()
+        with open(pkl_path, 'rb') as f:
+            self._m: dict[Any, Any] = pickle.load(f)
+
+        self._meta = self._m['metadata']
+        self._ish = self._meta['input_shapes']
+        self._slices = {k: v for k, v in self._meta['output_slices'].items() if k != 'pad'}
+        self._hidden_slice = self._meta['output_slices']['hidden_state']
+        self._run_policy = self._m['run_policy']
+        self._warp_jits: dict[tuple[int, int], Any] = {k: v for k, v in self._m.items() if isinstance(k, tuple)}
+        if not self._warp_jits:
+            raise ValueError("supercombo pkl has no warp JITs")
+        self._frame_skip = int(self._m.get('frame_skip', 4))
+        self._validate_warp_jits(pkl_path)
+        self._validate_jit_names()
+
+        self._queues: dict[str, Any] | None = None
+        self._npy: dict[str, np.ndarray] | None = None
+        self._cam: tuple[int, int] | None = None
+        self._prev_desire = np.zeros(self._ish['desire_pulse'][2], dtype=np.float32)
+        self._blob_cache: dict[tuple[str, int], Any] = {}
+
+    def _verify_artifact_file(self) -> None:
+        if not self._expected_sha256:
+            return
+
+        actual_sha256 = _file_sha256(self._pkl_path)
+        if actual_sha256 == self._expected_sha256:
+            return
+
+        try:
+            os.remove(self._pkl_path)
+        except OSError:
+            pass
+        redownload_msg = self._schedule_active_bundle_redownload()
+
+        raise RuntimeError(
+            "supercombo artifact SHA mismatch: "
+            f"expected {self._expected_sha256}, got {actual_sha256} for {self._pkl_path}. "
+            f"Deleted the stale cached file{redownload_msg}."
+        )
+
+    def _validate_warp_jits(self, pkl_path: str) -> None:
+        img = self._ish['img']
+        n_frames = img[1] // 6
+        expected_depth = self._frame_skip * (n_frames - 1) + 1
+        expected_device = os.getenv('DEV')
+
+        mismatches: list[str] = []
+        for cam, warp_jit in sorted(self._warp_jits.items()):
+            captured_depth = _captured_queue_depth(warp_jit)
+            captured_devices = _captured_devices(warp_jit)
+            if captured_depth is not None and captured_depth != expected_depth:
+                mismatches.append(
+                    f"{cam[0]}x{cam[1]} queue-depth captured={captured_depth} expected={expected_depth}"
+                )
+            if expected_device and captured_devices and expected_device not in captured_devices:
+                mismatches.append(
+                    f"{cam[0]}x{cam[1]} device captured={sorted(captured_devices)} expected={expected_device}"
+                )
+
+        if mismatches:
+            details = "; ".join(mismatches)
+            raise RuntimeError(
+                "supercombo warp JIT compatibility mismatch: "
+                f"{details}. Bundle {pkl_path} was compiled with the wrong backend, frame_skip, or queue shape; "
+                "re-download or rebuild this model artifact."
+            )
+
+    def _validate_jit_names(self) -> None:
+        expected_warp_names = ['big_frame', 'big_tfm', 'frame', 'tfm']
+        expected_policy_names = ['big_img_q', 'desire_q', 'feat_q', 'img_q', 'packed_npy_inputs', 'warped']
+
+        mismatches: list[str] = []
+
+        policy_names = sorted(_captured_expected_names(self._run_policy))
+        if policy_names and policy_names != expected_policy_names:
+            mismatches.append(f"run_policy captured={policy_names} expected={expected_policy_names}")
+
+        for cam, warp_jit in sorted(self._warp_jits.items()):
+            warp_names = sorted(_captured_expected_names(warp_jit))
+            if warp_names and warp_names != expected_warp_names:
+                mismatches.append(f"{cam[0]}x{cam[1]} warp captured={warp_names} expected={expected_warp_names}")
+
+        if mismatches:
+            details = "; ".join(mismatches)
+            actual_sha = None
+            try:
+                actual_sha = _file_sha256(self._pkl_path)
+            except OSError:
+                pass
+
+            if actual_sha and self._expected_sha256 and actual_sha != self._expected_sha256:
+                try:
+                    os.remove(self._pkl_path)
+                except OSError:
+                    pass
+                redownload_msg = self._schedule_active_bundle_redownload()
+                raise RuntimeError(
+                    "supercombo artifact contract mismatch with stale cached SHA: "
+                    f"{details}. Expected SHA {self._expected_sha256}, got {actual_sha}. "
+                    f"Deleted the stale cached file{redownload_msg}."
+                )
+
+            raise RuntimeError(
+                "supercombo artifact JIT argument mismatch: "
+                f"{details}. This model file does not match the current IQPilot runtime contract. "
+                "Re-download or rebuild this model artifact."
+            )
+
+    def _handle_runtime_jit_mismatch(self, err: BaseException) -> None:
+        if not _is_jit_arg_mismatch(err):
+            raise err
+
+        actual_sha = None
+        try:
+            actual_sha = _file_sha256(self._pkl_path)
+        except OSError:
+            pass
+
+        if actual_sha and self._expected_sha256 and actual_sha != self._expected_sha256:
+            try:
+                os.remove(self._pkl_path)
+            except OSError:
+                pass
+            redownload_msg = self._schedule_active_bundle_redownload()
+            raise RuntimeError(
+                "supercombo artifact runtime JIT mismatch with stale cached SHA: "
+                f"expected {self._expected_sha256}, got {actual_sha} for {self._pkl_path}. "
+                f"Deleted the stale cached file{redownload_msg}."
+            ) from err
+
+        raise RuntimeError(
+            "supercombo artifact runtime JIT mismatch: "
+            f"{err}. This model file does not match the current IQPilot runtime contract. "
+            "Re-download or rebuild this model artifact."
+        ) from err
+
+    def _schedule_active_bundle_redownload(self) -> str:
+        try:
+            params = Params()
+            active_bundle = params.get("ModelManager_ActiveBundle") or {}
+            index = active_bundle.get("index") if isinstance(active_bundle, dict) else None
+            if isinstance(index, str) and index.isdigit():
+                index = int(index)
+            if isinstance(index, int) and index >= 0:
+                params.put("ModelManager_DownloadIndex", str(index))
+                params.remove("ModelRunnerTypeCache")
+                return "; scheduled automatic re-download of the active model"
+        except Exception:
+            pass
+
+        return "; unable to schedule automatic re-download"
+
+    def _frame_tensor(self, key: str, buf):
+        Tensor, Device = _tinygrad_imports()
+        arr = np.frombuffer(buf.data, dtype=np.uint8)
+        ck = (key, arr.ctypes.data)
+        t = self._blob_cache.get(ck)
+        if t is None:
+            t = Tensor.from_blob(arr.ctypes.data, (arr.size,), dtype='uint8', device=Device.DEFAULT)
+            self._blob_cache[ck] = t
+        return t
+
+    @property
+    def vision_input_names(self) -> list[str]:
+        return ['img', 'big_img']
+
+    @property
+    def input_shapes(self) -> ShapeDict:
+        return dict(self._ish)
+
+    @property
+    def output_slices(self) -> SliceDict:
+        return dict(self._slices)
+
+    def prepare_inputs(self, imgs_cl, numpy_inputs, frames):
+        raise RuntimeError("supercombo runner has no OpenCL path; use run_fused()")
+
+    def _ensure_queues(self, cam_w: int, cam_h: int) -> None:
+        if self._queues is not None and self._cam == (cam_w, cam_h):
+            return
+        if (cam_w, cam_h) not in self._warp_jits:
+            raise RuntimeError(f"no warp JIT for {cam_w}x{cam_h}; have {sorted(self._warp_jits)}")
+
+        Tensor, Device = _tinygrad_imports()
+        fs = self._frame_skip
+        img = self._ish['img']
+        n_frames = img[1] // 6
+        img_buf = (fs * (n_frames - 1) + 1, 6, img[2], img[3])
+        fb = self._ish['features_buffer']
+        dp = self._ish['desire_pulse']
+        tc = self._ish['traffic_convention']
+        at = self._ish['action_t']
+
+        zeros_u8 = lambda s: Tensor(np.zeros(s, dtype=np.uint8), device=Device.DEFAULT).contiguous().realize()
+        zeros_f32 = lambda s: Tensor(np.zeros(s, dtype=np.float32), device=Device.DEFAULT).contiguous().realize()
+
+        shapes = {'desire': (dp[2],), 'traffic_convention': tuple(tc), 'action_t': tuple(at), 'prev_feat': (fb[0], fb[2])}
+        sizes = [math.prod(s) for s in shapes.values()]
+        packed = np.zeros(sum(sizes), dtype=np.float32)
+        views = {k: v.reshape(s) for (k, s), v in zip(shapes.items(), np.split(packed, np.cumsum(sizes[:-1])), strict=True)}
+
+        self._npy = {'tfm': np.zeros((3, 3), dtype=np.float32), 'big_tfm': np.zeros((3, 3), dtype=np.float32), **views}
+        self._queues = {
+            'img_q':     zeros_u8(img_buf),
+            'big_img_q': zeros_u8(img_buf),
+            'feat_q':    zeros_f32((fs * fb[1], fb[0], fb[2])),
+            'desire_q':  zeros_f32((fs * dp[1], dp[0], dp[2])),
+            'tfm':       Tensor(self._npy['tfm'], device='NPY'),
+            'big_tfm':   Tensor(self._npy['big_tfm'], device='NPY'),
+            'packed_npy_inputs': Tensor(packed, device='NPY'),
+        }
+        self._cam = (cam_w, cam_h)
+
+    def run_fused(self, bufs: dict, transforms: dict[str, np.ndarray], numpy_inputs: NumpyDict) -> NumpyDict:
+        Tensor, Device = _tinygrad_imports()
+        main_buf = bufs['img']
+        self._ensure_queues(main_buf.width, main_buf.height)
+        assert self._queues is not None and self._npy is not None
+
+        self._npy['tfm'][:] = transforms['img']
+        self._npy['big_tfm'][:] = transforms['big_img']
+
+        desire_key = next((k for k in numpy_inputs if k.startswith('desire')), None)
+        cur = numpy_inputs[desire_key].copy() if desire_key is not None else np.zeros_like(self._prev_desire)
+        cur[0] = 0
+        self._npy['desire'][:] = np.where(cur - self._prev_desire > .99, cur, 0)
+        self._prev_desire[:] = cur
+        if 'traffic_convention' in numpy_inputs:
+            self._npy['traffic_convention'][:] = numpy_inputs['traffic_convention']
+        if 'action_t' in numpy_inputs:
+            self._npy['action_t'][:] = numpy_inputs['action_t']
+
+        frame = self._frame_tensor('img', bufs['img'])
+        big_frame = self._frame_tensor('big_img', bufs['big_img'])
+
+        warp = self._warp_jits[self._cam]
+        try:
+            warped = warp(tfm=self._queues['tfm'], big_tfm=self._queues['big_tfm'], frame=frame, big_frame=big_frame)
+            out, = self._run_policy(warped=warped, img_q=self._queues['img_q'], big_img_q=self._queues['big_img_q'],
+                                    feat_q=self._queues['feat_q'], desire_q=self._queues['desire_q'],
+                                    packed_npy_inputs=self._queues['packed_npy_inputs'])
+        except Exception as err:
+            self._handle_runtime_jit_mismatch(err)
+            raise
+        flat = out.numpy().flatten()
+
+        self._npy['prev_feat'][:] = flat[self._hidden_slice].reshape(self._npy['prev_feat'].shape)
+
+        sliced = {k: flat[np.newaxis, sl] for k, sl in self._slices.items()}
+        return self._parser.parse_vision_outputs(sliced)
+
+    def _run_model(self) -> NumpyDict:
+        raise RuntimeError("supercombo path goes through run_fused(), not _run_model()")

iqpilot/selfdrive/iqmodeld/models/runners/tinygrad/tinygrad_runner.py

@@ -0,0 +1,190 @@
+"""
+Copyright © IQ.Lvbs, apart of Project Teal Lvbs, All Rights Reserved, licensed under https://konn3kt.com/tos/
+"""
+
+from __future__ import annotations
+
+import pickle
+from dataclasses import dataclass
+
+import numpy as np
+from tinygrad.dtype import dtypes
+from tinygrad.tensor import Tensor
+
+from iqpilot.selfdrive.iqmodeld.models.runners.model_runner import (
+  CLMemDict,
+  CUSTOM_MODEL_PATH,
+  FrameDict,
+  ModelType,
+  NumpyDict,
+  ShapeDict,
+  SliceDict,
+)
+from iqpilot.selfdrive.iqmodeld.models.runners.model_runner import ModelRunner
+from iqpilot.selfdrive.iqmodeld.models.runners.tinygrad.model_types import (
+  OffPolicyTinygrad,
+  OnPolicyTinygrad,
+  PolicyTinygrad,
+  SupercomboTinygrad,
+  VisionTinygrad,
+)
+from iqpilot.selfdrive.iqmodeld.models.split_model_constants import SplitModelConstants
+from iqpilot.selfdrive.iqmodeld.config import ModelConstants
+from iqpilot.selfdrive.iqmodeld.runtime.tinygrad import qcom_tensor_from_opencl_address
+from iqpilot.system.hardware import TICI
+
+
+@dataclass(frozen=True)
+class _TensorShapePlan:
+  dtype: object
+  device: str
+
+
+def _artifact_path(filename: str) -> str:
+  return f"{CUSTOM_MODEL_PATH}/{filename}"
+
+
+def _load_program_blob(filename: str):
+  with open(_artifact_path(filename), "rb") as artifact:
+    try:
+      return pickle.load(artifact)
+    except FileNotFoundError as exc:
+      assert "/dev/kgsl-3d0" not in str(exc), "Model was built on C3 or C3X, but is being loaded on PC"
+      raise
+
+
+def _compile_input_plan(captured) -> dict[str, _TensorShapePlan]:
+  plan: dict[str, _TensorShapePlan] = {}
+  for name, info in zip(captured.expected_names, captured.expected_input_info, strict=True):
+    plan[name] = _TensorShapePlan(dtype=info[2], device=info[3])
+  return plan
+
+
+def _merge_step_outputs(output_groups: list[NumpyDict]) -> NumpyDict:
+  stitched: NumpyDict = {}
+  for payload in output_groups:
+    stitched.update(payload)
+  if "planplus" in stitched and "plan" in stitched:
+    stitched["plan"] = stitched["plan"] + stitched["planplus"]
+  return stitched
+
+
+class TinygradRunner(ModelRunner, SupercomboTinygrad, PolicyTinygrad, VisionTinygrad, OffPolicyTinygrad, OnPolicyTinygrad):
+  def __init__(self, model_type: int = ModelType.supercombo):
+    ModelRunner.__init__(self)
+    for initializer in (SupercomboTinygrad, PolicyTinygrad, VisionTinygrad, OffPolicyTinygrad, OnPolicyTinygrad):
+      initializer.__init__(self)
+
+    self._constants = ModelConstants
+    self._model_data = self.models.get(model_type)
+    if self._model_data is None or self._model_data.model is None:
+      raise ValueError(f"Model data for type {model_type} not available.")
+
+    asset_name = self._model_data.model.artifact.fileName
+    assert asset_name.endswith("_tinygrad.pkl"), f"Invalid model file {asset_name} for TinygradRunner"
+
+    self.model_run = _load_program_blob(asset_name)
+    self._input_plan = _compile_input_plan(self.model_run.captured)
+    for name, spec in self._input_plan.items():
+      if "img" in name and spec.dtype is not dtypes.uint8:
+        raise ValueError(f"{asset_name}: image input {name} expects {spec.dtype}, incompatible with uint8 warp buffer")
+    self.input_to_dtype = {name: spec.dtype for name, spec in self._input_plan.items()}
+    self.input_to_device = {name: spec.device for name, spec in self._input_plan.items()}
+
+  @property
+  def vision_input_names(self) -> list[str]:
+    return [stream_name for stream_name in self.input_shapes if "img" in stream_name]
+
+  def _attach_vision_tensor(self, stream_name: str, frame_buffers: CLMemDict, frame_views: FrameDict) -> None:
+    spec = self._input_plan[stream_name]
+    frame_buffer = frame_buffers[stream_name]
+    if TICI:
+      self.inputs[stream_name] = qcom_tensor_from_opencl_address(frame_buffer.mem_address,
+                                                                 self.input_shapes[stream_name],
+                                                                 dtype=spec.dtype)
+      return
+
+    mirrored = frame_views[stream_name].as_numpy(frame_buffer).reshape(self.input_shapes[stream_name])
+    self.inputs[stream_name] = Tensor(mirrored, device=spec.device, dtype=spec.dtype).realize()
+
+  def _attach_state_tensor(self, tensor_name: str, tensor_value: np.ndarray) -> None:
+    spec = self._input_plan[tensor_name]
+    self.inputs[tensor_name] = Tensor(tensor_value, device=spec.device, dtype=spec.dtype).realize()
+
+  def prepare_vision_inputs(self, imgs_cl: CLMemDict, frames: FrameDict):
+    for stream_name in imgs_cl:
+      if stream_name not in self.inputs or not TICI:
+        self._attach_vision_tensor(stream_name, imgs_cl, frames)
+
+  def prepare_policy_inputs(self, numpy_inputs: NumpyDict):
+    for tensor_name, tensor_value in numpy_inputs.items():
+      self._attach_state_tensor(tensor_name, tensor_value)
+
+  def prepare_inputs(self, imgs_cl: CLMemDict, numpy_inputs: NumpyDict, frames: FrameDict) -> dict:
+    self.prepare_vision_inputs(imgs_cl, frames)
+    self.prepare_policy_inputs(numpy_inputs)
+    return self.inputs
+
+  def _parse_outputs(self, model_outputs: np.ndarray) -> NumpyDict:
+    if self._model_data is None:
+      raise ValueError("Model data is not available. Ensure the model is loaded correctly.")
+    return self.parser_method_dict[self._model_data.model.type.raw](model_outputs)
+
+  def _run_model(self) -> NumpyDict:
+    raw_output = self.model_run(**self.inputs).numpy().reshape(-1)
+    return self._parse_outputs(raw_output)
+
+
+class TinygradSplitRunner(ModelRunner):
+  def __init__(self):
+    super().__init__()
+    self.is_20hz_3d = True
+    self._constants = SplitModelConstants
+    self.vision_runner = TinygradRunner(ModelType.vision)
+    self.policy_runner = TinygradRunner(ModelType.policy) if self.models.get(ModelType.policy) else None
+    self.off_policy_runner = TinygradRunner(ModelType.offPolicy) if self.models.get(ModelType.offPolicy) else None
+    self.on_policy_runner = TinygradRunner(ModelType.onPolicy) if self.models.get(ModelType.onPolicy) else None
+
+  def _policy_units(self) -> list[TinygradRunner]:
+    return [runner for runner in (self.policy_runner, self.off_policy_runner, self.on_policy_runner) if runner is not None]
+
+  def run_vision(self) -> NumpyDict:
+    return self.vision_runner.run_model()
+
+  def run_policy(self) -> NumpyDict:
+    return _merge_step_outputs([runner.run_model() for runner in self._policy_units()])
+
+  def refresh_policy_features(self, features_buffer: np.ndarray) -> None:
+    for runner in self._policy_units():
+      if "features_buffer" in runner._input_plan:
+        runner._attach_state_tensor("features_buffer", features_buffer)
+
+  def _run_model(self) -> NumpyDict:
+    return _merge_step_outputs([self.run_vision(), self.run_policy()])
+
+  @property
+  def vision_input_names(self) -> list[str]:
+    return list(self.vision_runner.vision_input_names)
+
+  @property
+  def input_shapes(self) -> ShapeDict:
+    composite: ShapeDict = dict(self.vision_runner.input_shapes)
+    for runner in self._policy_units():
+      composite.update(runner.input_shapes)
+    return composite
+
+  @property
+  def output_slices(self) -> SliceDict:
+    composite: SliceDict = dict(self.vision_runner.output_slices)
+    for runner in self._policy_units():
+      composite.update(runner.output_slices)
+    return composite
+
+  def prepare_inputs(self, imgs_cl: CLMemDict, numpy_inputs: NumpyDict, frames: FrameDict) -> dict:
+    self.vision_runner.prepare_vision_inputs(imgs_cl, frames)
+    assembled_inputs = dict(self.vision_runner.inputs)
+    for runner in self._policy_units():
+      runner.prepare_policy_inputs(numpy_inputs)
+      assembled_inputs.update(runner.inputs)
+    self.inputs = assembled_inputs
+    return assembled_inputs