ai-edge-torch-nightly 0.3.0.dev20240827__py3-none-any.whl → 0.3.0.dev20240829__py3-none-any.whl

ai_edge_torch/odml_torch/composite/mark_tensor.py

@@ -0,0 +1,120 @@
+# Copyright 2024 The AI Edge Torch Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+import json
+from typing import Sequence, Union
+
+from jax._src.lib.mlir import ir
+from jax._src.lib.mlir.dialects import hlo as stablehlo
+import torch
+
+from .. import _torch_library
+from .. import lowerings
+
+CompositeAttrType = dict[
+    str,
+    Union[
+        int,
+        float,
+        bool,
+        str,
+        Sequence[int],
+        Sequence[float],
+        Sequence[bool],
+    ],
+]
+
+
+def _assert_valid_composite_attr(attr: CompositeAttrType):
+  if attr is None:
+    return
+  if not isinstance(attr, dict):
+    raise ValueError("Composite attr must be a Python dictionary.")
+
+  for k, v in attr.items():
+    if not isinstance(k, str):
+      raise ValueError("Composite attr name must be a Python str.")
+
+    invalid_attr_value_error = ValueError(
+        "Composite attr value must be either Python str, float, int, bool,"
+        " list[int], list[float], list[bool]."
+    )
+    if isinstance(v, (list, tuple)):
+      eltys = {type(el) for el in v}
+      if len(eltys) > 1 or next(iter(eltys)) not in (int, float, bool):
+        raise invalid_attr_value_error
+    elif type(v) not in (str, float, int, bool):
+      raise invalid_attr_value_error
+
+
+@torch._dynamo.assume_constant_result
+def serialize_composite_attr(attr: Union[CompositeAttrType, None]):
+  """Serialize the composite attr into a dynamo-tracable value."""
+  if attr is None:
+    return None
+  _assert_valid_composite_attr(attr)
+  return tuple(attr.items())
+
+
+@torch._dynamo.assume_constant_result
+def deserialize_composite_attr(serialized_attr) -> CompositeAttrType:
+  """Deserialize dynamo-tracable composite attribute into its raw value."""
+  if serialized_attr is None:
+    return None
+  return dict(serialized_attr)
+
+
+_torch_library.ODML_TORCH_LIB.define(
+    "mark_tensor(Tensor x, str name, int pos, str id, bool is_input, Any?"
+    " attr=None) -> Tensor"
+)
+
+mark_tensor_op = torch.ops.odml_torch.mark_tensor.default
+
+
+@torch.library.impl(
+    _torch_library.ODML_TORCH_LIB, "mark_tensor", "CompositeExplicitAutograd"
+)
+def mark_tensor(
+    x: torch.Tensor, name: str, pos: int, id: str, is_input: bool, attr=None
+):
+  return x
+
+
+@torch.library.impl(_torch_library.ODML_TORCH_LIB, "mark_tensor", "Meta")
+def mark_tensor_meta(
+    x: torch.Tensor, name: str, pos: int, id: str, is_input: bool, attr=None
+):
+  return torch.empty_like(x)
+
+
+@lowerings.lower(torch.ops.odml_torch.mark_tensor)
+def mark_tensor_lowering(
+    lctx, x: ir.Value, name: str, pos: int, id: str, is_input: bool, attr=None
+):
+  attr = deserialize_composite_attr(attr)
+  return stablehlo.custom_call(
+      [x.type],
+      inputs=[x],
+      call_target_name="mark_tensor",
+      backend_config=ir.StringAttr.get(
+          json.dumps({
+              "name": name,
+              "pos": pos,
+              "id": id,
+              "is_input": is_input,
+              "attr": attr,
+          })
+      ),
+  )

ai_edge_torch/odml_torch/composite/stablehlo_composite_builder.py

@@ -0,0 +1,106 @@
+# Copyright 2024 The AI Edge Torch Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+import uuid
+
+import torch
+
+from . import mark_tensor
+
+
+@torch._dynamo.assume_constant_result
+def _get_uuid() -> str:
+  return uuid.uuid4().hex
+
+
+class StableHLOCompositeBuilder:
+  """Builder class for building a StableHLO composite in the lowering."""
+
+  def __init__(self, name: str, attr: mark_tensor.CompositeAttrType = None):
+    """Helper for building a StableHLO Composite by marking input and output tensors.
+
+    It should be used with the StableHLO converters from `torch_xla.stablehlo`.
+
+    Args:
+      name (str): The name of the built StableHLO Composite op.
+      attr (mark_tensor.CompositeAttrType): Attributes of the StableHLO
+        Composite op.
+    """
+
+    self.attr = attr
+    self.name = name
+    self.id = _get_uuid()
+    self._inputs = []
+    self._outputs = []
+
+  def _mark_tensor(self, *tensors: torch.Tensor, is_input: bool):
+    """Mark the input/output tensors of the StableHLO Composite."""
+    marked_tensors = []
+    serialized_attr = (
+        mark_tensor.serialize_composite_attr(self.attr)
+        if not is_input
+        else None
+    )
+
+    for pos, tensor in enumerate(tensors):
+      if not isinstance(tensor, torch.Tensor):
+        raise ValueError(f"input must be a torch tensor. Got {type(tensor)}.")
+      marked_tensors.append(
+          mark_tensor.mark_tensor_op(
+              tensor,
+              name=self.name,
+              pos=pos,
+              id=self.id,
+              is_input=is_input,
+              attr=serialized_attr,
+          )
+      )
+
+    if len(marked_tensors) == 1:
+      return marked_tensors[0]
+    return tuple(marked_tensors)
+
+  def mark_inputs(self, *tensors: torch.Tensor):
+    """Mark the input tensors of the StableHLO Composite.
+
+    This method must only be called once per builder.
+
+    Args:
+      *tensors (torch.Tensor): Torch tensors to mark.
+
+    Returns:
+      marked_tensors (torch.Tensor or Tuple[torch.Tensor]):
+        Torch tensors marked as composite inputs. The tensor inputs of this
+        method
+        should be replaced by the marked tensors in later usages.
+    """
+
+    return self._mark_tensor(*tensors, is_input=True)
+
+  def mark_outputs(self, *tensors: torch.Tensor):
+    """Mark the output tensors of the StableHLO Composite.
+
+    This method must only be called once per builder.
+
+    Args:
+      *tensors (torch.Tensor): Torch tensors to mark.
+
+    Returns:
+      marked_tensors (torch.Tensor or Tuple[torch.Tensor]):
+        Torch tensors marked as composite outputs. The tensor inputs of this
+        method
+        should be replaced by the marked tensors in later usages.
+    """
+
+    return self._mark_tensor(*tensors, is_input=False)

ai_edge_torch/odml_torch/debuginfo/__init__.py

@@ -0,0 +1,16 @@
+# Copyright 2024 The AI Edge Torch Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+from ._build import build_mlir_debuginfo
+from ._op_polyfill import write_mlir_debuginfo_op

ai_edge_torch/odml_torch/debuginfo/_build.py

@@ -0,0 +1,43 @@
+# Copyright 2024 The AI Edge Torch Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+import torch
+
+
+def _class_fullname(cls):
+  module = cls.__module__
+  if module == "builtins":
+    return cls.__qualname__
+  return module + "." + cls.__qualname__
+
+
+def _get_hierarchy(node: torch.fx.Node):
+  nn_module_stack = node.meta.get("nn_module_stack", {})
+  layers = []
+  for name, layer in nn_module_stack.values():
+    iid = ("_" + name.split(".")[-1]) if name else ""
+    layer_str = layer if isinstance(layer, str) else _class_fullname(layer)
+    layers.append(layer_str + iid)
+
+  hierachy_str = "/".join(layers) + ";"
+  return hierachy_str
+
+
+def build_mlir_debuginfo(node: torch.fx.Node):
+  """Build the debuginfo string for the given node's lowerings in MLIR."""
+
+  if not hasattr(node, "meta") or "nn_module_stack" not in node.meta:
+    return None
+
+  return _get_hierarchy(node)

ai_edge_torch/odml_torch/debuginfo/_op_polyfill.py

@@ -0,0 +1,55 @@
+# Copyright 2024 The AI Edge Torch Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Polyfill op for torch.ops.xla.write_mlir_debuginfo.
+
+In odml-torch, MLIR debuginfo is generated in the lowering framework directly
+without the need of an additional torch op to write. This file register a no-op
+placeholder torch op to replace torch.ops.xla.write_mlir_debuginfo in
+ai-edge-torch.
+"""
+
+from jax._src.lib.mlir import ir
+import torch
+
+from .. import _torch_library
+from .. import lowerings
+
+
+_torch_library.ODML_TORCH_LIB.define(
+    "write_mlir_debuginfo(Tensor x, str data) -> Tensor"
+)
+
+write_mlir_debuginfo_op = torch.ops.odml_torch.write_mlir_debuginfo
+
+
+@torch.library.impl(
+    _torch_library.ODML_TORCH_LIB,
+    "write_mlir_debuginfo",
+    "CompositeExplicitAutograd",
+)
+def write_mlir_debuginfo(x: torch.Tensor, _: str):
+  return x
+
+
+@torch.library.impl(
+    _torch_library.ODML_TORCH_LIB, "write_mlir_debuginfo", "Meta"
+)
+def write_mlir_debuginfo_meta(x: torch.Tensor, _: str):
+  return torch.empty_like(x)
+
+
+@lowerings.lower(torch.ops.odml_torch.write_mlir_debuginfo)
+def write_mlir_debuginfo_lowering(lctx, x: ir.Value, _: str):
+  return x

ai_edge_torch/odml_torch/export.py

@@ -0,0 +1,320 @@
+# Copyright 2024 The AI Edge Torch Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""APIs to convert and lower a PyTorch ExportedProgram to MLIR."""
+
+import dataclasses
+import enum
+import io
+import operator
+from typing import Any, Callable, Optional
+
+from jax.lib import xla_extension
+from jax._src.lib.mlir import ir
+from jax._src.lib.mlir.dialects import func
+from jax._src.lib.mlir.dialects import hlo as stablehlo
+import torch
+import torch.utils._pytree as pytree
+
+from . import _torch_future
+from . import debuginfo
+from . import export_utils
+from . import lowerings
+
+LoweringContext = lowerings.context.LoweringContext
+
+
+def _build_flat_inputs(
+    ctx: ir.Context, exported_program: torch.export.ExportedProgram
+):
+  """Build flattened inputs and metadata from exported program's signature."""
+  placeholder_nodes = [
+      n for n in exported_program.graph.nodes if n.op == "placeholder"
+  ]
+  export_flat_args = _torch_future.graph_module_flat_inputs(
+      exported_program, *exported_program.example_inputs
+  )
+
+  ir_inputs = []
+  tensor_metas = []
+  for node, arg in zip(placeholder_nodes, export_flat_args):
+    tensor_meta = node.meta.get("tensor_meta")
+    if tensor_meta is None:
+      raise RuntimeError(f"{type(arg)} (for {node.name}) is not a tensor")
+
+    tensor_metas.append(tensor_meta)
+    # Assume all dynamic dimensions are unbounded.
+    # TODO: Add checks for ep.range_constraints in MLIR.
+    shape = tuple(
+        export_utils.IR_DYNAMIC if export_utils.is_torch_dynamic(s) else s
+        for s in tensor_meta.shape
+    )
+    ir_inputs.append(
+        ir.RankedTensorType.get(
+            shape,
+            export_utils.torch_dtype_to_ir_element_type(ctx, tensor_meta.dtype),
+        )
+    )
+  return tuple(ir_inputs), tuple(export_flat_args), tuple(tensor_metas)
+
+
+def _get_output_metas(exported_program: torch.export.ExportedProgram):
+  """Get the output node's tensor_meta from the exported program."""
+  outputs = [n for n in exported_program.graph.nodes if n.op == "output"]
+  assert len(outputs) == 1
+  outputs, _ = pytree.tree_flatten(outputs[0].args[0])
+  assert all(isinstance(output, torch.fx.Node) for output in outputs)
+  return tuple(output.meta["tensor_meta"] for output in outputs)
+
+
+class LoweringInterpreter(torch.fx.Interpreter):
+  """The FX interpreter to iterate and invoke corresponding lowering for each PyTorch op in the graph."""
+
+  def __init__(self, module: torch.fx.GraphModule, lctx: LoweringContext):
+    super().__init__(module)
+    self.lctx = lctx
+    self.outputs = None
+
+  def _build_loc(self, node: torch.fx.Node):
+
+    info = debuginfo.build_mlir_debuginfo(node)
+    if info is None:
+      return ir.Location.unknown()
+
+    return ir.Location.name(name=info)
+
+  def run_node(self, node: torch.fx.Node):
+    loc = self._build_loc(node)
+    with loc:
+      self.lctx = self.lctx.replace(ir_location=loc, node=node)
+      res = super().run_node(node)
+      self.lctx = self.lctx.replace(ir_location=None, node=None)
+    return res
+
+  def call_function(self, target, args, kwargs):
+    if target is operator.getitem:
+      return super().call_function(target, args, kwargs)
+
+    if hasattr(target, "_schema"):
+      new_args = []
+      for arg, spec in zip(args, target._schema.arguments):
+        if isinstance(spec.type, torch.TensorType):
+          if isinstance(arg, int):
+            arg = lowerings.utils.splat(arg, ir.IntegerType.get_signless(32))
+          elif isinstance(arg, float):
+            arg = lowerings.utils.splat(arg, ir.F32Type.get())
+
+        new_args.append(arg)
+      args = tuple(new_args)
+
+    lowering = lowerings.lookup(target)
+    if lowering is None:
+      raise RuntimeError(f"Lowering not found: {target}")
+    return lowering(self.lctx, *args, **kwargs)
+
+  def output(self, target, args, kwargs):
+    flat_outputs = pytree.tree_flatten(args[0])[0]
+    self.outputs = flat_outputs
+
+
+@dataclasses.dataclass
+class InputSpec:
+
+  class VariableType(enum.Enum):
+    USER_INPUT = "user_input"
+    PARAMETER = "parameter"
+
+  type_: VariableType
+  i: int = -1
+  name: str = ""
+
+  @classmethod
+  def parameter(cls, name: str):
+    return cls(type_=cls.VariableType.PARAMETER, name=name)
+
+  @classmethod
+  def user_input(cls, i: int):
+    return cls(type_=cls.VariableType.USER_INPUT, i=i)
+
+  @property
+  def is_parameter(self):
+    return self.type_ == self.VariableType.PARAMETER
+
+  @property
+  def is_user_input(self):
+    return self.type_ == self.VariableType.USER_INPUT
+
+
+@dataclasses.dataclass
+class VariableSignature:  # either argument or parameters
+  shape: list[int]
+  dtype: str
+  input_spec: InputSpec = None
+
+
+@dataclasses.dataclass
+class MlirLowered:
+  """The lowered MLIR module, metadata, and weight tensors bundle from exported program."""
+
+  ctx: ir.Context
+  module: ir.Module
+  state_dict: dict[str, torch.Tensor]
+  input_signature: list[VariableSignature]
+  output_signature: list[VariableSignature]
+
+  _tf_function: Optional[Callable[Any, Any]] = None
+
+  def __str__(self):
+    return str(self.get_text(enable_debug_info=False))
+
+  def __repr__(self):
+    return str(self.get_text(enable_debug_info=False))
+
+  def get_text(self, enable_debug_info=False):
+    return str(
+        self.module.operation.get_asm(enable_debug_info=enable_debug_info)
+    )
+
+  @property
+  def module_bytecode(self) -> bytes:
+    output = io.BytesIO()
+    self.module.operation.write_bytecode(file=output)
+    return output.getvalue()
+
+  @property
+  def module_bytecode_vhlo(self) -> bytes:
+    # HACK: In OSS, we use MLIR pybinding and StableHLO dialect from JAX's
+    # build, which may not have the same StableHLO version as what used in
+    # TFLite converter. Therefore we always serialize MLIR module in VHLO.
+    # TODO(b/362798610) Build MLIR pybinding in ai-edge-torch release.
+    target_version = stablehlo.get_minimum_version()
+    module_bytecode = xla_extension.mlir.serialize_portable_artifact(
+        self.module_bytecode, target_version
+    )
+    return module_bytecode
+
+  @property
+  def tf_function(self):
+    # Lazy import
+    from . import tf_integration
+
+    if self._tf_function is None:
+      self._tf_function = tf_integration.mlir_to_tf_function(self)
+    return self._tf_function
+
+  def __call__(self, *args):
+    # Lazy importing TF when execution is needed.
+    return self.tf_function(*args)
+
+  def to_flatbuffer(self):
+    from . import tf_integration
+
+    return tf_integration.mlir_to_flatbuffer(self)
+
+
+def exported_program_to_mlir(
+    exported_program: torch.export.ExportedProgram,
+) -> MlirLowered:
+  """Lower the exported program to MLIR."""
+  if torch.__version__ >= "2.2":
+    # torch version 2.1 didn't expose this yet
+    exported_program = exported_program.run_decompositions()
+    exported_program = exported_program.run_decompositions(
+        lowerings.decompositions()
+    )
+
+  with export_utils.create_ir_context() as context, ir.Location.unknown():
+
+    module = ir.Module.create()
+    lctx = LoweringContext(context, module)
+    interpreter = LoweringInterpreter(exported_program.graph_module, lctx)
+    ir_flat_inputs, export_flat_args, tensor_metas = _build_flat_inputs(
+        context, exported_program
+    )
+
+    # HACK: OSS MLIR pybinding could mysteriously transform func.func under
+    # construction into a func.return op after calling ir.Module.parse(..)
+    # in the context, which happens in JAX bridge. This is a bug in MLIR
+    # pybinding.
+    # Workaround steps:
+    # 1. Create a temp func.func.
+    # 2. Create and insert ops to temp's entry block. During the process
+    #   the temp func.func would be broken, but the ops in the block are fine.
+    # 3. Create the main func.func and copy all the ops in temp's entry block
+    #   to main.
+    # 4. Erase the temp func.func.
+    temp_func = func.FuncOp(
+        "temp",
+        ir.FunctionType.get(ir_flat_inputs, []),
+        ip=ir.InsertionPoint.at_block_begin(module.body),
+    )
+    with ir.InsertionPoint(temp_func.add_entry_block()):
+      interpreter.run(*temp_func.arguments, enable_io_processing=False)
+      num_mutations = len(exported_program.graph_signature.buffers_to_mutate)
+      outputs = interpreter.outputs[num_mutations:]
+      func.ReturnOp(interpreter.outputs[num_mutations:])
+
+    main_func = func.FuncOp(
+        "main",
+        ir.FunctionType.get(ir_flat_inputs, [o.type for o in outputs]),
+        ip=ir.InsertionPoint.at_block_begin(module.body),
+    )
+    with ir.InsertionPoint(main_func.add_entry_block()):
+      outputs = export_utils.clone_func_body_ops(temp_func, main_func.arguments)
+      func.ReturnOp(outputs)
+
+    main_func.attributes["sym_visibility"] = ir.StringAttr.get("public")
+    temp_func.erase()
+
+  module.operation.verify()
+
+  input_signature = []
+  state_dict = {}
+
+  user_inputs_cnt = 0
+  for arg, tensor_meta, input_spec in zip(
+      export_flat_args,
+      tensor_metas,
+      exported_program.graph_signature.input_specs,
+  ):
+    # Assumption:
+    # All states comes first in the list of args, and user provided inputs
+    # comes later. Also there is no kwargs.
+    if input_spec.kind == torch.export.graph_signature.InputKind.USER_INPUT:
+      input_signature.append(
+          VariableSignature(
+              tensor_meta.shape,
+              tensor_meta.dtype,
+              input_spec=InputSpec.user_input(user_inputs_cnt),
+          )
+      )
+      user_inputs_cnt += 1
+    else:
+      # Parameter or constant
+      state_dict[input_spec.target] = arg
+      input_signature.append(
+          VariableSignature(
+              tensor_meta.shape,
+              tensor_meta.dtype,
+              input_spec=InputSpec.parameter(input_spec.target),
+          )
+      )
+
+  output_signature = [
+      VariableSignature(tensor_meta.shape, tensor_meta.dtype)
+      for tensor_meta in _get_output_metas(exported_program)
+  ]
+  return MlirLowered(
+      context, module, state_dict, input_signature, output_signature
+  )