emx-onnx-cgen 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

emx_onnx_cgen/lowering/constant_of_shape.py

@@ -4,7 +4,7 @@ from onnx import numpy_helper
 
 from shared.scalar_types import ScalarType
 
-from ..codegen.c_emitter import ConstantOfShapeOp
+from ..ir.ops import ConstantOfShapeOp
 from ..dtypes import scalar_type_from_onnx
 from ..errors import ShapeInferenceError, UnsupportedOpError
 from ..ir.model import Graph, Node

emx_onnx_cgen/lowering/conv.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import math
 from dataclasses import dataclass
 
-from ..codegen.c_emitter import ConvOp
+from ..ir.ops import ConvOp
 from ..errors import ShapeInferenceError, UnsupportedOpError
 from ..ir.model import Graph, Node
 from .common import node_dtype as _node_dtype

emx_onnx_cgen/lowering/conv_transpose.py

@@ -0,0 +1,301 @@
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+from ..ir.ops import ConvTransposeOp
+from ..errors import ShapeInferenceError, UnsupportedOpError
+from ..ir.model import Graph, Node
+from .common import node_dtype as _node_dtype
+from .common import value_shape as _value_shape
+from .registry import register_lowering
+
+
+@dataclass(frozen=True)
+class ConvTransposeSpec:
+    batch: int
+    in_channels: int
+    out_channels: int
+    spatial_rank: int
+    in_spatial: tuple[int, ...]
+    out_spatial: tuple[int, ...]
+    kernel_shape: tuple[int, ...]
+    strides: tuple[int, ...]
+    pads: tuple[int, ...]
+    dilations: tuple[int, ...]
+    output_padding: tuple[int, ...]
+    group: int
+
+
+def _split_padding(
+    total_padding: int, auto_pad: str, *, dim: int
+) -> tuple[int, int]:
+    if total_padding < 0:
+        raise ShapeInferenceError(
+            "ConvTranspose output shape must be fully defined and non-negative"
+        )
+    pad_end = total_padding // 2
+    pad_begin = total_padding - pad_end
+    if auto_pad == "SAME_UPPER":
+        pad_begin, pad_end = pad_end, pad_begin
+    elif auto_pad not in {"SAME_LOWER", "NOTSET", ""}:
+        raise UnsupportedOpError(
+            f"ConvTranspose has unsupported auto_pad mode '{auto_pad}'"
+        )
+    if pad_begin < 0 or pad_end < 0:
+        raise ShapeInferenceError(
+            f"ConvTranspose pads must be non-negative for dim {dim}"
+        )
+    return pad_begin, pad_end
+
+
+def resolve_conv_transpose_spec(graph: Graph, node: Node) -> ConvTransposeSpec:
+    if len(node.inputs) not in {2, 3} or len(node.outputs) != 1:
+        raise UnsupportedOpError(
+            "ConvTranspose must have 2 or 3 inputs and 1 output"
+        )
+    supported_attrs = {
+        "auto_pad",
+        "dilations",
+        "group",
+        "kernel_shape",
+        "output_padding",
+        "output_shape",
+        "pads",
+        "strides",
+    }
+    if set(node.attrs) - supported_attrs:
+        raise UnsupportedOpError("ConvTranspose has unsupported attributes")
+    input_shape = _value_shape(graph, node.inputs[0], node)
+    weight_shape = _value_shape(graph, node.inputs[1], node)
+    if len(input_shape) < 3:
+        raise UnsupportedOpError("ConvTranspose expects NCHW inputs with spatial dims")
+    spatial_rank = len(input_shape) - 2
+    if spatial_rank not in {1, 2, 3}:
+        raise UnsupportedOpError("ConvTranspose supports 1D/2D/3D inputs only")
+    if len(weight_shape) != spatial_rank + 2:
+        raise UnsupportedOpError(
+            "ConvTranspose weight rank must match spatial rank"
+        )
+    batch, in_channels = input_shape[0], input_shape[1]
+    in_spatial = input_shape[2:]
+    weight_in_channels, weight_out_channels, *kernel_shape = weight_shape
+    kernel_attr = node.attrs.get("kernel_shape")
+    if kernel_attr is not None:
+        kernel_attr = tuple(int(value) for value in kernel_attr)
+        if len(kernel_attr) != spatial_rank:
+            raise UnsupportedOpError(
+                "ConvTranspose kernel_shape rank must match input spatial rank"
+            )
+        if kernel_attr != tuple(kernel_shape):
+            raise ShapeInferenceError(
+                "ConvTranspose kernel_shape must match weights, "
+                f"got {kernel_attr} and {tuple(kernel_shape)}"
+            )
+        kernel_shape = list(kernel_attr)
+    else:
+        kernel_shape = list(kernel_shape)
+    group = int(node.attrs.get("group", 1))
+    if group <= 0:
+        raise UnsupportedOpError("ConvTranspose expects group >= 1")
+    if in_channels % group != 0:
+        raise ShapeInferenceError(
+            "ConvTranspose expects group to evenly divide in channels, "
+            f"got group={group}, in_channels={in_channels}"
+        )
+    if weight_in_channels != in_channels:
+        raise ShapeInferenceError(
+            "ConvTranspose input channels must match weight channels, "
+            f"got {in_channels} and {weight_in_channels}"
+        )
+    out_channels = weight_out_channels * group
+    if out_channels % group != 0:
+        raise ShapeInferenceError(
+            "ConvTranspose expects group to evenly divide out channels, "
+            f"got group={group}, out_channels={out_channels}"
+        )
+    if len(node.inputs) == 3:
+        bias_shape = _value_shape(graph, node.inputs[2], node)
+        if bias_shape != (out_channels,):
+            raise ShapeInferenceError(
+                f"ConvTranspose bias shape must be {(out_channels,)}, got {bias_shape}"
+            )
+    strides = tuple(
+        int(value) for value in node.attrs.get("strides", (1,) * spatial_rank)
+    )
+    if len(strides) != spatial_rank:
+        raise UnsupportedOpError("ConvTranspose stride rank mismatch")
+    dilations = tuple(
+        int(value) for value in node.attrs.get("dilations", (1,) * spatial_rank)
+    )
+    if len(dilations) != spatial_rank:
+        raise UnsupportedOpError("ConvTranspose dilation rank mismatch")
+    output_padding = tuple(
+        int(value)
+        for value in node.attrs.get("output_padding", (0,) * spatial_rank)
+    )
+    if len(output_padding) != spatial_rank:
+        raise UnsupportedOpError("ConvTranspose output_padding rank mismatch")
+    for dim, (padding, stride) in enumerate(zip(output_padding, strides)):
+        if padding < 0:
+            raise UnsupportedOpError(
+                "ConvTranspose output_padding must be non-negative"
+            )
+        if padding >= stride:
+            raise UnsupportedOpError(
+                "ConvTranspose output_padding must be smaller than stride"
+            )
+    pads = tuple(
+        int(value)
+        for value in node.attrs.get("pads", (0,) * (2 * spatial_rank))
+    )
+    if len(pads) != 2 * spatial_rank:
+        raise UnsupportedOpError("ConvTranspose pads rank mismatch")
+    auto_pad = node.attrs.get("auto_pad", b"NOTSET")
+    if isinstance(auto_pad, bytes):
+        auto_pad = auto_pad.decode("utf-8", errors="ignore")
+    if auto_pad == "":
+        auto_pad = "NOTSET"
+    output_shape_attr = node.attrs.get("output_shape")
+    output_shape: list[int] | None = None
+    if output_shape_attr is not None:
+        output_shape = [int(value) for value in output_shape_attr]
+        if len(output_shape) != spatial_rank:
+            raise UnsupportedOpError("ConvTranspose output_shape rank mismatch")
+    if output_shape is not None:
+        if auto_pad == "VALID":
+            auto_pad = "NOTSET"
+        pad_begin = []
+        pad_end = []
+        for dim, (in_dim, stride, dilation, kernel, out_dim, out_pad) in enumerate(
+            zip(
+                in_spatial,
+                strides,
+                dilations,
+                kernel_shape,
+                output_shape,
+                output_padding,
+            )
+        ):
+            effective_kernel = dilation * (kernel - 1) + 1
+            total_padding = (
+                stride * (in_dim - 1)
+                + out_pad
+                + effective_kernel
+                - out_dim
+            )
+            pad_start, pad_finish = _split_padding(
+                total_padding, auto_pad, dim=dim
+            )
+            pad_begin.append(pad_start)
+            pad_end.append(pad_finish)
+        out_spatial = output_shape
+    else:
+        if auto_pad == "VALID":
+            pad_begin = [0] * spatial_rank
+            pad_end = [0] * spatial_rank
+        elif auto_pad in {"SAME_UPPER", "SAME_LOWER"}:
+            pad_begin = []
+            pad_end = []
+            for dim, (in_dim, stride, dilation, kernel, out_pad) in enumerate(
+                zip(in_spatial, strides, dilations, kernel_shape, output_padding)
+            ):
+                effective_kernel = dilation * (kernel - 1) + 1
+                out_dim = in_dim * stride
+                total_padding = (
+                    stride * (in_dim - 1)
+                    + out_pad
+                    + effective_kernel
+                    - out_dim
+                )
+                pad_start, pad_finish = _split_padding(
+                    total_padding, auto_pad, dim=dim
+                )
+                pad_begin.append(pad_start)
+                pad_end.append(pad_finish)
+        elif auto_pad in {"NOTSET"}:
+            pad_begin = list(pads[:spatial_rank])
+            pad_end = list(pads[spatial_rank:])
+        else:
+            raise UnsupportedOpError(
+                f"ConvTranspose has unsupported auto_pad mode '{auto_pad}'"
+            )
+        out_spatial = []
+        for dim, (in_dim, stride, dilation, kernel, pad_start, pad_finish, out_pad) in enumerate(
+            zip(
+                in_spatial,
+                strides,
+                dilations,
+                kernel_shape,
+                pad_begin,
+                pad_end,
+                output_padding,
+            )
+        ):
+            effective_kernel = dilation * (kernel - 1) + 1
+            out_dim = (
+                stride * (in_dim - 1)
+                + out_pad
+                + effective_kernel
+                - pad_start
+                - pad_finish
+            )
+            if out_dim < 0:
+                raise ShapeInferenceError(
+                    "ConvTranspose output shape must be non-negative"
+                )
+            out_spatial.append(out_dim)
+    output_shape = _value_shape(graph, node.outputs[0], node)
+    expected_output_shape = (batch, out_channels, *out_spatial)
+    if output_shape != expected_output_shape:
+        raise ShapeInferenceError(
+            "ConvTranspose output shape must be "
+            f"{expected_output_shape}, got {output_shape}"
+        )
+    return ConvTransposeSpec(
+        batch=batch,
+        in_channels=in_channels,
+        out_channels=out_channels,
+        spatial_rank=spatial_rank,
+        in_spatial=in_spatial,
+        out_spatial=tuple(out_spatial),
+        kernel_shape=tuple(kernel_shape),
+        strides=strides,
+        pads=(*pad_begin, *pad_end),
+        dilations=dilations,
+        output_padding=output_padding,
+        group=group,
+    )
+
+
+@register_lowering("ConvTranspose")
+def lower_conv_transpose(graph: Graph, node: Node) -> ConvTransposeOp:
+    if len(node.inputs) not in {2, 3} or len(node.outputs) != 1:
+        raise UnsupportedOpError(
+            "ConvTranspose must have 2 or 3 inputs and 1 output"
+        )
+    op_dtype = _node_dtype(graph, node, *node.inputs, *node.outputs)
+    if not op_dtype.is_float:
+        raise UnsupportedOpError(
+            "ConvTranspose supports float16, float, and double inputs only"
+        )
+    spec = resolve_conv_transpose_spec(graph, node)
+    return ConvTransposeOp(
+        input0=node.inputs[0],
+        weights=node.inputs[1],
+        bias=node.inputs[2] if len(node.inputs) == 3 else None,
+        output=node.outputs[0],
+        batch=spec.batch,
+        in_channels=spec.in_channels,
+        out_channels=spec.out_channels,
+        spatial_rank=spec.spatial_rank,
+        in_spatial=spec.in_spatial,
+        out_spatial=spec.out_spatial,
+        kernel_shape=spec.kernel_shape,
+        strides=spec.strides,
+        pads=spec.pads,
+        dilations=spec.dilations,
+        output_padding=spec.output_padding,
+        group=spec.group,
+        dtype=op_dtype,
+    )

emx_onnx_cgen/lowering/cumsum.py

@@ -4,7 +4,7 @@ import numpy as np
 
 from shared.scalar_types import ScalarType
 
-from ..codegen.c_emitter import CumSumOp
+from ..ir.ops import CumSumOp
 from ..errors import ShapeInferenceError, UnsupportedOpError
 from ..ir.model import Graph, Initializer, Node
 from ..lowering.common import value_dtype, value_shape

emx_onnx_cgen/lowering/depth_space.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from ..codegen.c_emitter import DepthToSpaceOp, SpaceToDepthOp
+from ..ir.ops import DepthToSpaceOp, SpaceToDepthOp
 from ..errors import ShapeInferenceError, UnsupportedOpError
 from ..ir.model import Graph, Node
 from ..lowering.common import value_dtype, value_shape

emx_onnx_cgen/lowering/dropout.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from ..codegen.c_emitter import ReshapeOp
+from ..ir.ops import ReshapeOp
 from ..errors import ShapeInferenceError, UnsupportedOpError
 from ..ir.model import Graph, Node
 from .common import value_dtype as _value_dtype

emx_onnx_cgen/lowering/einsum.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from ..ir.ops import EinsumKind, EinsumOp
+from ..errors import ShapeInferenceError, UnsupportedOpError
+from ..ir.model import Graph, Node
+from .common import node_dtype as _node_dtype
+from .common import value_shape as _value_shape
+from .registry import register_lowering
+
+
+def _normalize_equation(equation: str) -> str:
+    return equation.replace(" ", "")
+
+
+@register_lowering("Einsum")
+def lower_einsum(graph: Graph, node: Node) -> EinsumOp:
+    if not node.inputs or len(node.outputs) != 1:
+        raise UnsupportedOpError("Einsum must have 1 output and at least 1 input")
+    equation_value = node.attrs.get("equation")
+    if equation_value is None:
+        raise UnsupportedOpError("Einsum equation attribute is required")
+    equation = (
+        equation_value.decode()
+        if isinstance(equation_value, (bytes, bytearray))
+        else str(equation_value)
+    )
+    normalized = _normalize_equation(equation)
+    input_shapes = tuple(
+        _value_shape(graph, name, node) for name in node.inputs
+    )
+    output_shape = _value_shape(graph, node.outputs[0], node)
+    op_dtype = _node_dtype(graph, node, *node.inputs, *node.outputs)
+    if normalized == "->":
+        if len(node.inputs) != 1:
+            raise UnsupportedOpError("Einsum '->' must have 1 input")
+        if output_shape:
+            raise ShapeInferenceError(
+                "Einsum '->' output must be scalar, "
+                f"got shape {output_shape}"
+            )
+        kind = EinsumKind.REDUCE_ALL
+    elif normalized == "ij->i":
+        if len(node.inputs) != 1:
+            raise UnsupportedOpError("Einsum 'ij->i' must have 1 input")
+        input_shape = input_shapes[0]
+        if len(input_shape) != 2:
+            raise ShapeInferenceError(
+                "Einsum 'ij->i' input must be 2D, "
+                f"got shape {input_shape}"
+            )
+        expected = (input_shape[0],)
+        if output_shape != expected:
+            raise ShapeInferenceError(
+                f"Einsum 'ij->i' output must match shape {expected}, "
+                f"got {output_shape}"
+            )
+        kind = EinsumKind.SUM_J
+    elif normalized == "ij->ji":
+        if len(node.inputs) != 1:
+            raise UnsupportedOpError("Einsum 'ij->ji' must have 1 input")
+        input_shape = input_shapes[0]
+        if len(input_shape) != 2:
+            raise ShapeInferenceError(
+                "Einsum 'ij->ji' input must be 2D, "
+                f"got shape {input_shape}"
+            )
+        expected = (input_shape[1], input_shape[0])
+        if output_shape != expected:
+            raise ShapeInferenceError(
+                f"Einsum 'ij->ji' output must match shape {expected}, "
+                f"got {output_shape}"
+            )
+        kind = EinsumKind.TRANSPOSE
+    elif normalized in {"i,i", "i,i->"}:
+        if len(node.inputs) != 2:
+            raise UnsupportedOpError("Einsum 'i,i' must have 2 inputs")
+        left_shape, right_shape = input_shapes
+        if len(left_shape) != 1 or len(right_shape) != 1:
+            raise ShapeInferenceError(
+                "Einsum 'i,i' inputs must be vectors, "
+                f"got shapes {left_shape} and {right_shape}"
+            )
+        if left_shape[0] != right_shape[0]:
+            raise ShapeInferenceError(
+                "Einsum 'i,i' inputs must have the same length, "
+                f"got shapes {left_shape} and {right_shape}"
+            )
+        if output_shape:
+            raise ShapeInferenceError(
+                "Einsum 'i,i' output must be scalar, "
+                f"got shape {output_shape}"
+            )
+        kind = EinsumKind.DOT
+    elif normalized == "bij,bjk->bik":
+        if len(node.inputs) != 2:
+            raise UnsupportedOpError("Einsum 'bij,bjk->bik' must have 2 inputs")
+        left_shape, right_shape = input_shapes
+        if len(left_shape) != 3 or len(right_shape) != 3:
+            raise ShapeInferenceError(
+                "Einsum 'bij,bjk->bik' inputs must be 3D, "
+                f"got shapes {left_shape} and {right_shape}"
+            )
+        if left_shape[0] != right_shape[0]:
+            raise ShapeInferenceError(
+                "Einsum 'bij,bjk->bik' batch dimensions must match, "
+                f"got shapes {left_shape} and {right_shape}"
+            )
+        if left_shape[2] != right_shape[1]:
+            raise ShapeInferenceError(
+                "Einsum 'bij,bjk->bik' contraction dimensions must match, "
+                f"got shapes {left_shape} and {right_shape}"
+            )
+        expected = (left_shape[0], left_shape[1], right_shape[2])
+        if output_shape != expected:
+            raise ShapeInferenceError(
+                f"Einsum 'bij,bjk->bik' output must match shape {expected}, "
+                f"got {output_shape}"
+            )
+        kind = EinsumKind.BATCH_MATMUL
+    elif normalized == "...ii->...i":
+        if len(node.inputs) != 1:
+            raise UnsupportedOpError("Einsum '...ii->...i' must have 1 input")
+        input_shape = input_shapes[0]
+        if len(input_shape) < 2:
+            raise ShapeInferenceError(
+                "Einsum '...ii->...i' input must be at least 2D, "
+                f"got shape {input_shape}"
+            )
+        if input_shape[-1] != input_shape[-2]:
+            raise ShapeInferenceError(
+                "Einsum '...ii->...i' requires last two dims to match, "
+                f"got shape {input_shape}"
+            )
+        expected = (*input_shape[:-2], input_shape[-1])
+        if output_shape != expected:
+            raise ShapeInferenceError(
+                f"Einsum '...ii->...i' output must match shape {expected}, "
+                f"got {output_shape}"
+            )
+        kind = EinsumKind.BATCH_DIAGONAL
+    else:
+        raise UnsupportedOpError(
+            f"Unsupported Einsum equation '{equation}'"
+        )
+    return EinsumOp(
+        inputs=tuple(node.inputs),
+        output=node.outputs[0],
+        kind=kind,
+        input_shapes=input_shapes,
+        output_shape=output_shape,
+        dtype=op_dtype,
+        input_dtype=op_dtype,
+    )

emx_onnx_cgen/lowering/elementwise.py

@@ -1,13 +1,23 @@
 from __future__ import annotations
 
-from shared.scalar_functions import ScalarFunction
+from shared.scalar_functions import ScalarFunction, ScalarFunctionError
 from shared.scalar_types import ScalarType
 
-from ..codegen.c_emitter import ClipOp, UnaryOp
+from ..ir.ops import BinaryOp, ClipOp, UnaryOp
 from ..errors import UnsupportedOpError
+from ..ir.context import GraphContext
 from ..ir.model import Graph, Node
 from ..lowering.common import node_dtype, optional_name, value_dtype, value_shape
-from ..lowering.registry import register_lowering
+from ..lowering.registry import register_lowering, register_lowering_if_missing
+from ..ops import (
+    BINARY_OP_TYPES,
+    COMPARE_FUNCTIONS,
+    UNARY_OP_TYPES,
+    binary_op_symbol,
+    unary_op_symbol,
+    validate_unary_attrs,
+)
+from ..lowering.variadic import VARIADIC_OP_FUNCTIONS
 
 
 @register_lowering("Clip")
@@ -120,6 +130,138 @@ def lower_shrink(graph: Graph, node: Node) -> UnaryOp:
     )
 
 
+def _lower_binary_unary(graph: Graph | GraphContext, node: Node) -> BinaryOp | UnaryOp:
+    if node.op_type == "BitShift":
+        if len(node.inputs) != 2 or len(node.outputs) != 1:
+            raise UnsupportedOpError("BitShift must have 2 inputs and 1 output")
+        direction_attr = node.attrs.get("direction", "LEFT")
+        if isinstance(direction_attr, bytes):
+            direction = direction_attr.decode()
+        else:
+            direction = str(direction_attr)
+        if direction not in {"LEFT", "RIGHT"}:
+            raise UnsupportedOpError(
+                "BitShift direction must be LEFT or RIGHT"
+            )
+        op_dtype = node_dtype(graph, node, *node.inputs, *node.outputs)
+        if not op_dtype.is_integer:
+            raise UnsupportedOpError("BitShift expects integer inputs")
+        function = (
+            ScalarFunction.BITWISE_LEFT_SHIFT
+            if direction == "LEFT"
+            else ScalarFunction.BITWISE_RIGHT_SHIFT
+        )
+        op_spec = binary_op_symbol(function, node.attrs, dtype=op_dtype)
+        if op_spec is None:
+            raise UnsupportedOpError("Unsupported op BitShift")
+        input0_shape = value_shape(graph, node.inputs[0], node)
+        input1_shape = value_shape(graph, node.inputs[1], node)
+        output_shape = value_shape(graph, node.outputs[0], node)
+        return BinaryOp(
+            input0=node.inputs[0],
+            input1=node.inputs[1],
+            output=node.outputs[0],
+            function=function,
+            operator_kind=op_spec.kind,
+            input0_shape=input0_shape,
+            input1_shape=input1_shape,
+            shape=output_shape,
+            dtype=op_dtype,
+            input_dtype=op_dtype,
+        )
+    if node.op_type == "Mod":
+        fmod = int(node.attrs.get("fmod", 0))
+        if fmod not in {0, 1}:
+            raise UnsupportedOpError("Mod only supports fmod=0 or fmod=1")
+        function = (
+            ScalarFunction.FMOD if fmod == 1 else ScalarFunction.REMAINDER
+        )
+    else:
+        try:
+            function = ScalarFunction.from_onnx_op(node.op_type)
+        except ScalarFunctionError as exc:
+            raise UnsupportedOpError(
+                f"Unsupported op {node.op_type}"
+            ) from exc
+    validate_unary_attrs(node.op_type, node.attrs)
+    if function in COMPARE_FUNCTIONS:
+        input_dtype = node_dtype(graph, node, *node.inputs)
+        output_dtype = value_dtype(graph, node.outputs[0], node)
+        op_spec = binary_op_symbol(function, node.attrs, dtype=input_dtype)
+        if op_spec is None:
+            raise UnsupportedOpError(f"Unsupported op {node.op_type}")
+        if len(node.inputs) != 2 or len(node.outputs) != 1:
+            raise UnsupportedOpError(
+                f"{node.op_type} must have 2 inputs and 1 output"
+            )
+        if output_dtype != ScalarType.BOOL:
+            raise UnsupportedOpError(
+                f"{node.op_type} expects bool output, got {output_dtype.onnx_name}"
+            )
+        input0_shape = value_shape(graph, node.inputs[0], node)
+        input1_shape = value_shape(graph, node.inputs[1], node)
+        output_shape = value_shape(graph, node.outputs[0], node)
+        return BinaryOp(
+            input0=node.inputs[0],
+            input1=node.inputs[1],
+            output=node.outputs[0],
+            function=function,
+            operator_kind=op_spec.kind,
+            input0_shape=input0_shape,
+            input1_shape=input1_shape,
+            shape=output_shape,
+            dtype=output_dtype,
+            input_dtype=input_dtype,
+        )
+    op_dtype = node_dtype(graph, node, *node.inputs, *node.outputs)
+    op_spec = binary_op_symbol(function, node.attrs, dtype=op_dtype)
+    unary_symbol = unary_op_symbol(function, dtype=op_dtype)
+    if op_spec is None and unary_symbol is None:
+        raise UnsupportedOpError(f"Unsupported op {node.op_type}")
+    if op_spec is not None:
+        if len(node.inputs) != 2 or len(node.outputs) != 1:
+            raise UnsupportedOpError(
+                f"{node.op_type} must have 2 inputs and 1 output"
+            )
+        input0_shape = value_shape(graph, node.inputs[0], node)
+        input1_shape = value_shape(graph, node.inputs[1], node)
+        output_shape = value_shape(graph, node.outputs[0], node)
+        return BinaryOp(
+            input0=node.inputs[0],
+            input1=node.inputs[1],
+            output=node.outputs[0],
+            function=function,
+            operator_kind=op_spec.kind,
+            input0_shape=input0_shape,
+            input1_shape=input1_shape,
+            shape=output_shape,
+            dtype=op_dtype,
+            input_dtype=op_dtype,
+        )
+    if len(node.inputs) != 1 or len(node.outputs) != 1:
+        raise UnsupportedOpError(
+            f"{node.op_type} must have 1 input and 1 output"
+        )
+    output_shape = value_shape(graph, node.outputs[0], node)
+    return UnaryOp(
+        input0=node.inputs[0],
+        output=node.outputs[0],
+        function=function,
+        shape=output_shape,
+        dtype=op_dtype,
+        input_dtype=op_dtype,
+        params=(),
+    )
+
+
+_DEFAULT_ELEMENTWISE_TYPES = (
+    BINARY_OP_TYPES.union(UNARY_OP_TYPES) - set(VARIADIC_OP_FUNCTIONS.keys())
+)
+
+for _op_type in _DEFAULT_ELEMENTWISE_TYPES:
+    register_lowering_if_missing(_op_type)(_lower_binary_unary)
+
+
 @register_lowering("IsInf")
 def lower_isinf(graph: Graph, node: Node) -> UnaryOp:
     if len(node.inputs) != 1 or len(node.outputs) != 1:
@@ -130,6 +272,12 @@ def lower_isinf(graph: Graph, node: Node) -> UnaryOp:
         raise UnsupportedOpError("IsInf only supports floating-point inputs")
     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"
+        )
     output_shape = value_shape(graph, node.outputs[0], node)
     return UnaryOp(
         input0=node.inputs[0],
@@ -138,7 +286,7 @@ def lower_isinf(graph: Graph, node: Node) -> UnaryOp:
         shape=output_shape,
         dtype=output_dtype,
         input_dtype=input_dtype,
-        params=(),
+        params=(float(detect_negative), float(detect_positive)),
     )