onnx 1.13.1__cp310-cp310-win_amd64.whl → 1.14.1__cp310-cp310-win_amd64.whl

onnx/numpy_helper.py

@@ -1,8 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+#
 # SPDX-License-Identifier: Apache-2.0
-# pylint: disable=C3001
+
+# pylint: disable=C3001,isinstance-second-argument-not-valid-type
 
 import sys
-from typing import Any, Dict, List, Optional, Sequence, Union
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
 
@@ -27,12 +30,151 @@ def bfloat16_to_float32(
     shift = lambda x: x << 16  # noqa: E731
     if dims is None:
         if len(data.shape) == 0:
-            return shift(np.array([data]).astype(np.int32)).view(np.float32)[0]
-        return shift(data.astype(np.int32)).view(np.float32)
-    return shift(data.astype(np.int32)).reshape(dims).view(np.float32)
+            return shift(np.array([data]).astype(np.int32)).view(np.float32)[0]  # type: ignore[no-any-return]
+        return shift(data.astype(np.int32)).view(np.float32)  # type: ignore[no-any-return]
+    return shift(data.astype(np.int32)).reshape(dims).view(np.float32)  # type: ignore[no-any-return]
+
+
+def _float8e4m3_to_float32_scalar(ival: int, fn: bool, uz: bool) -> np.float32:
+    if not fn:
+        raise NotImplementedError("fn=False is not implemented.")
+    if ival < 0 or ival > 255:
+        raise ValueError(f"{ival} is not a float8.")
+    if uz:
+        exponent_bias = 8
+        if ival == 0x80:
+            return np.nan  # type: ignore[return-value]
+    else:
+        exponent_bias = 7
+        if ival == 255:
+            return np.float32(-np.nan)
+        if ival == 127:
+            return np.float32(np.nan)
+
+    expo = (ival & 0x78) >> 3
+    mant = ival & 0x07
+    sign = ival & 0x80
+    res = sign << 24
+    if expo == 0:
+        if mant > 0:
+            expo = 0x7F - exponent_bias
+            if mant & 0x4 == 0:
+                mant &= 0x3
+                mant <<= 1
+                expo -= 1
+            if mant & 0x4 == 0:
+                mant &= 0x3
+                mant <<= 1
+                expo -= 1
+            res |= (mant & 0x3) << 21
+            res |= expo << 23
+    else:
+        res |= mant << 20
+        expo += 0x7F - exponent_bias
+        res |= expo << 23
+    f = np.uint32(res).view(np.float32)  # pylint: disable=E1121
+    return f
+
+
+_float8e4m3_to_float32 = np.vectorize(
+    _float8e4m3_to_float32_scalar, excluded=["fn", "uz"]
+)
+
+
+def float8e4m3_to_float32(
+    data: Union[np.int16, np.int32, np.ndarray],
+    dims: Optional[Union[int, Sequence[int]]] = None,
+    fn: bool = True,
+    uz: bool = False,
+) -> np.ndarray:
+    """Converts ndarray of float8, e4m3 (as uint32) to f32 (as uint32).
+
+    :param data: a numpy array, empty dimensions are allowed if dims is None
+    :param dims: if specified, the function reshapes the results
+    :param fn: no infinite values
+    :param uz: no negative zero
+    :return: a numpy array of float32 with the same dimension if dims is None,
+        or reshaped to dims if specified.
+
+    See :ref:`onnx-detail-float8` for technical details.
+    """
+    if not fn:
+        raise NotImplementedError(
+            "float32_to_float8e4m3 not implemented with fn=False."
+        )
+    res = _float8e4m3_to_float32(data, fn=fn, uz=uz)
+    if dims is None:
+        return res  # type: ignore[no-any-return]
+    return res.reshape(dims)  # type: ignore[no-any-return]
+
+
+def _float8e5m2_to_float32_scalar(ival: int, fn: bool, uz: bool) -> np.float32:
+    if fn and uz:
+        if ival == 0x80:
+            return np.float32(np.nan)
+        exponent_bias = 16
+    elif not fn and not uz:
+        if ival in {253, 254, 255}:
+            return np.float32(-np.nan)
+        if ival in {125, 126, 127}:
+            return np.float32(np.nan)
+        if ival == 252:
+            return np.float32(-np.inf)
+        if ival == 124:
+            return np.float32(np.inf)
+        exponent_bias = 15
+    else:
+        raise NotImplementedError("fn and uz must be both False or True.")
+
+    expo = (ival & 0x7C) >> 2
+    mant = ival & 0x03
+    sign = ival & 0x80
+    res = sign << 24
+    if expo == 0:
+        if mant > 0:
+            expo = 0x7F - exponent_bias
+            if mant & 0x2 == 0:
+                mant &= 0x1
+                mant <<= 1
+                expo -= 1
+            res |= (mant & 0x1) << 22
+            res |= expo << 23
+    else:
+        res |= mant << 21
+        expo += 0x7F - exponent_bias
+        res |= expo << 23
+    f = np.uint32(res).view(np.float32)  # pylint: disable=E1121
+    return f
+
 
+_float8e5m2_to_float32 = np.vectorize(
+    _float8e5m2_to_float32_scalar, excluded=["fn", "uz"]
+)
 
-def to_array(tensor: TensorProto, base_dir: str = "") -> np.ndarray:
+
+def float8e5m2_to_float32(
+    data: Union[np.int16, np.int32, np.ndarray],
+    dims: Optional[Union[int, Sequence[int]]] = None,
+    fn: bool = False,
+    uz: bool = False,
+) -> np.ndarray:
+    """Converts ndarray of float8, e5m2 (as uint32) to f32 (as uint32).
+
+    :param data: a numpy array, empty dimensions are allowed if dims is None
+    :param dims: if specified, the function reshapes the results
+    :param fn: no infinite values
+    :param uz: no negative zero
+    :return: a numpy array of float32 with the same dimension if dims is None,
+        or reshaped to dims if specified"""
+    res = _float8e5m2_to_float32(data, fn=fn, uz=uz)
+    if dims is None:
+        return res  # type: ignore[no-any-return]
+    return res.reshape(dims)  # type: ignore[no-any-return]
+
+
+def to_array(  # pylint: disable=too-many-branches
+    tensor: TensorProto, base_dir: str = ""
+) -> np.ndarray:
     """Converts a tensor def object to a numpy array.
 
     Args:
@@ -75,29 +217,58 @@ def to_array(tensor: TensorProto, base_dir: str = "") -> np.ndarray:
             data = np.frombuffer(tensor.raw_data, dtype=np.int16)
             return bfloat16_to_float32(data, dims)
 
-        return np.frombuffer(tensor.raw_data, dtype=np_dtype).reshape(dims)
-    else:
-        # float16 is stored as int32 (uint16 type); Need view to get the original value
-        if tensor_dtype == TensorProto.FLOAT16:
-            return (
-                np.asarray(tensor.int32_data, dtype=np.uint16)
-                .reshape(dims)
-                .view(np.float16)
-            )
+        if tensor_dtype == TensorProto.FLOAT8E4M3FN:
+            data = np.frombuffer(tensor.raw_data, dtype=np.int8)
+            return float8e4m3_to_float32(data, dims)
 
-        # bfloat16 is stored as int32 (uint16 type); no numpy support for bf16
-        if tensor_dtype == TensorProto.BFLOAT16:
-            data = np.asarray(tensor.int32_data, dtype=np.int32)
-            return bfloat16_to_float32(data, dims)
+        if tensor_dtype == TensorProto.FLOAT8E4M3FNUZ:
+            data = np.frombuffer(tensor.raw_data, dtype=np.int8)
+            return float8e4m3_to_float32(data, dims, uz=True)
+
+        if tensor_dtype == TensorProto.FLOAT8E5M2:
+            data = np.frombuffer(tensor.raw_data, dtype=np.int8)
+            return float8e5m2_to_float32(data, dims)
+
+        if tensor_dtype == TensorProto.FLOAT8E5M2FNUZ:
+            data = np.frombuffer(tensor.raw_data, dtype=np.int8)
+            return float8e5m2_to_float32(data, dims, fn=True, uz=True)
+
+        return np.frombuffer(tensor.raw_data, dtype=np_dtype).reshape(dims)  # type: ignore[no-any-return]
+
+    # float16 is stored as int32 (uint16 type); Need view to get the original value
+    if tensor_dtype == TensorProto.FLOAT16:
+        return (
+            np.asarray(tensor.int32_data, dtype=np.uint16)
+            .reshape(dims)
+            .view(np.float16)
+        )
+
+    # bfloat16 is stored as int32 (uint16 type); no numpy support for bf16
+    if tensor_dtype == TensorProto.BFLOAT16:
+        data = np.asarray(tensor.int32_data, dtype=np.int32)
+        return bfloat16_to_float32(data, dims)
+
+    if tensor_dtype == TensorProto.FLOAT8E4M3FN:
+        data = np.asarray(tensor.int32_data, dtype=np.int32)
+        return float8e4m3_to_float32(data, dims)
 
-        data = getattr(tensor, storage_field)
-        if (
-            tensor_dtype == TensorProto.COMPLEX64
-            or tensor_dtype == TensorProto.COMPLEX128
-        ):
-            data = combine_pairs_to_complex(data)
+    if tensor_dtype == TensorProto.FLOAT8E4M3FNUZ:
+        data = np.asarray(tensor.int32_data, dtype=np.int32)
+        return float8e4m3_to_float32(data, dims, uz=True)
 
-        return np.asarray(data, dtype=storage_np_dtype).astype(np_dtype).reshape(dims)
+    if tensor_dtype == TensorProto.FLOAT8E5M2:
+        data = np.asarray(tensor.int32_data, dtype=np.int32)
+        return float8e5m2_to_float32(data, dims)
+
+    if tensor_dtype == TensorProto.FLOAT8E5M2FNUZ:
+        data = np.asarray(tensor.int32_data, dtype=np.int32)
+        return float8e5m2_to_float32(data, dims, fn=True, uz=True)
+
+    data = getattr(tensor, storage_field)
+    if tensor_dtype in (TensorProto.COMPLEX64, TensorProto.COMPLEX128):
+        data = combine_pairs_to_complex(data)  # type: ignore[assignment,arg-type]
+
+    return np.asarray(data, dtype=storage_np_dtype).astype(np_dtype).reshape(dims)
 
 
 def from_array(arr: np.ndarray, name: Optional[str] = None) -> TensorProto:
@@ -173,9 +344,9 @@ def to_list(sequence: SequenceProto) -> List[Any]:
     """
     elem_type = sequence.elem_type
     if elem_type == SequenceProto.TENSOR:
-        return [to_array(v) for v in sequence.tensor_values]
+        return [to_array(v) for v in sequence.tensor_values]  # type: ignore[arg-type]
     if elem_type == SequenceProto.SPARSE_TENSOR:
-        return [to_array(v) for v in sequence.sparse_tensor_values]
+        return [to_array(v) for v in sequence.sparse_tensor_values]  # type: ignore[arg-type]
     if elem_type == SequenceProto.SEQUENCE:
         return [to_list(v) for v in sequence.sequence_values]
     if elem_type == SequenceProto.MAP:
@@ -183,9 +354,9 @@ def to_list(sequence: SequenceProto) -> List[Any]:
     raise TypeError("The element type in the input sequence is not supported.")
 
 
-def from_list(
+def from_list(  # pylint: disable=too-many-branches
     lst: List[Any], name: Optional[str] = None, dtype: Optional[int] = None
-) -> SequenceProto:
+) -> SequenceProto:  # pylint: disable=too-many-branches
     """Converts a list into a sequence def.
 
     Args:
@@ -230,8 +401,8 @@ def from_list(
         for seq in lst:
             sequence.sequence_values.extend([from_list(seq)])
     elif elem_type == SequenceProto.MAP:
-        for map in lst:
-            sequence.map_values.extend([from_dict(map)])
+        for mapping in lst:
+            sequence.map_values.extend([from_dict(mapping)])
     else:
         raise TypeError(
             "The element type in the input list is not a tensor, "
@@ -240,7 +411,7 @@ def from_list(
     return sequence
 
 
-def to_dict(map: MapProto) -> Dict[Any, Any]:
+def to_dict(map_proto: MapProto) -> Dict[Any, Any]:
     """Converts a map def to a Python dictionary.
 
     Args:
@@ -250,23 +421,23 @@ def to_dict(map: MapProto) -> Dict[Any, Any]:
         dict: the converted dictionary.
     """
     key_list: List[Any] = []
-    if map.key_type == TensorProto.STRING:
-        key_list = list(map.string_keys)
+    if map_proto.key_type == TensorProto.STRING:
+        key_list = list(map_proto.string_keys)
     else:
-        key_list = list(map.keys)
+        key_list = list(map_proto.keys)
 
-    value_list = to_list(map.values)
+    value_list = to_list(map_proto.values)
     if len(key_list) != len(value_list):
         raise IndexError(
             "Length of keys and values for MapProto (map name: ",
-            map.name,
+            map_proto.name,
             ") are not the same.",
         )
     dictionary = dict(zip(key_list, value_list))
     return dictionary
 
 
-def from_dict(dict: Dict[Any, Any], name: Optional[str] = None) -> MapProto:
+def from_dict(dict_: Dict[Any, Any], name: Optional[str] = None) -> MapProto:
     """Converts a Python dictionary into a map def.
 
     Args:
@@ -276,10 +447,10 @@ def from_dict(dict: Dict[Any, Any], name: Optional[str] = None) -> MapProto:
     Returns:
         MapProto: the converted map def.
     """
-    map = MapProto()
+    map_proto = MapProto()
     if name:
-        map.name = name
-    keys = list(dict.keys())
+        map_proto.name = name
+    keys = list(dict_)
     raw_key_type = np.array(keys[0]).dtype
     key_type = helper.np_dtype_to_tensor_dtype(raw_key_type)
 
@@ -294,13 +465,19 @@ def from_dict(dict: Dict[Any, Any], name: Optional[str] = None) -> MapProto:
         TensorProto.UINT64,
     ]
 
-    if not all(isinstance(key, raw_key_type) for key in keys):
+    if not all(
+        isinstance(
+            key,
+            raw_key_type,  # type: ignore[arg-type]
+        )
+        for key in keys
+    ):
         raise TypeError(
             "The key type in the input dictionary is not the same "
             "for all keys and therefore is not valid as a map."
         )
 
-    values = list(dict.values())
+    values = list(dict_.values())
     raw_value_type = type(values[0])
     if not all(isinstance(val, raw_value_type) for val in values):
         raise TypeError(
@@ -310,13 +487,13 @@ def from_dict(dict: Dict[Any, Any], name: Optional[str] = None) -> MapProto:
 
     value_seq = from_list(values)
 
-    map.key_type = key_type
+    map_proto.key_type = key_type
     if key_type == TensorProto.STRING:
-        map.string_keys.extend(keys)
+        map_proto.string_keys.extend(keys)
     elif key_type in valid_key_int_types:
-        map.keys.extend(keys)
-    map.values.CopyFrom(value_seq)
-    return map
+        map_proto.keys.extend(keys)
+    map_proto.values.CopyFrom(value_seq)
+    return map_proto
 
 
 def to_optional(optional: OptionalProto) -> Optional[Any]:
@@ -334,7 +511,7 @@ def to_optional(optional: OptionalProto) -> Optional[Any]:
     if elem_type == OptionalProto.TENSOR:
         return to_array(optional.tensor_value)
     if elem_type == OptionalProto.SPARSE_TENSOR:
-        return to_array(optional.sparse_tensor_value)
+        return to_array(optional.sparse_tensor_value)  # type: ignore[arg-type]
     if elem_type == OptionalProto.SEQUENCE:
         return to_list(optional.sequence_value)
     if elem_type == OptionalProto.MAP:
@@ -366,8 +543,9 @@ def from_optional(
 
     if dtype:
         # dtype must be a valid OptionalProto.DataType
-        valid_dtypes = [v for v in OptionalProto.DataType.values()]
-        assert dtype in valid_dtypes
+        valid_dtypes = list(OptionalProto.DataType.values())
+        if dtype not in valid_dtypes:
+            raise TypeError(f"{dtype} must be a valid OptionalProto.DataType.")
         elem_type = dtype
     elif isinstance(opt, dict):
         elem_type = OptionalProto.MAP
@@ -407,3 +585,36 @@ def convert_endian(tensor: TensorProto) -> None:
     tensor.raw_data = (
         np.frombuffer(tensor.raw_data, dtype=np_dtype).byteswap().tobytes()
     )
+
+
+def create_random_int(
+    input_shape: Tuple[int], dtype: np.dtype, seed: int = 1
+) -> np.ndarray:
+    """
+    Create random integer array for backend/test/case/node.
+
+    Args:
+        input_shape: specify the shape for the returned integer array.
+        dtype: specify the NumPy data type for the returned integer array.
+        seed: (optional) the seed for np.random.
+
+    Returns:
+        np.ndarray: the created random integer array.
+    """
+    np.random.seed(seed)
+    if dtype in (
+        np.uint8,
+        np.uint16,
+        np.uint32,
+        np.uint64,
+        np.int8,
+        np.int16,
+        np.int32,
+        np.int64,
+    ):
+        # the range of np.random.randint is int32; set a fixed boundary if overflow
+        end = min(np.iinfo(dtype).max, np.iinfo(np.int32).max)
+        start = max(np.iinfo(dtype).min, np.iinfo(np.int32).min)
+        return np.random.randint(start, end, size=input_shape).astype(dtype)
+    else:
+        raise TypeError(f"{dtype} is not supported by create_random_int.")

onnx/onnx-ml.proto

@@ -98,13 +98,17 @@ enum Version {
   // - Implicitly add inference graph into each TrainingInfoProto's algorithm.
   IR_VERSION_2020_5_8 = 0x0000000000000007;
 
-  // IR VERSION 8 published on <TBD>
+  // IR VERSION 8 published on July 30, 2021
   // Introduce TypeProto.SparseTensor
   // Introduce TypeProto.Optional
   // Added a list of FunctionProtos local to the model
   // Deprecated since_version and operator status from FunctionProto
-  IR_VERSION = 0x0000000000000008;
+  IR_VERSION_2021_7_30 = 0x0000000000000008;
 
+  // IR VERSION 9 published on TBD
+  // Added AttributeProto to FunctionProto so that default attribute values can be set.
+  // Added FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ.
+  IR_VERSION = 0x0000000000000009;
 }
 
 // Attributes
@@ -507,6 +511,17 @@ message TensorProto {
     // This format has 1 sign bit, 8 exponent bits, and 7 mantissa bits.
     BFLOAT16 = 16;
 
+    // Non-IEEE floating-point format based on papers
+    // FP8 Formats for Deep Learning, https://arxiv.org/abs/2209.05433,
+    // 8-bit Numerical Formats For Deep Neural Networks, https://arxiv.org/pdf/2206.02915.pdf.
+    // Operators supported FP8 are Cast, CastLike, QuantizeLinear, DequantizeLinear.
+    // The computation usually happens inside a block quantize / dequantize
+    // fused by the runtime.
+    FLOAT8E4M3FN = 17;    // float 8, mostly used for coefficients, supports nan, not inf 
+    FLOAT8E4M3FNUZ = 18;  // float 8, mostly used for coefficients, supports nan, not inf, no negative zero 
+    FLOAT8E5M2 = 19;      // follows IEEE 754, supports nan, inf, mostly used for gradients
+    FLOAT8E5M2FNUZ = 20;  // follows IEEE 754, supports nan, inf, mostly used for gradients, no negative zero
+
     // Future extensions go here.
   }
 
@@ -540,11 +555,11 @@ message TensorProto {
   // When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
   repeated float float_data = 4 [packed = true];
 
-  // For int32, uint8, int8, uint16, int16, bool, and float16 values
-  // float16 values must be bit-wise converted to an uint16_t prior
+  // For int32, uint8, int8, uint16, int16, bool, float8, and float16 values
+  // float16 and float8 values must be bit-wise converted to an uint16_t prior
   // to writing to the buffer.
   // When this field is present, the data_type field MUST be
-  // INT32, INT16, INT8, UINT16, UINT8, BOOL, FLOAT16 or BFLOAT16
+  // INT32, INT16, INT8, UINT16, UINT8, BOOL, FLOAT16, BFLOAT16, FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ
   repeated int32 int32_data = 5 [packed = true];
 
   // For strings.
@@ -795,9 +810,16 @@ message FunctionProto {
   repeated string input = 4;
   repeated string output = 5;
 
-  // The attributes of the function.
+  // The attribute parameters of the function.
+  // It is for function parameters without default values.
   repeated string attribute = 6;
 
+  // The attribute protos of the function.
+  // It is for function attributes with default values.
+  // A function attribute shall be represented either as
+  // a string attribute or an AttributeProto, not both.
+  repeated AttributeProto attribute_proto = 11;
+
   // The nodes in the function.
   repeated NodeProto node = 7;
   // A human-readable documentation for this function. Markdown is allowed.

onnx/onnx-operators-ml.proto

@@ -4,7 +4,7 @@
 
 
 // Copyright (c) ONNX Project Contributors.
-// Licensed under the MIT license.
+// Licensed under the Apache-2.0 license.
 
 syntax = "proto2";
 

onnx/onnx-operators.in.proto

@@ -1,5 +1,5 @@
 // Copyright (c) ONNX Project Contributors.
-// Licensed under the MIT license.
+// Licensed under the Apache-2.0 license.
 
 syntax = "proto2";
 

onnx/onnx-operators.proto

@@ -4,7 +4,7 @@
 
 
 // Copyright (c) ONNX Project Contributors.
-// Licensed under the MIT license.
+// Licensed under the Apache-2.0 license.
 
 syntax = "proto2";
 

onnx/onnx.in.proto

@@ -95,13 +95,17 @@ enum Version {
   // - Implicitly add inference graph into each TrainingInfoProto's algorithm.
   IR_VERSION_2020_5_8 = 0x0000000000000007;
 
-  // IR VERSION 8 published on <TBD>
+  // IR VERSION 8 published on July 30, 2021
   // Introduce TypeProto.SparseTensor
   // Introduce TypeProto.Optional
   // Added a list of FunctionProtos local to the model
   // Deprecated since_version and operator status from FunctionProto
-  IR_VERSION = 0x0000000000000008;
+  IR_VERSION_2021_7_30 = 0x0000000000000008;
 
+  // IR VERSION 9 published on TBD
+  // Added AttributeProto to FunctionProto so that default attribute values can be set.
+  // Added FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ.
+  IR_VERSION = 0x0000000000000009;
 }
 
 // Attributes
@@ -504,6 +508,17 @@ message TensorProto {
     // This format has 1 sign bit, 8 exponent bits, and 7 mantissa bits.
     BFLOAT16 = 16;
 
+    // Non-IEEE floating-point format based on papers
+    // FP8 Formats for Deep Learning, https://arxiv.org/abs/2209.05433,
+    // 8-bit Numerical Formats For Deep Neural Networks, https://arxiv.org/pdf/2206.02915.pdf.
+    // Operators supported FP8 are Cast, CastLike, QuantizeLinear, DequantizeLinear.
+    // The computation usually happens inside a block quantize / dequantize
+    // fused by the runtime.
+    FLOAT8E4M3FN = 17;    // float 8, mostly used for coefficients, supports nan, not inf 
+    FLOAT8E4M3FNUZ = 18;  // float 8, mostly used for coefficients, supports nan, not inf, no negative zero 
+    FLOAT8E5M2 = 19;      // follows IEEE 754, supports nan, inf, mostly used for gradients
+    FLOAT8E5M2FNUZ = 20;  // follows IEEE 754, supports nan, inf, mostly used for gradients, no negative zero
+
     // Future extensions go here.
   }
 
@@ -537,11 +552,11 @@ message TensorProto {
   // When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
   repeated float float_data = 4 [packed = true];
 
-  // For int32, uint8, int8, uint16, int16, bool, and float16 values
-  // float16 values must be bit-wise converted to an uint16_t prior
+  // For int32, uint8, int8, uint16, int16, bool, float8, and float16 values
+  // float16 and float8 values must be bit-wise converted to an uint16_t prior
   // to writing to the buffer.
   // When this field is present, the data_type field MUST be
-  // INT32, INT16, INT8, UINT16, UINT8, BOOL, FLOAT16 or BFLOAT16
+  // INT32, INT16, INT8, UINT16, UINT8, BOOL, FLOAT16, BFLOAT16, FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ
   repeated int32 int32_data = 5 [packed = true];
 
   // For strings.
@@ -796,9 +811,16 @@ message FunctionProto {
   repeated string input = 4;
   repeated string output = 5;
 
-  // The attributes of the function.
+  // The attribute parameters of the function.
+  // It is for function parameters without default values.
   repeated string attribute = 6;
 
+  // The attribute protos of the function.
+  // It is for function attributes with default values.
+  // A function attribute shall be represented either as
+  // a string attribute or an AttributeProto, not both.
+  repeated AttributeProto attribute_proto = 11;
+
   // The nodes in the function.
   repeated NodeProto node = 7;
   // A human-readable documentation for this function. Markdown is allowed.

onnx/onnx.proto

@@ -96,13 +96,17 @@ enum Version {
   // - Implicitly add inference graph into each TrainingInfoProto's algorithm.
   IR_VERSION_2020_5_8 = 0x0000000000000007;
 
-  // IR VERSION 8 published on <TBD>
+  // IR VERSION 8 published on July 30, 2021
   // Introduce TypeProto.SparseTensor
   // Introduce TypeProto.Optional
   // Added a list of FunctionProtos local to the model
   // Deprecated since_version and operator status from FunctionProto
-  IR_VERSION = 0x0000000000000008;
+  IR_VERSION_2021_7_30 = 0x0000000000000008;
 
+  // IR VERSION 9 published on TBD
+  // Added AttributeProto to FunctionProto so that default attribute values can be set.
+  // Added FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ.
+  IR_VERSION = 0x0000000000000009;
 }
 
 // Attributes
@@ -505,6 +509,17 @@ message TensorProto {
     // This format has 1 sign bit, 8 exponent bits, and 7 mantissa bits.
     BFLOAT16 = 16;
 
+    // Non-IEEE floating-point format based on papers
+    // FP8 Formats for Deep Learning, https://arxiv.org/abs/2209.05433,
+    // 8-bit Numerical Formats For Deep Neural Networks, https://arxiv.org/pdf/2206.02915.pdf.
+    // Operators supported FP8 are Cast, CastLike, QuantizeLinear, DequantizeLinear.
+    // The computation usually happens inside a block quantize / dequantize
+    // fused by the runtime.
+    FLOAT8E4M3FN = 17;    // float 8, mostly used for coefficients, supports nan, not inf 
+    FLOAT8E4M3FNUZ = 18;  // float 8, mostly used for coefficients, supports nan, not inf, no negative zero 
+    FLOAT8E5M2 = 19;      // follows IEEE 754, supports nan, inf, mostly used for gradients
+    FLOAT8E5M2FNUZ = 20;  // follows IEEE 754, supports nan, inf, mostly used for gradients, no negative zero
+
     // Future extensions go here.
   }
 
@@ -538,11 +553,11 @@ message TensorProto {
   // When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
   repeated float float_data = 4 [packed = true];
 
-  // For int32, uint8, int8, uint16, int16, bool, and float16 values
-  // float16 values must be bit-wise converted to an uint16_t prior
+  // For int32, uint8, int8, uint16, int16, bool, float8, and float16 values
+  // float16 and float8 values must be bit-wise converted to an uint16_t prior
   // to writing to the buffer.
   // When this field is present, the data_type field MUST be
-  // INT32, INT16, INT8, UINT16, UINT8, BOOL, FLOAT16 or BFLOAT16
+  // INT32, INT16, INT8, UINT16, UINT8, BOOL, FLOAT16, BFLOAT16, FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ
   repeated int32 int32_data = 5 [packed = true];
 
   // For strings.
@@ -779,9 +794,16 @@ message FunctionProto {
   repeated string input = 4;
   repeated string output = 5;
 
-  // The attributes of the function.
+  // The attribute parameters of the function.
+  // It is for function parameters without default values.
   repeated string attribute = 6;
 
+  // The attribute protos of the function.
+  // It is for function attributes with default values.
+  // A function attribute shall be represented either as
+  // a string attribute or an AttributeProto, not both.
+  repeated AttributeProto attribute_proto = 11;
+
   // The nodes in the function.
   repeated NodeProto node = 7;
   // A human-readable documentation for this function. Markdown is allowed.

onnx/onnx_data_pb2.pyi

@@ -1,4 +1,5 @@
-# @generated by generate_proto_mypy_stubs.py.  Do not edit!
+# @generated by protoc-gen-mypy.py.  Do not edit!
+# mypy: disable-error-code=override
 from google.protobuf.message import (  # type: ignore
     Message,
 )