Submitting Artifacts

Read this before you start training

Two constraints on this page affect architectural decisions: fixed model interface, and the operator restriction. Both are far cheaper to design around than to retrofit. A model that cannot be exported cleanly will score poorly on latency for reasons that have nothing to do with its quality.

What you submit

A single archive named TEAMNAME_headpose.zip as a Google drive link, no larger than 500 MB, containing:

TEAMNAME_headpose/

├── model_fp32.onnx        required

├── model_int8.onnx        optional, quantised variant

├── run_inference.py       required

├── requirements.txt       required, versions pinned

├── model_card.md          required

├── README.md              required

└── weights/               optional, original PyTorch or TensorFlow files

Model format and interface

ONNX is strongly preferred. PyTorch and TensorFlow are accepted, but ONNX is the format deployed to the evaluation targets. 

Quaternion order is scalar-first. Both the input stream and your expected output use (w, x, y, z). If your training pipeline uses the scalar-last (x, y, z, w) convention — which several common libraries do — reorder at the model boundary before export.

Shorter context is allowed. The harness always feeds 400 samples. If your model uses fewer, accept the full tensor and slice internally. Doing less work per step is rewarded through the latency criterion.

Operator constraints

You will not be able to profile the target hardware, so the rules are published instead. Stay inside this set and your graph maps to processors found in common XR platforms (e.g., the Qualcomm NPU); step outside it and operators fall back to CPU, which typically costs an order of magnitude in latency.

Safe: Conv1d and Conv2d including depthwise and dilated variants, MatMul, Gemm, LayerNorm, BatchNorm, ReLU, ReLU6, HardSwish, GELU, Sigmoid, Tanh, Add, Mul, Concat, Slice, Reshape, Transpose, GlobalAveragePool.

Avoid: dynamic control flow (Loop, If, Scan), NonZero, TopK, custom operators, einsum with more than three operands, float64 anywhere, sequence types, and unrolled recurrences deeper than roughly 64 steps.

Export with care: attention is fine when it appears as plain MatMul, Softmax, MatMul. Fused scaled-dot-product attention operators may not be supported — export unfused. Trigonometric and arccos-style operations are supported but are often slow on NPUs; if your head computes an exponential map or similar, consider where that work belongs.

Recurrent, state-space, and cache-based models may carry hidden state between streaming steps. Expose it as additional named inputs and outputs on the same graph:

• Inputs: context, then state_in_0, state_in_1, … state_in_k

• Outputs: prediction, then state_out_0, state_out_1, … state_out_k

All state tensors must be static-shaped float32. The evaluation harness zero-initialises every state tensor at the start of a session, feeds the stream one sample at a time, and pipes each state_out_i into the corresponding state_in_i on the following step.

Declare every state tensor, its shape, and its meaning in model_card.md. A model that declares no state is treated as stateless and re-executed on each shifted window.

State must derive only from past samples. Carrying information across session boundaries is a causality violation.

run_inference.py

Must run on a clean Linux machine with CUDA after nothing more than pip install -r requirements.txt, and must expose exactly these two functions:

def load_model(model_dir: str) -> object:

    """Load and return the model from the given directory."""

def predict(model, context: "np.ndarray") -> "np.ndarray":

    """context: float32 array of shape [400, 4], quaternions ordered (w, x, y, z)

       returns:  float32 array of shape [20, 4],  same ordering"""

It must also run standalone, so the organisers can smoke-test it before deployment:

python run_inference.py --model_dir . --input sample.npy --output pred.npy

No network access at inference time. Nothing may be downloaded at runtime — all weights, configuration, and vocabulary ship inside the archive. A model that fetches weights from a hub on first call will fail validation.

model_card.md

A short structured document covering:

• Architecture — family and a one-paragraph description

• Total trainable parameters — this is evaluation criterion 2, and is verified against the delivered artefact

• MACs per streaming step — see next section

• Actual context length used, if fewer than 400 samples

• State tensors — names, shapes, and meaning, or an explicit statement that the model is stateless

• Quantisation, pruning, or distillation applied, and which file each applies to

• Training data — how you filtered and preprocessed BOXRR-23, and any augmentation

• Known failure modes — where the model is weakest

Reporting arithmetic cost

Since you cannot measure latency on the target, report MACs per streaming step: the multiply-accumulate cost of producing one set of 20 predictions after one new sample arrives.

For a stateless model this is the cost of a full 400-sample forward pass. For a stateful model it is typically far lower, because only the new sample is processed. That difference is precisely what the latency criterion rewards.

Compute it with a standard profiling tool or by hand, state it in both model_card.md and your paper, and show your working.

MACs are a proxy, not the score. Measured wall-clock latency on the target is what counts. Memory-bound models, and models with poor operator mapping, will time worse than their MAC count suggests — which is why Section 4 matters at least as much as raw arithmetic reduction.

Validity checks

A submission is rejected if it:

• Produces non-finite output on any evaluation window

• Violates causality, or uses more than 400 samples of context

• Emits a tensor of any shape other than [1, 20, 4]

• Fails to load in a clean environment from requirements.txt

• Requires network access at inference time

• Arrives without a paper, or without model_card.md

• Predictions are re-normalised to unit norm before scoring, so you need not normalise your output — but it must be finite.