emx-onnx-cgen 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

emx_onnx_cgen/runtime/evaluator.py

@@ -10,6 +10,7 @@ from ..errors import ShapeInferenceError, UnsupportedOpError
 from ..ir.model import Graph, Node
 from ..lowering.attention import resolve_attention_spec
 from ..lowering.average_pool import lower_average_pool, lower_global_average_pool
+from ..lowering.adagrad import lower_adagrad
 from ..lowering.batch_normalization import lower_batch_normalization
 from ..lowering.concat import lower_concat
 from ..lowering.constant_of_shape import lower_constant_of_shape
@@ -28,6 +29,7 @@ from ..lowering.grid_sample import lower_grid_sample
 from ..lowering.instance_normalization import lower_instance_normalization
 from ..lowering.group_normalization import lower_group_normalization
 from ..lowering.layer_normalization import lower_layer_normalization
+from ..lowering.non_max_suppression import lower_non_max_suppression
 from ..lowering.mean_variance_normalization import (
     lower_mean_variance_normalization,
 )
@@ -49,6 +51,7 @@ from ..lowering.topk import lower_topk
 from ..lowering.lstm import ACTIVATION_KIND_BY_NAME, resolve_lstm_spec
 from ..lowering.lrn import resolve_lrn_spec
 from ..lowering.matmul import lower_matmul
+from ..lowering.qlinear_matmul import lower_qlinear_matmul
 from ..lowering.maxpool import resolve_maxpool_spec
 from ..lowering.reduce import (
     REDUCE_KIND_BY_OP,
@@ -58,11 +61,13 @@ from ..lowering.reduce import (
 )
 from ..lowering.reshape import lower_reshape
 from ..lowering.scatter_nd import lower_scatternd
+from ..lowering.tensor_scatter import lower_tensor_scatter
 from ..lowering.slice import _normalize_slices
 from ..lowering.shape import lower_shape
 from ..lowering.size import lower_size
 from ..lowering.softmax import lower_softmax
 from ..lowering.rms_normalization import lower_rms_normalization
+from ..lowering.rotary_embedding import lower_rotary_embedding
 from ..lowering.squeeze import lower_squeeze
 from ..lowering.transpose import lower_transpose
 from ..lowering.unsqueeze import lower_unsqueeze
@@ -158,6 +163,37 @@ def _eval_einsum(evaluator: Evaluator, node: Node) -> None:
     evaluator.values[node.outputs[0]] = np.einsum(equation, *inputs)
 
 
+@register_evaluator("Adagrad")
+def _eval_adagrad(evaluator: Evaluator, node: Node) -> None:
+    op = lower_adagrad(evaluator.graph, node)
+    rate = evaluator.values[op.rate]
+    timestep = evaluator.values[op.timestep]
+    rate_value = (
+        np.array(rate, dtype=op.dtype.np_dtype).reshape(-1)[0].item()
+    )
+    timestep_value = (
+        np.array(timestep, dtype=np.int64).reshape(-1)[0].item()
+    )
+    r = op.dtype.np_dtype.type(
+        rate_value / (1.0 + float(timestep_value) * op.decay_factor)
+    )
+    for x_name, g_name, h_name, out_name, h_out_name in zip(
+        op.inputs,
+        op.gradients,
+        op.accumulators,
+        op.outputs,
+        op.accumulator_outputs,
+    ):
+        x = evaluator.values[x_name]
+        g = evaluator.values[g_name]
+        h = evaluator.values[h_name]
+        g_regularized = op.norm_coefficient * x + g
+        h_new = h + g_regularized * g_regularized
+        h_adaptive = np.sqrt(h_new) + op.epsilon
+        evaluator.values[out_name] = x - r * g_regularized / h_adaptive
+        evaluator.values[h_out_name] = h_new
+
+
 @register_evaluator("Clip")
 def _eval_clip(evaluator: Evaluator, node: Node) -> None:
     if not node.inputs or len(node.outputs) != 1:
@@ -188,6 +224,79 @@ def _eval_clip(evaluator: Evaluator, node: Node) -> None:
     evaluator.values[node.outputs[0]] = np.clip(x, min_val, max_val)
 
 
+def _max_min(lhs: float, rhs: float) -> tuple[float, float]:
+    if lhs >= rhs:
+        return rhs, lhs
+    return lhs, rhs
+
+
+def _suppress_by_iou(
+    boxes: np.ndarray,
+    box_index1: int,
+    box_index2: int,
+    *,
+    center_point_box: int,
+    iou_threshold: float,
+) -> bool:
+    box1 = boxes[box_index1]
+    box2 = boxes[box_index2]
+    if center_point_box == 0:
+        x1_min, x1_max = _max_min(float(box1[1]), float(box1[3]))
+        x2_min, x2_max = _max_min(float(box2[1]), float(box2[3]))
+        intersection_x_min = max(x1_min, x2_min)
+        intersection_x_max = min(x1_max, x2_max)
+        if intersection_x_max <= intersection_x_min:
+            return False
+
+        y1_min, y1_max = _max_min(float(box1[0]), float(box1[2]))
+        y2_min, y2_max = _max_min(float(box2[0]), float(box2[2]))
+        intersection_y_min = max(y1_min, y2_min)
+        intersection_y_max = min(y1_max, y2_max)
+        if intersection_y_max <= intersection_y_min:
+            return False
+    else:
+        box1_width_half = float(box1[2]) / 2.0
+        box1_height_half = float(box1[3]) / 2.0
+        box2_width_half = float(box2[2]) / 2.0
+        box2_height_half = float(box2[3]) / 2.0
+
+        x1_min = float(box1[0]) - box1_width_half
+        x1_max = float(box1[0]) + box1_width_half
+        x2_min = float(box2[0]) - box2_width_half
+        x2_max = float(box2[0]) + box2_width_half
+
+        y1_min = float(box1[1]) - box1_height_half
+        y1_max = float(box1[1]) + box1_height_half
+        y2_min = float(box2[1]) - box2_height_half
+        y2_max = float(box2[1]) + box2_height_half
+
+        intersection_x_min = max(x1_min, x2_min)
+        intersection_x_max = min(x1_max, x2_max)
+        if intersection_x_max <= intersection_x_min:
+            return False
+
+        intersection_y_min = max(y1_min, y2_min)
+        intersection_y_max = min(y1_max, y2_max)
+        if intersection_y_max <= intersection_y_min:
+            return False
+
+    intersection_area = (intersection_x_max - intersection_x_min) * (
+        intersection_y_max - intersection_y_min
+    )
+    if intersection_area <= 0:
+        return False
+
+    area1 = (x1_max - x1_min) * (y1_max - y1_min)
+    area2 = (x2_max - x2_min) * (y2_max - y2_min)
+    union_area = area1 + area2 - intersection_area
+
+    if area1 <= 0 or area2 <= 0 or union_area <= 0:
+        return False
+
+    intersection_over_union = intersection_area / union_area
+    return intersection_over_union > iou_threshold
+
+
 def _exclusive_cumsum(data: np.ndarray, axis: int) -> np.ndarray:
     result = np.zeros_like(data)
     if data.shape[axis] == 0:
@@ -222,6 +331,100 @@ def _eval_cumsum(evaluator: Evaluator, node: Node) -> None:
     evaluator.values[op.output] = result
 
 
+@register_evaluator("NonMaxSuppression")
+def _eval_nonmax_suppression(evaluator: Evaluator, node: Node) -> None:
+    op = lower_non_max_suppression(evaluator.graph, node)
+    boxes = evaluator.values[op.boxes]
+    scores = evaluator.values[op.scores]
+
+    max_output_boxes_per_class = 0
+    if op.max_output_boxes_per_class is not None:
+        max_output_values = evaluator.values[
+            op.max_output_boxes_per_class
+        ].astype(np.int64, copy=False)
+        max_output_values = max_output_values.reshape(-1)
+        if max_output_values.size != 1:
+            raise UnsupportedOpError(
+                "NonMaxSuppression max_output_boxes_per_class must be scalar"
+            )
+        max_output_boxes_per_class = max(int(max_output_values[0]), 0)
+
+    iou_threshold = 0.0
+    if op.iou_threshold is not None:
+        iou_values = evaluator.values[op.iou_threshold].reshape(-1)
+        if iou_values.size != 1:
+            raise UnsupportedOpError(
+                "NonMaxSuppression iou_threshold must be scalar"
+            )
+        iou_threshold = float(iou_values[0])
+
+    score_threshold = 0.0
+    score_threshold_enabled = op.score_threshold is not None
+    if op.score_threshold is not None:
+        score_values = evaluator.values[op.score_threshold].reshape(-1)
+        if score_values.size != 1:
+            raise UnsupportedOpError(
+                "NonMaxSuppression score_threshold must be scalar"
+            )
+        score_threshold = float(score_values[0])
+
+    if max_output_boxes_per_class == 0:
+        evaluator.values[op.output] = np.empty((0, 3), dtype=np.int64)
+        return
+
+    num_batches = boxes.shape[0]
+    num_boxes = boxes.shape[1]
+    num_classes = scores.shape[1]
+
+    selected_indices: list[tuple[int, int, int]] = []
+    for batch_index in range(num_batches):
+        batch_boxes = boxes[batch_index]
+        for class_index in range(num_classes):
+            class_scores = scores[batch_index, class_index]
+            candidates: list[tuple[float, int]] = []
+            if score_threshold_enabled:
+                for box_index in range(num_boxes):
+                    score = float(class_scores[box_index])
+                    if score > score_threshold:
+                        candidates.append((score, box_index))
+            else:
+                for box_index in range(num_boxes):
+                    candidates.append(
+                        (float(class_scores[box_index]), box_index)
+                    )
+            candidates.sort(key=lambda item: (item[0], -item[1]))
+            selected_boxes: list[int] = []
+            while (
+                candidates
+                and len(selected_boxes) < max_output_boxes_per_class
+            ):
+                _, box_index = candidates.pop()
+                if any(
+                    _suppress_by_iou(
+                        batch_boxes,
+                        box_index,
+                        selected_index,
+                        center_point_box=op.center_point_box,
+                        iou_threshold=iou_threshold,
+                    )
+                    for selected_index in selected_boxes
+                ):
+                    continue
+                selected_boxes.append(box_index)
+                selected_indices.append(
+                    (batch_index, class_index, box_index)
+                )
+
+    result = np.empty((len(selected_indices), 3), dtype=np.int64)
+    for idx, (batch_index, class_index, box_index) in enumerate(
+        selected_indices
+    ):
+        result[idx, 0] = batch_index
+        result[idx, 1] = class_index
+        result[idx, 2] = box_index
+    evaluator.values[op.output] = result
+
+
 @register_evaluator("Pad")
 def _eval_pad(evaluator: Evaluator, node: Node) -> None:
     op = lower_pad(evaluator.graph, node)
@@ -343,6 +546,35 @@ def _eval_scatternd(evaluator: Evaluator, node: Node) -> None:
     evaluator.values[op.output] = output
 
 
+@register_evaluator("TensorScatter")
+def _eval_tensor_scatter(evaluator: Evaluator, node: Node) -> None:
+    op = lower_tensor_scatter(evaluator.graph, node)
+    past_cache = evaluator.values[op.past_cache]
+    update = evaluator.values[op.update]
+    if op.write_indices is None:
+        write_indices = np.zeros((past_cache.shape[0],), dtype=np.int64)
+    else:
+        write_indices = evaluator.values[op.write_indices].astype(
+            np.int64, copy=False
+        )
+    axis = op.axis
+    max_sequence_length = past_cache.shape[axis]
+    sequence_length = update.shape[axis]
+    output = np.array(past_cache, copy=True)
+    for prefix_idx in np.ndindex(past_cache.shape[:axis]):
+        batch_idx = prefix_idx[0]
+        base_index = int(write_indices[batch_idx])
+        for sequence_idx in range(sequence_length):
+            cache_idx = (*prefix_idx, base_index + sequence_idx)
+            if op.mode == "circular":
+                cache_idx = tuple(
+                    np.mod(np.asarray(cache_idx), max_sequence_length)
+                )
+            update_idx = (*prefix_idx, sequence_idx)
+            output[cache_idx] = update[update_idx]
+    evaluator.values[op.output] = output
+
+
 @register_evaluator("Celu")
 def _eval_celu(evaluator: Evaluator, node: Node) -> None:
     if len(node.inputs) != 1 or len(node.outputs) != 1:
@@ -749,8 +981,22 @@ def _eval_isinf(evaluator: Evaluator, node: Node) -> None:
     output_dtype = value_dtype(evaluator.graph, node.outputs[0], node)
     if output_dtype != ScalarType.BOOL:
         raise UnsupportedOpError("IsInf output must be bool")
+    detect_negative = int(node.attrs.get("detect_negative", 1))
+    detect_positive = int(node.attrs.get("detect_positive", 1))
+    if detect_negative not in {0, 1} or detect_positive not in {0, 1}:
+        raise UnsupportedOpError(
+            "IsInf detect_negative and detect_positive must be 0 or 1"
+        )
     x = evaluator.values[node.inputs[0]]
-    evaluator.values[node.outputs[0]] = np.isinf(x)
+    if detect_negative and detect_positive:
+        result = np.isinf(x)
+    elif detect_negative:
+        result = np.isneginf(x)
+    elif detect_positive:
+        result = np.isposinf(x)
+    else:
+        result = np.zeros(x.shape, dtype=bool)
+    evaluator.values[node.outputs[0]] = result
 
 
 @register_evaluator("IsNaN")
@@ -1184,6 +1430,49 @@ def _eval_attention(evaluator: Evaluator, node: Node) -> None:
         evaluator.values[qk_matmul_output_name] = qk_output
 
 
+@register_evaluator("RotaryEmbedding")
+def _eval_rotary_embedding(evaluator: Evaluator, node: Node) -> None:
+    op = lower_rotary_embedding(evaluator.graph, node)
+    x = evaluator.values[op.input0]
+    cos_cache = evaluator.values[op.cos_cache]
+    sin_cache = evaluator.values[op.sin_cache]
+    position_ids = (
+        evaluator.values[op.position_ids] if op.position_ids else None
+    )
+    original_shape = x.shape
+    if op.input_rank == 4:
+        x = np.transpose(x, (0, 2, 1, 3))
+    else:
+        x = x.reshape(op.batch, op.seq_len, op.num_heads, op.head_size)
+    x_rotate = x[..., : op.rotary_dim]
+    x_not_rotate = x[..., op.rotary_dim :]
+    if position_ids is not None:
+        cos_cache = cos_cache[position_ids]
+        sin_cache = sin_cache[position_ids]
+    cos_cache = np.expand_dims(cos_cache, axis=2)
+    sin_cache = np.expand_dims(sin_cache, axis=2)
+    if op.interleaved:
+        x1 = x_rotate[..., 0::2]
+        x2 = x_rotate[..., 1::2]
+    else:
+        x1, x2 = np.split(x_rotate, 2, axis=-1)
+    real = (cos_cache * x1) - (sin_cache * x2)
+    imag = (sin_cache * x1) + (cos_cache * x2)
+    if op.interleaved:
+        real = np.expand_dims(real, axis=-1)
+        imag = np.expand_dims(imag, axis=-1)
+        x_rotate_concat = np.concatenate((real, imag), axis=-1)
+        x_rotate = np.reshape(x_rotate_concat, x_rotate.shape)
+    else:
+        x_rotate = np.concatenate((real, imag), axis=-1)
+    output = np.concatenate((x_rotate, x_not_rotate), axis=-1)
+    if op.input_rank == 4:
+        output = np.transpose(output, (0, 2, 1, 3))
+    else:
+        output = output.reshape(original_shape)
+    evaluator.values[node.outputs[0]] = output
+
+
 def _apply_lstm_activation(
     kind: int, value: np.ndarray, alpha: float, beta: float
 ) -> np.ndarray:
@@ -1382,6 +1671,41 @@ def _eval_quantize_linear(evaluator: Evaluator, node: Node) -> None:
         spec.output_dtype.np_dtype, copy=False
     )
 
+
+@register_evaluator("QLinearMatMul")
+def _eval_qlinear_matmul(evaluator: Evaluator, node: Node) -> None:
+    op = lower_qlinear_matmul(evaluator.graph, node)
+    input0 = evaluator.values[op.input0]
+    input1 = evaluator.values[op.input1]
+    input0_scale = evaluator.values[op.input0_scale]
+    input1_scale = evaluator.values[op.input1_scale]
+    output_scale = evaluator.values[op.output_scale]
+    input0_zero_point = evaluator.values[op.input0_zero_point]
+    input1_zero_point = evaluator.values[op.input1_zero_point]
+    output_zero_point = evaluator.values[op.output_zero_point]
+
+    def _scalar_value(array: np.ndarray) -> float:
+        return float(np.asarray(array).reshape(-1)[0])
+
+    def _scalar_int(array: np.ndarray) -> int:
+        return int(np.asarray(array).reshape(-1)[0])
+
+    input0_zero = _scalar_int(input0_zero_point)
+    input1_zero = _scalar_int(input1_zero_point)
+    output_zero = _scalar_int(output_zero_point)
+    scale = _scalar_value(input0_scale) * _scalar_value(
+        input1_scale
+    ) / _scalar_value(output_scale)
+    acc = _apply_matmul(
+        input0.astype(np.int32) - input0_zero,
+        input1.astype(np.int32) - input1_zero,
+    )
+    scaled = acc.astype(np.float64) * scale + output_zero
+    rounded = np.rint(scaled)
+    info = np.iinfo(op.dtype.np_dtype)
+    clipped = np.clip(rounded, info.min, info.max)
+    evaluator.values[op.output] = clipped.astype(op.dtype.np_dtype)
+
 @register_evaluator("InstanceNormalization")
 def _eval_instance_normalization(evaluator: Evaluator, node: Node) -> None:
     op = lower_instance_normalization(evaluator.graph, node)

emx_onnx_cgen/verification.py

@@ -2,24 +2,7 @@ from __future__ import annotations
 
 import numpy as np
 
-
-def _float_uint_dtype(values: np.ndarray) -> type[np.unsignedinteger]:
-    if values.dtype == np.float16:
-        return np.uint16
-    if values.dtype == np.float32:
-        return np.uint32
-    if values.dtype == np.float64:
-        return np.uint64
-    raise ValueError(f"Unsupported floating dtype for ULP calculation: {values.dtype}")
-
-
-def _float_to_ordered_int(values: np.ndarray) -> np.ndarray:
-    uint_dtype = _float_uint_dtype(values)
-    bits = np.dtype(uint_dtype).itemsize * 8
-    sign_mask = np.array(1 << (bits - 1), dtype=uint_dtype)
-    as_uint = values.view(uint_dtype)
-    ordered = np.where(as_uint & sign_mask, ~as_uint, as_uint | sign_mask)
-    return ordered.astype(np.uint64, copy=False)
+from shared.ulp import ulp_intdiff_float
 
 
 def max_ulp_diff(actual: np.ndarray, expected: np.ndarray) -> int:
@@ -34,27 +17,14 @@ def max_ulp_diff(actual: np.ndarray, expected: np.ndarray) -> int:
         raise ValueError(f"Unsupported floating dtype for ULP calculation: {dtype}")
     actual_cast = actual.astype(dtype, copy=False)
     expected_cast = expected.astype(dtype, copy=False)
-    nan_mask = np.isnan(actual_cast) | np.isnan(expected_cast)
-    if nan_mask.any():
-        both_nan = np.isnan(actual_cast) & np.isnan(expected_cast)
-        if not np.all(both_nan):
-            uint_dtype = _float_uint_dtype(expected_cast)
-            return int(np.iinfo(uint_dtype).max)
-        actual_cast = actual_cast[~nan_mask]
-        expected_cast = expected_cast[~nan_mask]
-        if actual_cast.size == 0:
-            return 0
-    eps = np.finfo(dtype).eps
-    near_zero = (np.abs(actual_cast) < eps) & (np.abs(expected_cast) < eps)
-    if np.any(near_zero):
-        actual_cast = actual_cast.copy()
-        expected_cast = expected_cast.copy()
-        actual_cast[near_zero] = 0
-        expected_cast[near_zero] = 0
-    ordered_actual = _float_to_ordered_int(actual_cast)
-    ordered_expected = _float_to_ordered_int(expected_cast)
-    deltas = ordered_actual.astype(np.int64) - ordered_expected.astype(np.int64)
-    return int(np.max(np.abs(deltas)))
+    max_diff = 0
+    for actual_value, expected_value in np.nditer(
+        [actual_cast, expected_cast], flags=["refs_ok"]
+    ):
+        diff = ulp_intdiff_float(actual_value[()], expected_value[()])
+        if diff > max_diff:
+            max_diff = diff
+    return max_diff
 
 
 def format_success_message(max_ulp: int) -> str:

{emx_onnx_cgen-0.3.0.dist-info → emx_onnx_cgen-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emx-onnx-cgen
-Version: 0.3.0
+Version: 0.3.2
 Summary: emmtrix ONNX-to-C Code Generator
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -71,7 +71,7 @@ Compile an ONNX model into a C source file:
 emx-onnx-cgen compile path/to/model.onnx build/model.c
 ```
 
-Verify an ONNX model end-to-end against ONNX Runtime:
+Verify an ONNX model end-to-end against ONNX Runtime (default):
 
 ```bash
 emx-onnx-cgen verify path/to/model.onnx
@@ -93,7 +93,7 @@ Options:
 - `--model-name`: Override the generated model name (default: output file stem).
 - `--emit-testbench`: Emit a JSON-producing `main()` testbench for validation.
 - `--emit-data-file`: Emit constant data arrays into a companion `_data` C file.
-- `--large-weight-threshold`: Store weights larger than this element count in a binary file (default: `1024`).
+- `--large-weight-threshold`: Store weights larger than this element count in a binary file (default: `1048576`; set to `0` to disable).
 - `--large-temp-threshold-bytes`: Mark temporary buffers larger than this threshold as static (default: `1024`).
 - `--no-restrict-arrays`: Disable `restrict` qualifiers on generated array parameters.
 
@@ -111,6 +111,7 @@ Options:
 - `--large-weight-threshold`: Store weights larger than this element count in a binary file (default: `1024`).
 - `--large-temp-threshold-bytes`: Mark temporary buffers larger than this threshold as static (default: `1024`).
 - `--max-ulp`: Maximum allowed ULP distance for floating outputs (default: `100`).
+- `--runtime`: Runtime backend for verification (`onnxruntime` or `onnx-reference`, default: `onnx-reference`).
 
 How verification works:
 
@@ -119,14 +120,14 @@ How verification works:
 2. **Build and execute**: the testbench is compiled with the selected C compiler
    (`--cc`, `CC`, or a detected `cc/gcc/clang`) and executed in a temporary
    directory.
-3. **Run ONNX Runtime**: the JSON inputs from the testbench are fed to ORT using
-   the same model.
+3. **Run runtime backend**: the JSON inputs from the testbench are fed to the
+   selected runtime (`onnxruntime` or `onnx-reference`) using the same model.
 4. **Compare outputs**: floating outputs are compared by maximum ULP distance
    (see https://www.emmtrix.com/wiki/ULP_Difference_of_Float_Numbers for the
    ULP definition and algorithm); non-floating outputs must match exactly.
    Missing outputs or mismatches are treated as failures.
-5. **ORT unsupported models**: if ORT reports `NOT_IMPLEMENTED`, verification is
-   skipped with a warning (exit code 0).
+5. **ORT unsupported models**: when using `onnxruntime`, if ORT reports
+   `NOT_IMPLEMENTED`, verification is skipped with a warning (exit code 0).
 
 ## Output
 

emx_onnx_cgen-0.3.2.dist-info/RECORD

@@ -0,0 +1,107 @@
+emx_onnx_cgen/__init__.py,sha256=jUSbu1kJ0krzVTYEcph3jCprBhD7tWNtiSdL6r29KrM,221
+emx_onnx_cgen/__main__.py,sha256=iC1lLVtR6-TmpL6OxXcy3oIntExUtajn9-q627R1XyI,140
+emx_onnx_cgen/_build_info.py,sha256=A7nFhoSa2YUEYMuQb71Vehv5hhDs7VSInIe852k4khc,112
+emx_onnx_cgen/_version.py,sha256=e8NqPtZ8fggRgk3GPrqZ_U_BDV8aSULw1u_Gn9NNbnk,704
+emx_onnx_cgen/cli.py,sha256=7Y9JW-t1PLg25zOizuqyMqwsXbbG9ok99DsYeFSiOFQ,21685
+emx_onnx_cgen/compiler.py,sha256=qXKUQedaQY6A2jX-twte4qVA263T3UtCDlPjvoM5vYU,16513
+emx_onnx_cgen/dtypes.py,sha256=jRx3BBvk0qFW14bngoL1B7L_IRasyNJ4jqhpM5YhcOM,1335
+emx_onnx_cgen/errors.py,sha256=HpOv95mTgr9ZX2gYe1RtwVMbPskh7zkqjU_FgAD-uIM,363
+emx_onnx_cgen/onnx_import.py,sha256=IF7KZGfEP9H4H1fHYjobGbB_381fqD_67KtqZYs9AZ4,9168
+emx_onnx_cgen/onnxruntime_utils.py,sha256=mEsC1x00M1jyBgVBKqnKoqx6H1tdgsFFUy7rbITs3bs,308
+emx_onnx_cgen/ops.py,sha256=qpPOaqsYprlJrhCNLVBZ3XnREBRDdmkXbd1zaAkywOI,16732
+emx_onnx_cgen/testbench.py,sha256=-NbqD1aC7OXvFMLiLzd2IPObenQdHFH85cNxNSB1GeY,640
+emx_onnx_cgen/validation.py,sha256=KFdUdGjQbzTj1szCJcjxnTi8f5l6ywNgCB9abbBpTbM,2360
+emx_onnx_cgen/verification.py,sha256=IrhIMm29R2vEkW1Q8gtoQtscMGxfJRavNRSMJHBAJ5g,1041
+emx_onnx_cgen/codegen/__init__.py,sha256=H_kBdc_w_W-3qdUZJHwKBDns1AeP_Un3-46LW20yLV0,406
+emx_onnx_cgen/codegen/c_emitter.py,sha256=dS-vjjuWT0GHETbV3ipoYedvuvcJB0yGwMZgoQuJe-g,452931
+emx_onnx_cgen/codegen/emitter.py,sha256=udcsqJNr46TFHiyVv5I4wdVH8ll6Bi4VqcR1VvofbnY,92
+emx_onnx_cgen/ir/__init__.py,sha256=fD2D8qxlGoCFJb0m9v6u3XTgzSxDOhB4cfLBiCLovzg,102
+emx_onnx_cgen/ir/context.py,sha256=cM3V6G3zs6VCsABP6TnZ8vvQ7VGwOF1iKtb1hq0WO3g,3356
+emx_onnx_cgen/ir/model.py,sha256=SZ3K8t4dKUqWuXWe5ozApofXx4bdcf4p0WYCdeU-mFA,1265
+emx_onnx_cgen/ir/op_base.py,sha256=mHvp0VD55JIrwQI2MFEmSILi22kuurBX085aamcjQ0g,6160
+emx_onnx_cgen/ir/op_context.py,sha256=9CZCUNJLsV4cJsYmJqWbaDrwQd4sr-9Ot1PmPSqGAto,2103
+emx_onnx_cgen/ir/ops/__init__.py,sha256=IcllGXB4T3TCrpBq9cy3jR_edS_IJ_qXac37K_rIZcA,2440
+emx_onnx_cgen/ir/ops/elementwise.py,sha256=sZ1S6X_fagNDevN6dXHBy75g_z-WP_dHFAVmPGnmeaU,3721
+emx_onnx_cgen/ir/ops/misc.py,sha256=1ekAgV5j6Stc1Yw8e-0EPD5t8mI1YJxmyIkAn9Zr4h8,10920
+emx_onnx_cgen/ir/ops/nn.py,sha256=-4ZqDkcu7zgci3YVfMzCDzokqpZHgOYZaq_C1GclBZQ,14365
+emx_onnx_cgen/ir/ops/reduce.py,sha256=-aA4bwOMppd9pnWQwhl6hOxryh0G2xRaHqeNwQ97AdY,2756
+emx_onnx_cgen/lowering/__init__.py,sha256=AxnUfmpf5Teos1ms3zE6r0EBxxPYznGSOICDEFWH_pk,1535
+emx_onnx_cgen/lowering/adagrad.py,sha256=DuW3MeNNJjhXz1k7XI9JDwfgWr-TyD5Q-B9eAZrNecM,4797
+emx_onnx_cgen/lowering/arg_reduce.py,sha256=7dvlOItEp_Mtxj-lohI_mNRqHFZZnGCsdfx8ON0i2F0,3377
+emx_onnx_cgen/lowering/attention.py,sha256=-Il_8AQMuwQtq-2-RkVyVfnvtRJuO61Cv1PlMIypxEc,16477
+emx_onnx_cgen/lowering/average_pool.py,sha256=kcaOBPNaVMITY7gprbJSIMRrwhgIbeI3OEVxzO1xRM0,8074
+emx_onnx_cgen/lowering/batch_normalization.py,sha256=_i-vwlhuAQYqxJIezHaxeqcmISV66Y_5o929_FTtMZg,3976
+emx_onnx_cgen/lowering/cast.py,sha256=J2Tf7MprIcZjsgVLGsaccpbyvftfXfm57o--Il-8GlQ,2841
+emx_onnx_cgen/lowering/common.py,sha256=lQVBapOlo3w0ats2R2kPwftuTYMc8aAsQuLWrcQQ_pM,16783
+emx_onnx_cgen/lowering/concat.py,sha256=aY1QjCBzmyxDmfybyzRRSEPiL3hR1JwtCCXvHA7vFDE,1086
+emx_onnx_cgen/lowering/constant_of_shape.py,sha256=N01UvbVroDk08FTbBMndrLYIzI0G6M0UQuCr4oxpP40,3197
+emx_onnx_cgen/lowering/conv.py,sha256=9VFdsChsJ_AL25mhe2H482Aa2-89-S1dSJpiu7ixgQg,7298
+emx_onnx_cgen/lowering/conv_transpose.py,sha256=10K7nhQ60p0PAB3qxmeazm2tbsSS1GDeINBk7VzsH1U,11153
+emx_onnx_cgen/lowering/cumsum.py,sha256=9E0C5NtvPt6g5T4QLdIOeDkXaZNzyDklus2-qu2B7eA,4114
+emx_onnx_cgen/lowering/depth_space.py,sha256=i7INioNkofBxFlZW9y0W_qA6mp67_FAXouhKCiB9RKc,4206
+emx_onnx_cgen/lowering/dropout.py,sha256=MZ4YrB-jvUFXpIKE5kOLyrEF5uy5dh0yjJH6Rj8KlMs,1764
+emx_onnx_cgen/lowering/einsum.py,sha256=MWAgWVOzP38RSOxJABwvYU6ykD9odmhrmddXinmFs7s,6117
+emx_onnx_cgen/lowering/elementwise.py,sha256=q9X3qTll7gLp39NTTdzuLs9RBsONssw50l1hWo8wby0,12229
+emx_onnx_cgen/lowering/expand.py,sha256=GmYJZWXXcBV42hMGUgbKKbLjeCxpbcMSoG9OU1ZkFFY,5518
+emx_onnx_cgen/lowering/eye_like.py,sha256=QBiHWYZbgK4uiUYWuS7WHCMBGMSG0paNZM84OYmGb7c,1723
+emx_onnx_cgen/lowering/flatten.py,sha256=6h-TQNy9iq5hfXR9h2clUrc2eHmZP9gAb9KbCSJdV20,2131
+emx_onnx_cgen/lowering/gather.py,sha256=PCER36AjmpxzAM4wuL7En3XR1RKZCdSzjxualDCUHAI,1803
+emx_onnx_cgen/lowering/gather_elements.py,sha256=cCp2UFOjktgEfS9s9npMS_BXklBkpMpD7UhIIMhQ-_Y,2318
+emx_onnx_cgen/lowering/gather_nd.py,sha256=rmr_ijeSeCrZ_R_QPwdoHPQUCe8nE0YRSv2NjUiiFjY,3090
+emx_onnx_cgen/lowering/gemm.py,sha256=qBaZ-6FZAAMEaZ4uifo58tJI8SoBsJvkZTCg7jvq288,4579
+emx_onnx_cgen/lowering/global_max_pool.py,sha256=RMjaspdwThsHFGq_CJ2lUo5MOZc4NtmG-W5zshhc85A,2212
+emx_onnx_cgen/lowering/grid_sample.py,sha256=FFbK-jrjqFLwSUu7BfSZC9So7MeCZprGKG5N4XQUxR4,5217
+emx_onnx_cgen/lowering/group_normalization.py,sha256=Ep7toUW9sHvMHb2EwNpgayygTW-TN62ooVLdaF0z9_c,2653
+emx_onnx_cgen/lowering/hardmax.py,sha256=PKY7w_4N6qzJq_l1O3le8J-uspPPK3Ujpl6Kdmt4tOU,1950
+emx_onnx_cgen/lowering/identity.py,sha256=zzmmSz1NTiRAPIZqU81qnNQFuuSJq6EvqbUOt1Hc3gA,1848
+emx_onnx_cgen/lowering/instance_normalization.py,sha256=XrDOAo8Af7yDObtAAJ006dVCN175cWPb5Wvh61PE7xs,1939
+emx_onnx_cgen/lowering/layer_normalization.py,sha256=RjRn1sPFupB8n3RsA8O9p5vDmfmj2Q6hjMVhSFzfLkU,4518
+emx_onnx_cgen/lowering/logsoftmax.py,sha256=giFEKQKN7xxlQqV64HNvO1QQobjM-IgavWJi7DT5pJk,1884
+emx_onnx_cgen/lowering/lp_normalization.py,sha256=il1fBWan8DwZ3dlRVSJWVhMpzHDYtwjh1YJaNm6palY,1701
+emx_onnx_cgen/lowering/lp_pool.py,sha256=aG-J6xwhprMJIXTNXwA781XfbBnUD0oh9_POwwEEAe4,4862
+emx_onnx_cgen/lowering/lrn.py,sha256=rJ_7ISllYphbHKmlMv3c5IwqPl-oZrEKWux7QCdjqIQ,3359
+emx_onnx_cgen/lowering/lstm.py,sha256=RVe0qGesoK-FfWeV0vCKCkoWD32Fv_C22LnQLFLr4Tc,12294
+emx_onnx_cgen/lowering/matmul.py,sha256=CpxloKLXX7u5SofOTYUTt8vU9IkD7h25VByQbLwkGiw,4248
+emx_onnx_cgen/lowering/maxpool.py,sha256=0XoazajqrB5So-hEnR73LOSsdF7ZnguVNAc9NSjK6Q4,7483
+emx_onnx_cgen/lowering/mean_variance_normalization.py,sha256=tFeDgrocZO5Q5hNBaFl4cTFpKTPNVmRH9-FZircEffA,1864
+emx_onnx_cgen/lowering/negative_log_likelihood_loss.py,sha256=J5VfAQN2bIrt8D4_6KIGxRBk4Q9ykJvlqJftCrqy-jc,9333
+emx_onnx_cgen/lowering/non_max_suppression.py,sha256=9EeHm2aF7QBmP-s23r43VDgRvGyFWcNcI1s_jYPqln0,5749
+emx_onnx_cgen/lowering/nonzero.py,sha256=qjDlI_0s37hK-arOD-Bm_Ft9N_gTVt0X3OEqxuP1sR0,1626
+emx_onnx_cgen/lowering/one_hot.py,sha256=JGJsA35Q5hyX7nutNVJMGgTgcFxlAlolH9k4igVc2s0,4341
+emx_onnx_cgen/lowering/pad.py,sha256=Z8361NQCwypKfTnS8-0rylX6P-S8xLU6QLbahVzxrzw,10405
+emx_onnx_cgen/lowering/qlinear_matmul.py,sha256=gsV8CAB9_PhPuCGBYEvqfhby3uHQ6-4lyfDI2Xgvw0c,7899
+emx_onnx_cgen/lowering/quantize_linear.py,sha256=yJOvZbGxI8HcZ_Zl9VO49qJVfZ5FwNoDq5TjTiGzKmg,4760
+emx_onnx_cgen/lowering/range.py,sha256=yaRvLHLlWNvvg-IO590jSVPv2dWrJjPWXyysSNOj0IY,3452
+emx_onnx_cgen/lowering/reduce.py,sha256=W_wa1ev2tD8gqSTTQX5K0brwvB_x1kqf9vo8R5HHN6k,18402
+emx_onnx_cgen/lowering/registry.py,sha256=tNmnP6ZhIrKv83Q6VdfkTLSsw6P8cqch-nqSWpURYX8,2002
+emx_onnx_cgen/lowering/reshape.py,sha256=L5h-u7DbrRzuPucDFwXw-oCX8bikD9R2RBkz9lTwEBM,13441
+emx_onnx_cgen/lowering/resize.py,sha256=XCTUppSDj9-GyztBORIuK1MJMxelA3DU_NZzfsVIlgQ,14633
+emx_onnx_cgen/lowering/rms_normalization.py,sha256=pWu5u0TqHZaL3rh07MtA6eOP0zLzNCoQ84f1V0un2Iw,2525
+emx_onnx_cgen/lowering/rotary_embedding.py,sha256=IfDxuUCJqFIK8SCviYXZfdJcrgg8tjT2ofYFUP2uv8c,6068
+emx_onnx_cgen/lowering/scatter_nd.py,sha256=WuNxsMQmCTXgqen5rygpAbZIsfca537lvvFPakn0rJU,3210
+emx_onnx_cgen/lowering/shape.py,sha256=r68BQSK2ldY6ct3iPfkpJsGySmaViOGqn3Mi3qoPTTM,2224
+emx_onnx_cgen/lowering/size.py,sha256=Mfj2x0zvDrhMAcmhXI5F63dzd3w3ZT2IxfI0jMbTSuQ,1250
+emx_onnx_cgen/lowering/slice.py,sha256=rMzmQ5nwaM8oJVmChOeVHPJn0qMXYpKZCPzO_eoEj_M,14805
+emx_onnx_cgen/lowering/softmax.py,sha256=mImrc0oeFpMywsx94PdDS1aQVj7DUgqoFhjsMjLLDdk,1863
+emx_onnx_cgen/lowering/softmax_cross_entropy_loss.py,sha256=B6h23sGBZLdpKcbtoQUhVwfLrdSJwNcbCoPoDc3rTc0,5219
+emx_onnx_cgen/lowering/split.py,sha256=w4OPi4X-xoJgmTJuCTIfp0Dm7wd2NLZZ6AJM-jUROFg,5883
+emx_onnx_cgen/lowering/squeeze.py,sha256=p9bER1Jkc8_6BGjsD3b7zhuak11eywoQhVFIvJ9Vzj0,6084
+emx_onnx_cgen/lowering/tensor_scatter.py,sha256=1Wqb9XsNNj1CEKnH3Vx45xh3QQbxHF9L90ycVbcsy44,4485
+emx_onnx_cgen/lowering/tile.py,sha256=PJva752IM55f8evZzOz12Y7PUGsQ0kC_YR86SqowWqM,3030
+emx_onnx_cgen/lowering/topk.py,sha256=Dqx7qMr4HbXhVGN-wJf_D4dPTvYMVT6S82A2M3f9Dwo,4819
+emx_onnx_cgen/lowering/transpose.py,sha256=oNFRjkH63KqnO2Q4oJengEAUEYC1M3PW12AauWwebzI,1751
+emx_onnx_cgen/lowering/trilu.py,sha256=OjJjyo2ZRcfo9UGH8Zfq4o0PR6YDeoHSj8DzMu0w318,3266
+emx_onnx_cgen/lowering/unsqueeze.py,sha256=9y-OM-oY6ln1-R6duRRemeRrwBIpX2TZs_nRtlYQMYE,5985
+emx_onnx_cgen/lowering/variadic.py,sha256=etIWA7jVqWrWH3NkNvpF5opVGgvb0ZS4iLo4L3euWDs,3287
+emx_onnx_cgen/lowering/where.py,sha256=K2RUDvLg0uTvi6Z_uTOXM5jgc3PXRj0cTZ4u58GEGko,2644
+emx_onnx_cgen/runtime/__init__.py,sha256=88xGpAs1IEBlzlWL_e9tnKUlaSRdc7pQUeVCu5LC4DY,50
+emx_onnx_cgen/runtime/evaluator.py,sha256=yqsBpAIlBky-rby7J5z7i1SvDaK6PjObxH-wQSdZ2G0,114732
+shared/__init__.py,sha256=bmP79AVZdY_1aNULJap9pm76Q41Rabrza6X-0A8lDzw,45
+shared/scalar_functions.py,sha256=CErro1Du2Ri3uqX6Dgd18DzNbxduckAvsmLJ6oHGx9A,91123
+shared/scalar_types.py,sha256=kEpsl5T-NVFxCcTzXqPJbtpvDiCgKHfz91dphLLZxZA,4912
+shared/ulp.py,sha256=DpeovCFijmP8_M7zyTZWsNyfOtJ1AjNSdxf5jGsdfJo,1856
+emx_onnx_cgen-0.3.2.dist-info/METADATA,sha256=K_7vi0Tqx4-r94xZ2WliM4PXIfApgaI8C5a1_UgIjZE,6266
+emx_onnx_cgen-0.3.2.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+emx_onnx_cgen-0.3.2.dist-info/entry_points.txt,sha256=b7Rvmz_Bi9kWyn7QayQC_FEXiRpt4cS1RnluKh49yoo,57
+emx_onnx_cgen-0.3.2.dist-info/top_level.txt,sha256=g39fo-blEbgiVcC_GRqAnBzN234w3LXbcVdLUoItSLk,21
+emx_onnx_cgen-0.3.2.dist-info/RECORD,,

{emx_onnx_cgen-0.3.0.dist-info → emx_onnx_cgen-0.3.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

shared/scalar_functions.py

@@ -2059,6 +2059,17 @@ def _bool_from_ops(name: str) -> _GeneratedScalar:
 
 
 _SCALAR_TYPES: Dict[ScalarType, _ScalarTypeInfo] = {
+    ScalarType.F16: _ScalarTypeInfo(
+        scalar_type=ScalarType.F16,
+        c_type="_Float16",
+        prefix="ref_scalar_f16_",
+        suffix="f16",
+        is_float=True,
+        is_bool=False,
+        is_signed=True,
+        is_small_int=False,
+        bits=None,
+    ),
     ScalarType.F32: _ScalarTypeInfo(
         scalar_type=ScalarType.F32,
         c_type="float",