Add onnx module

8 files changed, 3694 insertions, 0 deletions

diff --git a/go.work b/go.work
index d836d80..1c74e9c 100644
--- a/go.work
+++ b/go.work
@@ -5,6 +5,7 @@ use (
 	./gpt2
 	./llm
 	./mbpe
+	./onnx
 	./research/lesci
 	./tensor
 	./tokenizer
diff --git a/onnx/.gitignore b/onnx/.gitignore
new file mode 100644
index 0000000..900757b
--- /dev/null
+++ b/onnx/.gitignore
@@ -0,0 +1 @@
+scripts/onnx.proto
diff --git a/onnx/cmd/extract/main.go b/onnx/cmd/extract/main.go
new file mode 100644
index 0000000..d8f8358
--- /dev/null
+++ b/onnx/cmd/extract/main.go
@@ -0,0 +1,23 @@
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"go.jknobloc.com/x/onnx"
+	"go.jknobloc.com/x/tensor"
+)
+
+func main() {
+	data, shape, err := onnx.ExtractInitializer("gpt2/models/base/model.onnx", "transformer.wte.weight")
+
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	t := tensor.NewDense[float32](shape, data)
+
+	eot := t.Select(0, 50256).Contiguous()
+
+	fmt.Println(eot)
+}
diff --git a/onnx/go.mod b/onnx/go.mod
new file mode 100644
index 0000000..35cf660
--- /dev/null
+++ b/onnx/go.mod
@@ -0,0 +1,8 @@
+module go.jknobloc.com/x/onnx
+
+go 1.25.0
+
+require (
+	go.jknobloc.com/x/tensor v0.0.0-20260414175339-402477b200d1
+	google.golang.org/protobuf v1.36.11
+)
diff --git a/onnx/go.sum b/onnx/go.sum
new file mode 100644
index 0000000..20233cc
--- /dev/null
+++ b/onnx/go.sum
@@ -0,0 +1,6 @@
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+go.jknobloc.com/x/tensor v0.0.0-20260414175339-402477b200d1 h1:dauYEeyAjhzZ1hyyAR9exszAUKeFIqrrBNaAGboZaaA=
+go.jknobloc.com/x/tensor v0.0.0-20260414175339-402477b200d1/go.mod h1:Citqq246efr+IGX0RBARqDm4gXwvPA4aNAz3F8Il6kk=
+google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
diff --git a/onnx/internal/pb/onnx.pb.go b/onnx/internal/pb/onnx.pb.go
new file mode 100644
index 0000000..31bc0de
--- /dev/null
+++ b/onnx/internal/pb/onnx.pb.go
@@ -0,0 +1,3568 @@
+//
+// WARNING: This file is automatically generated!  Please edit onnx.in.proto.
+//
+
+// SPDX-License-Identifier: Apache-2.0
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.11
+// 	protoc        v7.34.1
+// source: onnx.proto
+
+package pb
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+	unsafe "unsafe"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+// Versioning
+//
+// ONNX versioning is specified in docs/IR.md and elaborated on in docs/Versioning.md
+//
+// To be compatible with both proto2 and proto3, we will use a version number
+// that is not defined by the default value but an explicit enum number.
+type Version int32
+
+const (
+	// proto3 requires the first enum value to be zero.
+	// We add this just to appease the compiler.
+	Version__START_VERSION Version = 0
+	// The version field is always serialized and we will use it to store the
+	// version that the  graph is generated from. This helps us set up version
+	// control.
+	// For the IR, we are using simple numbers starting with 0x00000001,
+	// which was the version we published on Oct 10, 2017.
+	Version_IR_VERSION_2017_10_10 Version = 1
+	// IR_VERSION 2 published on Oct 30, 2017
+	// - Added type discriminator to AttributeProto to support proto3 users
+	Version_IR_VERSION_2017_10_30 Version = 2
+	// IR VERSION 3 published on Nov 3, 2017
+	// - For operator versioning:
+	//   - Added new message OperatorSetIdProto
+	//   - Added opset_import in ModelProto
+	//
+	// - For vendor extensions, added domain in NodeProto
+	Version_IR_VERSION_2017_11_3 Version = 3
+	// IR VERSION 4 published on Jan 22, 2019
+	// - Relax constraint that initializers should be a subset of graph inputs
+	// - Add type BFLOAT16
+	Version_IR_VERSION_2019_1_22 Version = 4
+	// IR VERSION 5 published on March 18, 2019
+	// - Add message TensorAnnotation.
+	// - Add quantization annotation in GraphProto to map tensor with its scale and zero point quantization parameters.
+	Version_IR_VERSION_2019_3_18 Version = 5
+	// IR VERSION 6 published on Sep 19, 2019
+	// - Add support for sparse tensor constants stored in model.
+	//   - Add message SparseTensorProto
+	//   - Add sparse initializers
+	Version_IR_VERSION_2019_9_19 Version = 6
+	// IR VERSION 7 published on May 8, 2020
+	//   - Add support to allow function body graph to rely on multiple external operator sets.
+	//   - Add a list to promote inference graph's initializers to global and
+	//     mutable variables. Global variables are visible in all graphs of the
+	//     stored models.
+	//   - Add message TrainingInfoProto to store initialization
+	//     method and training algorithm. The execution of TrainingInfoProto
+	//     can modify the values of mutable variables.
+	//   - Implicitly add inference graph into each TrainingInfoProto's algorithm.
+	Version_IR_VERSION_2020_5_8 Version = 7
+	// 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
+	Version_IR_VERSION_2021_7_30 Version = 8
+	// IR VERSION 9 published on May 5, 2023
+	// Added AttributeProto to FunctionProto so that default attribute values can be set.
+	// Added FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ.
+	Version_IR_VERSION_2023_5_5 Version = 9
+	// IR VERSION 10 published on March 25, 2024
+	// Added UINT4, INT4, overload field for functions and metadata_props on multiple proto definitions.
+	Version_IR_VERSION_2024_3_25 Version = 10
+	// IR VERSION 11 published on May 12, 2025
+	// Added FLOAT4E2M1, multi-device protobuf classes.
+	Version_IR_VERSION_2025_05_12 Version = 11
+	// IR VERSION 12 published on August 26, 2025
+	// Added FLOAT8E8M0.
+	Version_IR_VERSION_2025_08_26 Version = 12
+	// IR VERSION 13 published on November 6, 2025
+	// Added UINT2, INT2.
+	Version_IR_VERSION Version = 13
+)
+
+// Enum value maps for Version.
+var (
+	Version_name = map[int32]string{
+		0:  "_START_VERSION",
+		1:  "IR_VERSION_2017_10_10",
+		2:  "IR_VERSION_2017_10_30",
+		3:  "IR_VERSION_2017_11_3",
+		4:  "IR_VERSION_2019_1_22",
+		5:  "IR_VERSION_2019_3_18",
+		6:  "IR_VERSION_2019_9_19",
+		7:  "IR_VERSION_2020_5_8",
+		8:  "IR_VERSION_2021_7_30",
+		9:  "IR_VERSION_2023_5_5",
+		10: "IR_VERSION_2024_3_25",
+		11: "IR_VERSION_2025_05_12",
+		12: "IR_VERSION_2025_08_26",
+		13: "IR_VERSION",
+	}
+	Version_value = map[string]int32{
+		"_START_VERSION":        0,
+		"IR_VERSION_2017_10_10": 1,
+		"IR_VERSION_2017_10_30": 2,
+		"IR_VERSION_2017_11_3":  3,
+		"IR_VERSION_2019_1_22":  4,
+		"IR_VERSION_2019_3_18":  5,
+		"IR_VERSION_2019_9_19":  6,
+		"IR_VERSION_2020_5_8":   7,
+		"IR_VERSION_2021_7_30":  8,
+		"IR_VERSION_2023_5_5":   9,
+		"IR_VERSION_2024_3_25":  10,
+		"IR_VERSION_2025_05_12": 11,
+		"IR_VERSION_2025_08_26": 12,
+		"IR_VERSION":            13,
+	}
+)
+
+func (x Version) Enum() *Version {
+	p := new(Version)
+	*p = x
+	return p
+}
+
+func (x Version) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (Version) Descriptor() protoreflect.EnumDescriptor {
+	return file_onnx_proto_enumTypes[0].Descriptor()
+}
+
+func (Version) Type() protoreflect.EnumType {
+	return &file_onnx_proto_enumTypes[0]
+}
+
+func (x Version) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *Version) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = Version(num)
+	return nil
+}
+
+// Deprecated: Use Version.Descriptor instead.
+func (Version) EnumDescriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{0}
+}
+
+// Operator/function status.
+type OperatorStatus int32
+
+const (
+	OperatorStatus_EXPERIMENTAL OperatorStatus = 0
+	OperatorStatus_STABLE       OperatorStatus = 1
+)
+
+// Enum value maps for OperatorStatus.
+var (
+	OperatorStatus_name = map[int32]string{
+		0: "EXPERIMENTAL",
+		1: "STABLE",
+	}
+	OperatorStatus_value = map[string]int32{
+		"EXPERIMENTAL": 0,
+		"STABLE":       1,
+	}
+)
+
+func (x OperatorStatus) Enum() *OperatorStatus {
+	p := new(OperatorStatus)
+	*p = x
+	return p
+}
+
+func (x OperatorStatus) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (OperatorStatus) Descriptor() protoreflect.EnumDescriptor {
+	return file_onnx_proto_enumTypes[1].Descriptor()
+}
+
+func (OperatorStatus) Type() protoreflect.EnumType {
+	return &file_onnx_proto_enumTypes[1]
+}
+
+func (x OperatorStatus) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *OperatorStatus) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = OperatorStatus(num)
+	return nil
+}
+
+// Deprecated: Use OperatorStatus.Descriptor instead.
+func (OperatorStatus) EnumDescriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{1}
+}
+
+// Note: this enum is structurally identical to the OpSchema::AttrType
+// enum defined in schema.h.  If you rev one, you likely need to rev the other.
+type AttributeProto_AttributeType int32
+
+const (
+	AttributeProto_UNDEFINED      AttributeProto_AttributeType = 0
+	AttributeProto_FLOAT          AttributeProto_AttributeType = 1
+	AttributeProto_INT            AttributeProto_AttributeType = 2
+	AttributeProto_STRING         AttributeProto_AttributeType = 3
+	AttributeProto_TENSOR         AttributeProto_AttributeType = 4
+	AttributeProto_GRAPH          AttributeProto_AttributeType = 5
+	AttributeProto_SPARSE_TENSOR  AttributeProto_AttributeType = 11
+	AttributeProto_TYPE_PROTO     AttributeProto_AttributeType = 13
+	AttributeProto_FLOATS         AttributeProto_AttributeType = 6
+	AttributeProto_INTS           AttributeProto_AttributeType = 7
+	AttributeProto_STRINGS        AttributeProto_AttributeType = 8
+	AttributeProto_TENSORS        AttributeProto_AttributeType = 9
+	AttributeProto_GRAPHS         AttributeProto_AttributeType = 10
+	AttributeProto_SPARSE_TENSORS AttributeProto_AttributeType = 12
+	AttributeProto_TYPE_PROTOS    AttributeProto_AttributeType = 14
+)
+
+// Enum value maps for AttributeProto_AttributeType.
+var (
+	AttributeProto_AttributeType_name = map[int32]string{
+		0:  "UNDEFINED",
+		1:  "FLOAT",
+		2:  "INT",
+		3:  "STRING",
+		4:  "TENSOR",
+		5:  "GRAPH",
+		11: "SPARSE_TENSOR",
+		13: "TYPE_PROTO",
+		6:  "FLOATS",
+		7:  "INTS",
+		8:  "STRINGS",
+		9:  "TENSORS",
+		10: "GRAPHS",
+		12: "SPARSE_TENSORS",
+		14: "TYPE_PROTOS",
+	}
+	AttributeProto_AttributeType_value = map[string]int32{
+		"UNDEFINED":      0,
+		"FLOAT":          1,
+		"INT":            2,
+		"STRING":         3,
+		"TENSOR":         4,
+		"GRAPH":          5,
+		"SPARSE_TENSOR":  11,
+		"TYPE_PROTO":     13,
+		"FLOATS":         6,
+		"INTS":           7,
+		"STRINGS":        8,
+		"TENSORS":        9,
+		"GRAPHS":         10,
+		"SPARSE_TENSORS": 12,
+		"TYPE_PROTOS":    14,
+	}
+)
+
+func (x AttributeProto_AttributeType) Enum() *AttributeProto_AttributeType {
+	p := new(AttributeProto_AttributeType)
+	*p = x
+	return p
+}
+
+func (x AttributeProto_AttributeType) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (AttributeProto_AttributeType) Descriptor() protoreflect.EnumDescriptor {
+	return file_onnx_proto_enumTypes[2].Descriptor()
+}
+
+func (AttributeProto_AttributeType) Type() protoreflect.EnumType {
+	return &file_onnx_proto_enumTypes[2]
+}
+
+func (x AttributeProto_AttributeType) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *AttributeProto_AttributeType) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = AttributeProto_AttributeType(num)
+	return nil
+}
+
+// Deprecated: Use AttributeProto_AttributeType.Descriptor instead.
+func (AttributeProto_AttributeType) EnumDescriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{0, 0}
+}
+
+type TensorProto_DataType int32
+
+const (
+	TensorProto_UNDEFINED TensorProto_DataType = 0
+	// Basic types.
+	TensorProto_FLOAT  TensorProto_DataType = 1 // float
+	TensorProto_UINT8  TensorProto_DataType = 2 // uint8_t
+	TensorProto_INT8   TensorProto_DataType = 3 // int8_t
+	TensorProto_UINT16 TensorProto_DataType = 4 // uint16_t
+	TensorProto_INT16  TensorProto_DataType = 5 // int16_t
+	TensorProto_INT32  TensorProto_DataType = 6 // int32_t
+	TensorProto_INT64  TensorProto_DataType = 7 // int64_t
+	TensorProto_STRING TensorProto_DataType = 8 // string
+	TensorProto_BOOL   TensorProto_DataType = 9 // bool
+	// IEEE754 half-precision floating-point format (16 bits wide).
+	// This format has 1 sign bit, 5 exponent bits, and 10 mantissa bits.
+	TensorProto_FLOAT16    TensorProto_DataType = 10
+	TensorProto_DOUBLE     TensorProto_DataType = 11
+	TensorProto_UINT32     TensorProto_DataType = 12
+	TensorProto_UINT64     TensorProto_DataType = 13
+	TensorProto_COMPLEX64  TensorProto_DataType = 14 // complex with float32 real and imaginary components
+	TensorProto_COMPLEX128 TensorProto_DataType = 15 // complex with float64 real and imaginary components
+	// Non-IEEE floating-point format based on IEEE754 single-precision
+	// floating-point number truncated to 16 bits.
+	// This format has 1 sign bit, 8 exponent bits, and 7 mantissa bits.
+	TensorProto_BFLOAT16 TensorProto_DataType = 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.
+	TensorProto_FLOAT8E4M3FN   TensorProto_DataType = 17 // float 8, mostly used for coefficients, supports nan, not inf
+	TensorProto_FLOAT8E4M3FNUZ TensorProto_DataType = 18 // float 8, mostly used for coefficients, supports nan, not inf, no negative zero
+	TensorProto_FLOAT8E5M2     TensorProto_DataType = 19 // follows IEEE 754, supports nan, inf, mostly used for gradients
+	TensorProto_FLOAT8E5M2FNUZ TensorProto_DataType = 20 // follows IEEE 754, supports nan, not inf, mostly used for gradients, no negative zero
+	// 4-bit integer data types
+	TensorProto_UINT4 TensorProto_DataType = 21 // Unsigned integer in range [0, 15]
+	TensorProto_INT4  TensorProto_DataType = 22 // Signed integer in range [-8, 7], using two's-complement representation
+	// 4-bit floating point data types
+	TensorProto_FLOAT4E2M1 TensorProto_DataType = 23
+	// E8M0 type used as the scale for microscaling (MX) formats:
+	// https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf
+	TensorProto_FLOAT8E8M0 TensorProto_DataType = 24
+	// 2-bit integer data type
+	TensorProto_UINT2 TensorProto_DataType = 25 // Unsigned integer in range [0, 3]
+	TensorProto_INT2  TensorProto_DataType = 26 // Signed integer in range [-2, 1], using two's complement representation
+)
+
+// Enum value maps for TensorProto_DataType.
+var (
+	TensorProto_DataType_name = map[int32]string{
+		0:  "UNDEFINED",
+		1:  "FLOAT",
+		2:  "UINT8",
+		3:  "INT8",
+		4:  "UINT16",
+		5:  "INT16",
+		6:  "INT32",
+		7:  "INT64",
+		8:  "STRING",
+		9:  "BOOL",
+		10: "FLOAT16",
+		11: "DOUBLE",
+		12: "UINT32",
+		13: "UINT64",
+		14: "COMPLEX64",
+		15: "COMPLEX128",
+		16: "BFLOAT16",
+		17: "FLOAT8E4M3FN",
+		18: "FLOAT8E4M3FNUZ",
+		19: "FLOAT8E5M2",
+		20: "FLOAT8E5M2FNUZ",
+		21: "UINT4",
+		22: "INT4",
+		23: "FLOAT4E2M1",
+		24: "FLOAT8E8M0",
+		25: "UINT2",
+		26: "INT2",
+	}
+	TensorProto_DataType_value = map[string]int32{
+		"UNDEFINED":      0,
+		"FLOAT":          1,
+		"UINT8":          2,
+		"INT8":           3,
+		"UINT16":         4,
+		"INT16":          5,
+		"INT32":          6,
+		"INT64":          7,
+		"STRING":         8,
+		"BOOL":           9,
+		"FLOAT16":        10,
+		"DOUBLE":         11,
+		"UINT32":         12,
+		"UINT64":         13,
+		"COMPLEX64":      14,
+		"COMPLEX128":     15,
+		"BFLOAT16":       16,
+		"FLOAT8E4M3FN":   17,
+		"FLOAT8E4M3FNUZ": 18,
+		"FLOAT8E5M2":     19,
+		"FLOAT8E5M2FNUZ": 20,
+		"UINT4":          21,
+		"INT4":           22,
+		"FLOAT4E2M1":     23,
+		"FLOAT8E8M0":     24,
+		"UINT2":          25,
+		"INT2":           26,
+	}
+)
+
+func (x TensorProto_DataType) Enum() *TensorProto_DataType {
+	p := new(TensorProto_DataType)
+	*p = x
+	return p
+}
+
+func (x TensorProto_DataType) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (TensorProto_DataType) Descriptor() protoreflect.EnumDescriptor {
+	return file_onnx_proto_enumTypes[3].Descriptor()
+}
+
+func (TensorProto_DataType) Type() protoreflect.EnumType {
+	return &file_onnx_proto_enumTypes[3]
+}
+
+func (x TensorProto_DataType) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *TensorProto_DataType) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = TensorProto_DataType(num)
+	return nil
+}
+
+// Deprecated: Use TensorProto_DataType.Descriptor instead.
+func (TensorProto_DataType) EnumDescriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{14, 0}
+}
+
+// Location of the data for this tensor. MUST be one of:
+// - DEFAULT - data stored inside the protobuf message. Data is stored in raw_data (if set) otherwise in type-specified field.
+// - EXTERNAL - data stored in an external location as described by external_data field.
+type TensorProto_DataLocation int32
+
+const (
+	TensorProto_DEFAULT  TensorProto_DataLocation = 0
+	TensorProto_EXTERNAL TensorProto_DataLocation = 1
+)
+
+// Enum value maps for TensorProto_DataLocation.
+var (
+	TensorProto_DataLocation_name = map[int32]string{
+		0: "DEFAULT",
+		1: "EXTERNAL",
+	}
+	TensorProto_DataLocation_value = map[string]int32{
+		"DEFAULT":  0,
+		"EXTERNAL": 1,
+	}
+)
+
+func (x TensorProto_DataLocation) Enum() *TensorProto_DataLocation {
+	p := new(TensorProto_DataLocation)
+	*p = x
+	return p
+}
+
+func (x TensorProto_DataLocation) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (TensorProto_DataLocation) Descriptor() protoreflect.EnumDescriptor {
+	return file_onnx_proto_enumTypes[4].Descriptor()
+}
+
+func (TensorProto_DataLocation) Type() protoreflect.EnumType {
+	return &file_onnx_proto_enumTypes[4]
+}
+
+func (x TensorProto_DataLocation) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *TensorProto_DataLocation) UnmarshalJSON(b []byte) error {
+	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+	if err != nil {
+		return err
+	}
+	*x = TensorProto_DataLocation(num)
+	return nil
+}
+
+// Deprecated: Use TensorProto_DataLocation.Descriptor instead.
+func (TensorProto_DataLocation) EnumDescriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{14, 1}
+}
+
+// Attributes
+//
+// A named attribute containing either singular float, integer, string, graph,
+// and tensor values, or repeated float, integer, string, graph, and tensor values.
+// An AttributeProto MUST contain the name field, and *only one* of the
+// following content fields, effectively enforcing a C/C++ union equivalent.
+type AttributeProto struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// The name field MUST be present for this version of the IR.
+	Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` // namespace Attribute
+	// if ref_attr_name is not empty, ref_attr_name is the attribute name in parent function.
+	// In this case, this AttributeProto does not contain data, and it's a reference of attribute
+	// in parent scope.
+	// NOTE: This should ONLY be used in function (sub-graph). It's invalid to be used in main graph.
+	RefAttrName *string `protobuf:"bytes,21,opt,name=ref_attr_name,json=refAttrName" json:"ref_attr_name,omitempty"`
+	// A human-readable documentation for this attribute. Markdown is allowed.
+	DocString *string `protobuf:"bytes,13,opt,name=doc_string,json=docString" json:"doc_string,omitempty"`
+	// The type field MUST be present for this version of the IR.
+	// For 0.0.1 versions of the IR, this field was not defined, and
+	// implementations needed to use has_field heuristics to determine
+	// which value field was in use.  For IR_VERSION 0.0.2 or later, this
+	// field MUST be set and match the f|i|s|t|... field in use.  This
+	// change was made to accommodate proto3 implementations.
+	Type *AttributeProto_AttributeType `protobuf:"varint,20,opt,name=type,enum=onnx.AttributeProto_AttributeType" json:"type,omitempty"` // discriminator that indicates which field below is in use
+	// Exactly ONE of the following fields must be present for this version of the IR
+	F            *float32           `protobuf:"fixed32,2,opt,name=f" json:"f,omitempty"`                                          // float
+	I            *int64             `protobuf:"varint,3,opt,name=i" json:"i,omitempty"`                                           // int
+	S            []byte             `protobuf:"bytes,4,opt,name=s" json:"s,omitempty"`                                            // UTF-8 string
+	T            *TensorProto       `protobuf:"bytes,5,opt,name=t" json:"t,omitempty"`                                            // tensor value
+	G            *GraphProto        `protobuf:"bytes,6,opt,name=g" json:"g,omitempty"`                                            // graph
+	SparseTensor *SparseTensorProto `protobuf:"bytes,22,opt,name=sparse_tensor,json=sparseTensor" json:"sparse_tensor,omitempty"` // sparse tensor value
+	// Do not use field below, it's deprecated.
+	// optional ValueProto v = 12;         // value - subsumes everything but graph
+	Tp            *TypeProto           `protobuf:"bytes,14,opt,name=tp" json:"tp,omitempty"`                                            // type proto
+	Floats        []float32            `protobuf:"fixed32,7,rep,name=floats" json:"floats,omitempty"`                                   // list of floats
+	Ints          []int64              `protobuf:"varint,8,rep,name=ints" json:"ints,omitempty"`                                        // list of ints
+	Strings       [][]byte             `protobuf:"bytes,9,rep,name=strings" json:"strings,omitempty"`                                   // list of UTF-8 strings
+	Tensors       []*TensorProto       `protobuf:"bytes,10,rep,name=tensors" json:"tensors,omitempty"`                                  // list of tensors
+	Graphs        []*GraphProto        `protobuf:"bytes,11,rep,name=graphs" json:"graphs,omitempty"`                                    // list of graph
+	SparseTensors []*SparseTensorProto `protobuf:"bytes,23,rep,name=sparse_tensors,json=sparseTensors" json:"sparse_tensors,omitempty"` // list of sparse tensors
+	TypeProtos    []*TypeProto         `protobuf:"bytes,15,rep,name=type_protos,json=typeProtos" json:"type_protos,omitempty"`          // list of type protos
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *AttributeProto) Reset() {
+	*x = AttributeProto{}
+	mi := &file_onnx_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *AttributeProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*AttributeProto) ProtoMessage() {}
+
+func (x *AttributeProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[0]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use AttributeProto.ProtoReflect.Descriptor instead.
+func (*AttributeProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *AttributeProto) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
+	}
+	return ""
+}
+
+func (x *AttributeProto) GetRefAttrName() string {
+	if x != nil && x.RefAttrName != nil {
+		return *x.RefAttrName
+	}
+	return ""
+}
+
+func (x *AttributeProto) GetDocString() string {
+	if x != nil && x.DocString != nil {
+		return *x.DocString
+	}
+	return ""
+}
+
+func (x *AttributeProto) GetType() AttributeProto_AttributeType {
+	if x != nil && x.Type != nil {
+		return *x.Type
+	}
+	return AttributeProto_UNDEFINED
+}
+
+func (x *AttributeProto) GetF() float32 {
+	if x != nil && x.F != nil {
+		return *x.F
+	}
+	return 0
+}
+
+func (x *AttributeProto) GetI() int64 {
+	if x != nil && x.I != nil {
+		return *x.I
+	}
+	return 0
+}
+
+func (x *AttributeProto) GetS() []byte {
+	if x != nil {
+		return x.S
+	}
+	return nil
+}
+
+func (x *AttributeProto) GetT() *TensorProto {
+	if x != nil {
+		return x.T
+	}
+	return nil
+}
+
+func (x *AttributeProto) GetG() *GraphProto {
+	if x != nil {
+		return x.G
+	}
+	return nil
+}
+
+func (x *AttributeProto) GetSparseTensor() *SparseTensorProto {
+	if x != nil {
+		return x.SparseTensor
+	}
+	return nil
+}
+
+func (x *AttributeProto) GetTp() *TypeProto {
+	if x != nil {
+		return x.Tp
+	}
+	return nil
+}
+
+func (x *AttributeProto) GetFloats() []float32 {
+	if x != nil {
+		return x.Floats
+	}
+	return nil
+}
+
+func (x *AttributeProto) GetInts() []int64 {
+	if x != nil {
+		return x.Ints
+	}
+	return nil
+}
+
+func (x *AttributeProto) GetStrings() [][]byte {
+	if x != nil {
+		return x.Strings
+	}
+	return nil
+}
+
+func (x *AttributeProto) GetTensors() []*TensorProto {
+	if x != nil {
+		return x.Tensors
+	}
+	return nil
+}
+
+func (x *AttributeProto) GetGraphs() []*GraphProto {
+	if x != nil {
+		return x.Graphs
+	}
+	return nil
+}
+
+func (x *AttributeProto) GetSparseTensors() []*SparseTensorProto {
+	if x != nil {
+		return x.SparseTensors
+	}
+	return nil
+}
+
+func (x *AttributeProto) GetTypeProtos() []*TypeProto {
+	if x != nil {
+		return x.TypeProtos
+	}
+	return nil
+}
+
+// Defines information on value, including the name, the type, and
+// the shape of the value.
+type ValueInfoProto struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// This field MUST be present in this version of the IR.
+	Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` // namespace Value
+	// This field MUST be present in this version of the IR for
+	// inputs and outputs of the top-level graph.
+	Type *TypeProto `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
+	// A human-readable documentation for this value. Markdown is allowed.
+	DocString *string `protobuf:"bytes,3,opt,name=doc_string,json=docString" json:"doc_string,omitempty"`
+	// Named metadata values; keys should be distinct.
+	MetadataProps []*StringStringEntryProto `protobuf:"bytes,4,rep,name=metadata_props,json=metadataProps" json:"metadata_props,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ValueInfoProto) Reset() {
+	*x = ValueInfoProto{}
+	mi := &file_onnx_proto_msgTypes[1]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ValueInfoProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ValueInfoProto) ProtoMessage() {}
+
+func (x *ValueInfoProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[1]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ValueInfoProto.ProtoReflect.Descriptor instead.
+func (*ValueInfoProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *ValueInfoProto) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
+	}
+	return ""
+}
+
+func (x *ValueInfoProto) GetType() *TypeProto {
+	if x != nil {
+		return x.Type
+	}
+	return nil
+}
+
+func (x *ValueInfoProto) GetDocString() string {
+	if x != nil && x.DocString != nil {
+		return *x.DocString
+	}
+	return ""
+}
+
+func (x *ValueInfoProto) GetMetadataProps() []*StringStringEntryProto {
+	if x != nil {
+		return x.MetadataProps
+	}
+	return nil
+}
+
+// Nodes
+//
+// Computation graphs are made up of a DAG of nodes, which represent what is
+// commonly called a "layer" or "pipeline stage" in machine learning frameworks.
+//
+// For example, it can be a node of type "Conv" that takes in an image, a filter
+// tensor and a bias tensor, and produces the convolved output.
+type NodeProto struct {
+	state  protoimpl.MessageState `protogen:"open.v1"`
+	Input  []string               `protobuf:"bytes,1,rep,name=input" json:"input,omitempty"`   // namespace Value
+	Output []string               `protobuf:"bytes,2,rep,name=output" json:"output,omitempty"` // namespace Value
+	// An optional identifier for this node in a graph.
+	// This field MAY be absent in this version of the IR.
+	Name *string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"` // namespace Node
+	// The symbolic identifier of the Operator to execute.
+	OpType *string `protobuf:"bytes,4,opt,name=op_type,json=opType" json:"op_type,omitempty"` // namespace Operator
+	// The domain of the OperatorSet that specifies the operator named by op_type.
+	Domain *string `protobuf:"bytes,7,opt,name=domain" json:"domain,omitempty"` // namespace Domain
+	// Overload identifier, used only to map this to a model-local function.
+	Overload *string `protobuf:"bytes,8,opt,name=overload" json:"overload,omitempty"`
+	// Additional named attributes.
+	Attribute []*AttributeProto `protobuf:"bytes,5,rep,name=attribute" json:"attribute,omitempty"`
+	// A human-readable documentation for this node. Markdown is allowed.
+	DocString *string `protobuf:"bytes,6,opt,name=doc_string,json=docString" json:"doc_string,omitempty"`
+	// Named metadata values; keys should be distinct.
+	MetadataProps []*StringStringEntryProto `protobuf:"bytes,9,rep,name=metadata_props,json=metadataProps" json:"metadata_props,omitempty"`
+	// Configuration of multi-device annotations.
+	DeviceConfigurations []*NodeDeviceConfigurationProto `protobuf:"bytes,10,rep,name=device_configurations,json=deviceConfigurations" json:"device_configurations,omitempty"`
+	unknownFields        protoimpl.UnknownFields
+	sizeCache            protoimpl.SizeCache
+}
+
+func (x *NodeProto) Reset() {
+	*x = NodeProto{}
+	mi := &file_onnx_proto_msgTypes[2]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *NodeProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NodeProto) ProtoMessage() {}
+
+func (x *NodeProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[2]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use NodeProto.ProtoReflect.Descriptor instead.
+func (*NodeProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *NodeProto) GetInput() []string {
+	if x != nil {
+		return x.Input
+	}
+	return nil
+}
+
+func (x *NodeProto) GetOutput() []string {
+	if x != nil {
+		return x.Output
+	}
+	return nil
+}
+
+func (x *NodeProto) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
+	}
+	return ""
+}
+
+func (x *NodeProto) GetOpType() string {
+	if x != nil && x.OpType != nil {
+		return *x.OpType
+	}
+	return ""
+}
+
+func (x *NodeProto) GetDomain() string {
+	if x != nil && x.Domain != nil {
+		return *x.Domain
+	}
+	return ""
+}
+
+func (x *NodeProto) GetOverload() string {
+	if x != nil && x.Overload != nil {
+		return *x.Overload
+	}
+	return ""
+}
+
+func (x *NodeProto) GetAttribute() []*AttributeProto {
+	if x != nil {
+		return x.Attribute
+	}
+	return nil
+}
+
+func (x *NodeProto) GetDocString() string {
+	if x != nil && x.DocString != nil {
+		return *x.DocString
+	}
+	return ""
+}
+
+func (x *NodeProto) GetMetadataProps() []*StringStringEntryProto {
+	if x != nil {
+		return x.MetadataProps
+	}
+	return nil
+}
+
+func (x *NodeProto) GetDeviceConfigurations() []*NodeDeviceConfigurationProto {
+	if x != nil {
+		return x.DeviceConfigurations
+	}
+	return nil
+}
+
+// IntIntListEntryProto follows the pattern for cross-proto-version maps.
+// See https://developers.google.com/protocol-buffers/docs/proto3#maps
+type IntIntListEntryProto struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Key           *int64                 `protobuf:"varint,1,opt,name=key" json:"key,omitempty"`
+	Value         []int64                `protobuf:"varint,2,rep,name=value" json:"value,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *IntIntListEntryProto) Reset() {
+	*x = IntIntListEntryProto{}
+	mi := &file_onnx_proto_msgTypes[3]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *IntIntListEntryProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*IntIntListEntryProto) ProtoMessage() {}
+
+func (x *IntIntListEntryProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[3]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use IntIntListEntryProto.ProtoReflect.Descriptor instead.
+func (*IntIntListEntryProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *IntIntListEntryProto) GetKey() int64 {
+	if x != nil && x.Key != nil {
+		return *x.Key
+	}
+	return 0
+}
+
+func (x *IntIntListEntryProto) GetValue() []int64 {
+	if x != nil {
+		return x.Value
+	}
+	return nil
+}
+
+// Multi-device configuration proto for NodeProto.
+type NodeDeviceConfigurationProto struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// This field MUST be present for this version of the IR.
+	// ID of the configuration. MUST match the name of a DeviceConfigurationProto.
+	ConfigurationId *string `protobuf:"bytes,1,opt,name=configuration_id,json=configurationId" json:"configuration_id,omitempty"`
+	// Sharding spec for the node.
+	ShardingSpec []*ShardingSpecProto `protobuf:"bytes,2,rep,name=sharding_spec,json=shardingSpec" json:"sharding_spec,omitempty"`
+	// Pipeline stage of this node.
+	PipelineStage *int32 `protobuf:"varint,3,opt,name=pipeline_stage,json=pipelineStage" json:"pipeline_stage,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *NodeDeviceConfigurationProto) Reset() {
+	*x = NodeDeviceConfigurationProto{}
+	mi := &file_onnx_proto_msgTypes[4]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *NodeDeviceConfigurationProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NodeDeviceConfigurationProto) ProtoMessage() {}
+
+func (x *NodeDeviceConfigurationProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[4]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use NodeDeviceConfigurationProto.ProtoReflect.Descriptor instead.
+func (*NodeDeviceConfigurationProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *NodeDeviceConfigurationProto) GetConfigurationId() string {
+	if x != nil && x.ConfigurationId != nil {
+		return *x.ConfigurationId
+	}
+	return ""
+}
+
+func (x *NodeDeviceConfigurationProto) GetShardingSpec() []*ShardingSpecProto {
+	if x != nil {
+		return x.ShardingSpec
+	}
+	return nil
+}
+
+func (x *NodeDeviceConfigurationProto) GetPipelineStage() int32 {
+	if x != nil && x.PipelineStage != nil {
+		return *x.PipelineStage
+	}
+	return 0
+}
+
+// ShardingSpecProto: This describes the sharding spec for a specific
+// input or output tensor of a node.
+type ShardingSpecProto struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// This field MUST be present for this version of the IR.
+	// Identifies the input or output of the node that is being sharded.
+	// Required to match a name specified in the node's input or output list of ValueInfoProtos.
+	// It is called `logical tensor` in subsequent descriptions.
+	TensorName *string `protobuf:"bytes,1,opt,name=tensor_name,json=tensorName" json:"tensor_name,omitempty"`
+	// The following is the list of devices across which the logical
+	// tensor is sharded or replicated.
+	Device []int64 `protobuf:"varint,2,rep,name=device" json:"device,omitempty"`
+	// Each element v in above field devices may represent either a
+	// device or a set of devices (when we want the same shard/tensor
+	// to be replicated across a subset of devices), as indicated by
+	// the following optional map. If the map contains an entry for v,
+	// then v represents a device group, and the map indicates the set
+	// of devices in that group.
+	IndexToDeviceGroupMap []*IntIntListEntryProto `protobuf:"bytes,3,rep,name=index_to_device_group_map,json=indexToDeviceGroupMap" json:"index_to_device_group_map,omitempty"`
+	// The following is the sharded-shape of the tensor, consisting of
+	// the sharding-spec for each axis of the tensor.
+	ShardedDim    []*ShardedDimProto `protobuf:"bytes,4,rep,name=sharded_dim,json=shardedDim" json:"sharded_dim,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ShardingSpecProto) Reset() {
+	*x = ShardingSpecProto{}
+	mi := &file_onnx_proto_msgTypes[5]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ShardingSpecProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ShardingSpecProto) ProtoMessage() {}
+
+func (x *ShardingSpecProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[5]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ShardingSpecProto.ProtoReflect.Descriptor instead.
+func (*ShardingSpecProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *ShardingSpecProto) GetTensorName() string {
+	if x != nil && x.TensorName != nil {
+		return *x.TensorName
+	}
+	return ""
+}
+
+func (x *ShardingSpecProto) GetDevice() []int64 {
+	if x != nil {
+		return x.Device
+	}
+	return nil
+}
+
+func (x *ShardingSpecProto) GetIndexToDeviceGroupMap() []*IntIntListEntryProto {
+	if x != nil {
+		return x.IndexToDeviceGroupMap
+	}
+	return nil
+}
+
+func (x *ShardingSpecProto) GetShardedDim() []*ShardedDimProto {
+	if x != nil {
+		return x.ShardedDim
+	}
+	return nil
+}
+
+// ShardedDimProto: This describes the sharding spec for a single
+// axis of a sharded tensor.
+type ShardedDimProto struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// This field MUST be present for this version of the IR.
+	// The axis this sharding corresponds to. Must be in the range of
+	// [-r, r - 1], where r is the rank of the tensor. Negative axis values means
+	// counting from the back.
+	Axis *int64 `protobuf:"varint,1,opt,name=axis" json:"axis,omitempty"`
+	// Describes how the tensor on the provided axis is sharded.
+	// The common-case is described by a single instance of SimpleShardedDimProto.
+	// Multiple instances can be used to handle cases where a sharded
+	// tensor is reshaped, fusing multiple axes into one.
+	SimpleSharding []*SimpleShardedDimProto `protobuf:"bytes,2,rep,name=simple_sharding,json=simpleSharding" json:"simple_sharding,omitempty"`
+	unknownFields  protoimpl.UnknownFields
+	sizeCache      protoimpl.SizeCache
+}
+
+func (x *ShardedDimProto) Reset() {
+	*x = ShardedDimProto{}
+	mi := &file_onnx_proto_msgTypes[6]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ShardedDimProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ShardedDimProto) ProtoMessage() {}
+
+func (x *ShardedDimProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[6]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ShardedDimProto.ProtoReflect.Descriptor instead.
+func (*ShardedDimProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *ShardedDimProto) GetAxis() int64 {
+	if x != nil && x.Axis != nil {
+		return *x.Axis
+	}
+	return 0
+}
+
+func (x *ShardedDimProto) GetSimpleSharding() []*SimpleShardedDimProto {
+	if x != nil {
+		return x.SimpleSharding
+	}
+	return nil
+}
+
+// SimpleShardedDimProto: Indicates that N blocks are divided into M shards.
+// N is allowed to be symbolic where M is required to be a constant.
+type SimpleShardedDimProto struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// Dimension value to be sharded.
+	//
+	// Types that are valid to be assigned to Dim:
+	//
+	//	*SimpleShardedDimProto_DimValue
+	//	*SimpleShardedDimProto_DimParam
+	Dim isSimpleShardedDimProto_Dim `protobuf_oneof:"dim"`
+	// This field MUST be present for this version of the IR.
+	// Number of shards to split dim into.
+	NumShards     *int64 `protobuf:"varint,3,opt,name=num_shards,json=numShards" json:"num_shards,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *SimpleShardedDimProto) Reset() {
+	*x = SimpleShardedDimProto{}
+	mi := &file_onnx_proto_msgTypes[7]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *SimpleShardedDimProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SimpleShardedDimProto) ProtoMessage() {}
+
+func (x *SimpleShardedDimProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[7]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SimpleShardedDimProto.ProtoReflect.Descriptor instead.
+func (*SimpleShardedDimProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{7}
+}
+
+func (x *SimpleShardedDimProto) GetDim() isSimpleShardedDimProto_Dim {
+	if x != nil {
+		return x.Dim
+	}
+	return nil
+}
+
+func (x *SimpleShardedDimProto) GetDimValue() int64 {
+	if x != nil {
+		if x, ok := x.Dim.(*SimpleShardedDimProto_DimValue); ok {
+			return x.DimValue
+		}
+	}
+	return 0
+}
+
+func (x *SimpleShardedDimProto) GetDimParam() string {
+	if x != nil {
+		if x, ok := x.Dim.(*SimpleShardedDimProto_DimParam); ok {
+			return x.DimParam
+		}
+	}
+	return ""
+}
+
+func (x *SimpleShardedDimProto) GetNumShards() int64 {
+	if x != nil && x.NumShards != nil {
+		return *x.NumShards
+	}
+	return 0
+}
+
+type isSimpleShardedDimProto_Dim interface {
+	isSimpleShardedDimProto_Dim()
+}
+
+type SimpleShardedDimProto_DimValue struct {
+	DimValue int64 `protobuf:"varint,1,opt,name=dim_value,json=dimValue,oneof"`
+}
+
+type SimpleShardedDimProto_DimParam struct {
+	DimParam string `protobuf:"bytes,2,opt,name=dim_param,json=dimParam,oneof"`
+}
+
+func (*SimpleShardedDimProto_DimValue) isSimpleShardedDimProto_Dim() {}
+
+func (*SimpleShardedDimProto_DimParam) isSimpleShardedDimProto_Dim() {}
+
+// Training information
+// TrainingInfoProto stores information for training a model.
+// In particular, this defines two functionalities: an initialization-step
+// and a training-algorithm-step. Initialization resets the model
+// back to its original state as if no training has been performed.
+// Training algorithm improves the model based on input data.
+//
+// The semantics of the initialization-step is that the initializers
+// in ModelProto.graph and in TrainingInfoProto.algorithm are first
+// initialized as specified by the initializers in the graph, and then
+// updated by the "initialization_binding" in every instance in
+// ModelProto.training_info.
+//
+// The field "algorithm" defines a computation graph which represents a
+// training algorithm's step. After the execution of a
+// TrainingInfoProto.algorithm, the initializers specified by "update_binding"
+// may be immediately updated. If the targeted training algorithm contains
+// consecutive update steps (such as block coordinate descent methods),
+// the user needs to create a TrainingInfoProto for each step.
+type TrainingInfoProto struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// This field describes a graph to compute the initial tensors
+	// upon starting the training process. Initialization graph has no input
+	// and can have multiple outputs. Usually, trainable tensors in neural
+	// networks are randomly initialized. To achieve that, for each tensor,
+	// the user can put a random number operator such as RandomNormal or
+	// RandomUniform in TrainingInfoProto.initialization.node and assign its
+	// random output to the specific tensor using "initialization_binding".
+	// This graph can also set the initializers in "algorithm" in the same
+	// TrainingInfoProto; a use case is resetting the number of training
+	// iteration to zero.
+	//
+	// By default, this field is an empty graph and its evaluation does not
+	// produce any output. Thus, no initializer would be changed by default.
+	Initialization *GraphProto `protobuf:"bytes,1,opt,name=initialization" json:"initialization,omitempty"`
+	// This field represents a training algorithm step. Given required inputs,
+	// it computes outputs to update initializers in its own or inference graph's
+	// initializer lists. In general, this field contains loss node, gradient node,
+	// optimizer node, increment of iteration count.
+	//
+	// An execution of the training algorithm step is performed by executing the
+	// graph obtained by combining the inference graph (namely "ModelProto.graph")
+	// and the "algorithm" graph. That is, the actual
+	// input/initializer/output/node/value_info/sparse_initializer list of
+	// the training graph is the concatenation of
+	// "ModelProto.graph.input/initializer/output/node/value_info/sparse_initializer"
+	// and "algorithm.input/initializer/output/node/value_info/sparse_initializer"
+	// in that order. This combined graph must satisfy the normal ONNX conditions.
+	// Now, let's provide a visualization of graph combination for clarity.
+	// Let the inference graph (i.e., "ModelProto.graph") be
+	//
+	//	tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d
+	//
+	// and the "algorithm" graph be
+	//
+	//	tensor_d -> Add -> tensor_e
+	//
+	// The combination process results
+	//
+	//	tensor_a, tensor_b -> MatMul -> tensor_c -> Sigmoid -> tensor_d -> Add -> tensor_e
+	//
+	// Notice that an input of a node in the "algorithm" graph may reference the
+	// output of a node in the inference graph (but not the other way round). Also, inference
+	// node cannot reference inputs of "algorithm". With these restrictions, inference graph
+	// can always be run independently without training information.
+	//
+	// By default, this field is an empty graph and its evaluation does not
+	// produce any output. Evaluating the default training step never
+	// update any initializers.
+	Algorithm *GraphProto `protobuf:"bytes,2,opt,name=algorithm" json:"algorithm,omitempty"`
+	// This field specifies the bindings from the outputs of "initialization" to
+	// some initializers in "ModelProto.graph.initializer" and
+	// the "algorithm.initializer" in the same TrainingInfoProto.
+	// See "update_binding" below for details.
+	//
+	// By default, this field is empty and no initializer would be changed
+	// by the execution of "initialization".
+	InitializationBinding []*StringStringEntryProto `protobuf:"bytes,3,rep,name=initialization_binding,json=initializationBinding" json:"initialization_binding,omitempty"`
+	// Gradient-based training is usually an iterative procedure. In one gradient
+	// descent iteration, we apply
+	//
+	// x = x - r * g
+	//
+	// where "x" is the optimized tensor, "r" stands for learning rate, and "g" is
+	// gradient of "x" with respect to a chosen loss. To avoid adding assignments
+	// into the training graph, we split the update equation into
+	//
+	// y = x - r * g
+	// x = y
+	//
+	// The user needs to save "y = x - r * g" into TrainingInfoProto.algorithm. To
+	// tell that "y" should be assigned to "x", the field "update_binding" may
+	// contain a key-value pair of strings, "x" (key of StringStringEntryProto)
+	// and "y" (value of StringStringEntryProto).
+	// For a neural network with multiple trainable (mutable) tensors, there can
+	// be multiple key-value pairs in "update_binding".
+	//
+	// The initializers appears as keys in "update_binding" are considered
+	// mutable variables. This implies some behaviors
+	// as described below.
+	//
+	//  1. We have only unique keys in all "update_binding"s so that two
+	//     variables may not have the same name. This ensures that one
+	//     variable is assigned up to once.
+	//  2. The keys must appear in names of "ModelProto.graph.initializer" or
+	//     "TrainingInfoProto.algorithm.initializer".
+	//  3. The values must be output names of "algorithm" or "ModelProto.graph.output".
+	//  4. Mutable variables are initialized to the value specified by the
+	//     corresponding initializer, and then potentially updated by
+	//     "initializer_binding"s and "update_binding"s in "TrainingInfoProto"s.
+	//
+	// This field usually contains names of trainable tensors
+	// (in ModelProto.graph), optimizer states such as momentums in advanced
+	// stochastic gradient methods (in TrainingInfoProto.graph),
+	// and number of training iterations (in TrainingInfoProto.graph).
+	//
+	// By default, this field is empty and no initializer would be changed
+	// by the execution of "algorithm".
+	UpdateBinding []*StringStringEntryProto `protobuf:"bytes,4,rep,name=update_binding,json=updateBinding" json:"update_binding,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *TrainingInfoProto) Reset() {
+	*x = TrainingInfoProto{}
+	mi := &file_onnx_proto_msgTypes[8]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *TrainingInfoProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TrainingInfoProto) ProtoMessage() {}
+
+func (x *TrainingInfoProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[8]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TrainingInfoProto.ProtoReflect.Descriptor instead.
+func (*TrainingInfoProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{8}
+}
+
+func (x *TrainingInfoProto) GetInitialization() *GraphProto {
+	if x != nil {
+		return x.Initialization
+	}
+	return nil
+}
+
+func (x *TrainingInfoProto) GetAlgorithm() *GraphProto {
+	if x != nil {
+		return x.Algorithm
+	}
+	return nil
+}
+
+func (x *TrainingInfoProto) GetInitializationBinding() []*StringStringEntryProto {
+	if x != nil {
+		return x.InitializationBinding
+	}
+	return nil
+}
+
+func (x *TrainingInfoProto) GetUpdateBinding() []*StringStringEntryProto {
+	if x != nil {
+		return x.UpdateBinding
+	}
+	return nil
+}
+
+// Models
+//
+// ModelProto is a top-level file/container format for bundling a ML model and
+// associating its computation graph with metadata.
+//
+// The semantics of the model are described by the associated GraphProto's.
+type ModelProto struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// The version of the IR this model targets. See Version enum above.
+	// This field MUST be present.
+	IrVersion *int64 `protobuf:"varint,1,opt,name=ir_version,json=irVersion" json:"ir_version,omitempty"`
+	// The OperatorSets this model relies on.
+	// All ModelProtos MUST have at least one entry that
+	// specifies which version of the ONNX OperatorSet is
+	// being imported.
+	//
+	// All nodes in the ModelProto's graph will bind against the operator
+	// with the same-domain/same-op_type operator with the HIGHEST version
+	// in the referenced operator sets.
+	OpsetImport []*OperatorSetIdProto `protobuf:"bytes,8,rep,name=opset_import,json=opsetImport" json:"opset_import,omitempty"`
+	// The name of the framework or tool used to generate this model.
+	// This field SHOULD be present to indicate which implementation/tool/framework
+	// emitted the model.
+	ProducerName *string `protobuf:"bytes,2,opt,name=producer_name,json=producerName" json:"producer_name,omitempty"`
+	// The version of the framework or tool used to generate this model.
+	// This field SHOULD be present to indicate which implementation/tool/framework
+	// emitted the model.
+	ProducerVersion *string `protobuf:"bytes,3,opt,name=producer_version,json=producerVersion" json:"producer_version,omitempty"`
+	// Domain name of the model.
+	// We use reverse domain names as name space indicators. For example:
+	// `com.facebook.fair` or `com.microsoft.cognitiveservices`
+	//
+	// Together with `model_version` and GraphProto.name, this forms the unique identity of
+	// the graph.
+	Domain *string `protobuf:"bytes,4,opt,name=domain" json:"domain,omitempty"`
+	// The version of the graph encoded. See Version enum below.
+	ModelVersion *int64 `protobuf:"varint,5,opt,name=model_version,json=modelVersion" json:"model_version,omitempty"`
+	// A human-readable documentation for this model. Markdown is allowed.
+	DocString *string `protobuf:"bytes,6,opt,name=doc_string,json=docString" json:"doc_string,omitempty"`
+	// The parameterized graph that is evaluated to execute the model.
+	Graph *GraphProto `protobuf:"bytes,7,opt,name=graph" json:"graph,omitempty"`
+	// Named metadata values; keys should be distinct.
+	MetadataProps []*StringStringEntryProto `protobuf:"bytes,14,rep,name=metadata_props,json=metadataProps" json:"metadata_props,omitempty"`
+	// Training-specific information. Sequentially executing all stored
+	// `TrainingInfoProto.algorithm`s and assigning their outputs following
+	// the corresponding `TrainingInfoProto.update_binding`s is one training
+	// iteration. Similarly, to initialize the model
+	// (as if training hasn't happened), the user should sequentially execute
+	// all stored `TrainingInfoProto.initialization`s and assigns their outputs
+	// using `TrainingInfoProto.initialization_binding`s.
+	//
+	// If this field is empty, the training behavior of the model is undefined.
+	TrainingInfo []*TrainingInfoProto `protobuf:"bytes,20,rep,name=training_info,json=trainingInfo" json:"training_info,omitempty"`
+	// A list of function protos local to the model.
+	//
+	// The (domain, name, overload) tuple must be unique across the function protos in this list.
+	// In case of any conflicts the behavior (whether the model local functions are given higher priority,
+	// or standard operator sets are given higher priority or this is treated as error) is defined by
+	// the runtimes.
+	//
+	// The operator sets imported by FunctionProto should be compatible with the ones
+	// imported by ModelProto and other model local FunctionProtos.
+	// Example, if same operator set say 'A' is imported by a FunctionProto and ModelProto
+	// or by 2 FunctionProtos then versions for the operator set may be different but,
+	// the operator schema returned for op_type, domain, version combination
+	// for both the versions should be same for every node in the function body.
+	//
+	// One FunctionProto can reference other FunctionProto in the model, however, recursive reference
+	// is not allowed.
+	Functions []*FunctionProto `protobuf:"bytes,25,rep,name=functions" json:"functions,omitempty"`
+	// Describes different target configurations for a multi-device use case.
+	// A model MAY describe multiple multi-device configurations for execution.
+	Configuration []*DeviceConfigurationProto `protobuf:"bytes,26,rep,name=configuration" json:"configuration,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ModelProto) Reset() {
+	*x = ModelProto{}
+	mi := &file_onnx_proto_msgTypes[9]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ModelProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ModelProto) ProtoMessage() {}
+
+func (x *ModelProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[9]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ModelProto.ProtoReflect.Descriptor instead.
+func (*ModelProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *ModelProto) GetIrVersion() int64 {
+	if x != nil && x.IrVersion != nil {
+		return *x.IrVersion
+	}
+	return 0
+}
+
+func (x *ModelProto) GetOpsetImport() []*OperatorSetIdProto {
+	if x != nil {
+		return x.OpsetImport
+	}
+	return nil
+}
+
+func (x *ModelProto) GetProducerName() string {
+	if x != nil && x.ProducerName != nil {
+		return *x.ProducerName
+	}
+	return ""
+}
+
+func (x *ModelProto) GetProducerVersion() string {
+	if x != nil && x.ProducerVersion != nil {
+		return *x.ProducerVersion
+	}
+	return ""
+}
+
+func (x *ModelProto) GetDomain() string {
+	if x != nil && x.Domain != nil {
+		return *x.Domain
+	}
+	return ""
+}
+
+func (x *ModelProto) GetModelVersion() int64 {
+	if x != nil && x.ModelVersion != nil {
+		return *x.ModelVersion
+	}
+	return 0
+}
+
+func (x *ModelProto) GetDocString() string {
+	if x != nil && x.DocString != nil {
+		return *x.DocString
+	}
+	return ""
+}
+
+func (x *ModelProto) GetGraph() *GraphProto {
+	if x != nil {
+		return x.Graph
+	}
+	return nil
+}
+
+func (x *ModelProto) GetMetadataProps() []*StringStringEntryProto {
+	if x != nil {
+		return x.MetadataProps
+	}
+	return nil
+}
+
+func (x *ModelProto) GetTrainingInfo() []*TrainingInfoProto {
+	if x != nil {
+		return x.TrainingInfo
+	}
+	return nil
+}
+
+func (x *ModelProto) GetFunctions() []*FunctionProto {
+	if x != nil {
+		return x.Functions
+	}
+	return nil
+}
+
+func (x *ModelProto) GetConfiguration() []*DeviceConfigurationProto {
+	if x != nil {
+		return x.Configuration
+	}
+	return nil
+}
+
+// DeviceConfigurationProto describes a multi-device configuration for a model.
+type DeviceConfigurationProto struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// This field MUST be present for this version of the IR.
+	// Name of the configuration.
+	Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	// This field MUST be present for this version of the IR.
+	// Number of devices inside this configuration.
+	NumDevices *int32 `protobuf:"varint,2,opt,name=num_devices,json=numDevices" json:"num_devices,omitempty"`
+	// Optional names of the devices. MUST be length of num_devices if provided.
+	Device        []string `protobuf:"bytes,3,rep,name=device" json:"device,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *DeviceConfigurationProto) Reset() {
+	*x = DeviceConfigurationProto{}
+	mi := &file_onnx_proto_msgTypes[10]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *DeviceConfigurationProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DeviceConfigurationProto) ProtoMessage() {}
+
+func (x *DeviceConfigurationProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[10]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DeviceConfigurationProto.ProtoReflect.Descriptor instead.
+func (*DeviceConfigurationProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{10}
+}
+
+func (x *DeviceConfigurationProto) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
+	}
+	return ""
+}
+
+func (x *DeviceConfigurationProto) GetNumDevices() int32 {
+	if x != nil && x.NumDevices != nil {
+		return *x.NumDevices
+	}
+	return 0
+}
+
+func (x *DeviceConfigurationProto) GetDevice() []string {
+	if x != nil {
+		return x.Device
+	}
+	return nil
+}
+
+// StringStringEntryProto follows the pattern for cross-proto-version maps.
+// See https://developers.google.com/protocol-buffers/docs/proto3#maps
+type StringStringEntryProto struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Key           *string                `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+	Value         *string                `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *StringStringEntryProto) Reset() {
+	*x = StringStringEntryProto{}
+	mi := &file_onnx_proto_msgTypes[11]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *StringStringEntryProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*StringStringEntryProto) ProtoMessage() {}
+
+func (x *StringStringEntryProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[11]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use StringStringEntryProto.ProtoReflect.Descriptor instead.
+func (*StringStringEntryProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{11}
+}
+
+func (x *StringStringEntryProto) GetKey() string {
+	if x != nil && x.Key != nil {
+		return *x.Key
+	}
+	return ""
+}
+
+func (x *StringStringEntryProto) GetValue() string {
+	if x != nil && x.Value != nil {
+		return *x.Value
+	}
+	return ""
+}
+
+type TensorAnnotation struct {
+	state      protoimpl.MessageState `protogen:"open.v1"`
+	TensorName *string                `protobuf:"bytes,1,opt,name=tensor_name,json=tensorName" json:"tensor_name,omitempty"`
+	// <key, value> pairs to annotate tensor specified by <tensor_name> above.
+	// The keys used in the mapping below must be pre-defined in ONNX spec.
+	// For example, for 8-bit linear quantization case, 'SCALE_TENSOR', 'ZERO_POINT_TENSOR' will be pre-defined as
+	// quantization parameter keys.
+	QuantParameterTensorNames []*StringStringEntryProto `protobuf:"bytes,2,rep,name=quant_parameter_tensor_names,json=quantParameterTensorNames" json:"quant_parameter_tensor_names,omitempty"`
+	unknownFields             protoimpl.UnknownFields
+	sizeCache                 protoimpl.SizeCache
+}
+
+func (x *TensorAnnotation) Reset() {
+	*x = TensorAnnotation{}
+	mi := &file_onnx_proto_msgTypes[12]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *TensorAnnotation) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TensorAnnotation) ProtoMessage() {}
+
+func (x *TensorAnnotation) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[12]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TensorAnnotation.ProtoReflect.Descriptor instead.
+func (*TensorAnnotation) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *TensorAnnotation) GetTensorName() string {
+	if x != nil && x.TensorName != nil {
+		return *x.TensorName
+	}
+	return ""
+}
+
+func (x *TensorAnnotation) GetQuantParameterTensorNames() []*StringStringEntryProto {
+	if x != nil {
+		return x.QuantParameterTensorNames
+	}
+	return nil
+}
+
+// Graphs
+//
+// A graph defines the computational logic of a model and is comprised of a parameterized
+// list of nodes that form a directed acyclic graph based on their inputs and outputs.
+// This is the equivalent of the "network" or "graph" in many deep learning
+// frameworks.
+type GraphProto struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// The nodes in the graph, sorted topologically.
+	Node []*NodeProto `protobuf:"bytes,1,rep,name=node" json:"node,omitempty"`
+	// The name of the graph.
+	Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"` // namespace Graph
+	// A list of named tensor values, used to specify constant inputs of the graph.
+	// Each initializer (both TensorProto as well SparseTensorProto) MUST have a name.
+	// The name MUST be unique across both initializer and sparse_initializer,
+	// but the name MAY also appear in the input list.
+	Initializer []*TensorProto `protobuf:"bytes,5,rep,name=initializer" json:"initializer,omitempty"`
+	// Initializers (see above) stored in sparse format.
+	SparseInitializer []*SparseTensorProto `protobuf:"bytes,15,rep,name=sparse_initializer,json=sparseInitializer" json:"sparse_initializer,omitempty"`
+	// A human-readable documentation for this graph. Markdown is allowed.
+	DocString *string `protobuf:"bytes,10,opt,name=doc_string,json=docString" json:"doc_string,omitempty"`
+	// The inputs and outputs of the graph.
+	Input  []*ValueInfoProto `protobuf:"bytes,11,rep,name=input" json:"input,omitempty"`
+	Output []*ValueInfoProto `protobuf:"bytes,12,rep,name=output" json:"output,omitempty"`
+	// Information for the values in the graph. The ValueInfoProto.name's
+	// must be distinct. It is optional for a value to appear in value_info list.
+	ValueInfo []*ValueInfoProto `protobuf:"bytes,13,rep,name=value_info,json=valueInfo" json:"value_info,omitempty"`
+	// This field carries information to indicate the mapping among a tensor and its
+	// quantization parameter tensors. For example:
+	// For tensor 'a', it may have {'SCALE_TENSOR', 'a_scale'} and {'ZERO_POINT_TENSOR', 'a_zero_point'} annotated,
+	// which means, tensor 'a_scale' and tensor 'a_zero_point' are scale and zero point of tensor 'a' in the model.
+	QuantizationAnnotation []*TensorAnnotation `protobuf:"bytes,14,rep,name=quantization_annotation,json=quantizationAnnotation" json:"quantization_annotation,omitempty"`
+	// Named metadata values; keys should be distinct.
+	MetadataProps []*StringStringEntryProto `protobuf:"bytes,16,rep,name=metadata_props,json=metadataProps" json:"metadata_props,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *GraphProto) Reset() {
+	*x = GraphProto{}
+	mi := &file_onnx_proto_msgTypes[13]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GraphProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GraphProto) ProtoMessage() {}
+
+func (x *GraphProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[13]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GraphProto.ProtoReflect.Descriptor instead.
+func (*GraphProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *GraphProto) GetNode() []*NodeProto {
+	if x != nil {
+		return x.Node
+	}
+	return nil
+}
+
+func (x *GraphProto) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
+	}
+	return ""
+}
+
+func (x *GraphProto) GetInitializer() []*TensorProto {
+	if x != nil {
+		return x.Initializer
+	}
+	return nil
+}
+
+func (x *GraphProto) GetSparseInitializer() []*SparseTensorProto {
+	if x != nil {
+		return x.SparseInitializer
+	}
+	return nil
+}
+
+func (x *GraphProto) GetDocString() string {
+	if x != nil && x.DocString != nil {
+		return *x.DocString
+	}
+	return ""
+}
+
+func (x *GraphProto) GetInput() []*ValueInfoProto {
+	if x != nil {
+		return x.Input
+	}
+	return nil
+}
+
+func (x *GraphProto) GetOutput() []*ValueInfoProto {
+	if x != nil {
+		return x.Output
+	}
+	return nil
+}
+
+func (x *GraphProto) GetValueInfo() []*ValueInfoProto {
+	if x != nil {
+		return x.ValueInfo
+	}
+	return nil
+}
+
+func (x *GraphProto) GetQuantizationAnnotation() []*TensorAnnotation {
+	if x != nil {
+		return x.QuantizationAnnotation
+	}
+	return nil
+}
+
+func (x *GraphProto) GetMetadataProps() []*StringStringEntryProto {
+	if x != nil {
+		return x.MetadataProps
+	}
+	return nil
+}
+
+// Tensors
+//
+// A serialized tensor value.
+type TensorProto struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// The shape of the tensor.
+	Dims []int64 `protobuf:"varint,1,rep,name=dims" json:"dims,omitempty"`
+	// The data type of the tensor.
+	// This field MUST have a valid TensorProto.DataType value
+	DataType *int32               `protobuf:"varint,2,opt,name=data_type,json=dataType" json:"data_type,omitempty"`
+	Segment  *TensorProto_Segment `protobuf:"bytes,3,opt,name=segment" json:"segment,omitempty"`
+	// For float and complex64 values
+	// Complex64 tensors are encoded as a single array of floats,
+	// with the real components appearing in odd numbered positions,
+	// and the corresponding imaginary component appearing in the
+	// subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
+	// is encoded as [1.0, 2.0 ,3.0 ,4.0]
+	// When this field is present, the data_type field MUST be FLOAT or COMPLEX64.
+	FloatData []float32 `protobuf:"fixed32,4,rep,packed,name=float_data,json=floatData" json:"float_data,omitempty"`
+	// For int32, uint8, int8, uint16, int16, uint4, int4, uint2, int2, bool, (b)float16, float8, and float4:
+	//   - (b)float16 and float8 values MUST be converted bit-wise into an unsigned integer
+	//     representation before being written to the buffer.
+	//   - Each pair of uint4, int4, and float4 values MUST be packed as two 4-bit elements into a single byte.
+	//     The first element is stored in the 4 least significant bits (LSB),
+	//     and the second element is stored in the 4 most significant bits (MSB).
+	//   - Each group of four uint2, int2 values MUST be packed as four 2-bit elements into a single byte.
+	//     The elements are packed from LSB to MSB, with the first element in bits 0-1, second element in bits 2-3,
+	//     third element in bits 4-5, and fourth element in bits 6-7.
+	//
+	// Consequently:
+	// - For data types with a bit-width of 8 or greater, each `int32_data` stores one element.
+	// - For 4-bit data types, each `int32_data` stores two elements.
+	// - For 2-bit data types, each `int32_data` stores four elements.
+	//
+	// When this field is present, the data_type field MUST be
+	// INT32, INT16, INT8, INT4, INT2, UINT16, UINT8, UINT4, UINT2, BOOL, FLOAT16, BFLOAT16, FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ, FLOAT8E8M0, FLOAT4E2M1
+	Int32Data []int32 `protobuf:"varint,5,rep,packed,name=int32_data,json=int32Data" json:"int32_data,omitempty"`
+	// For strings.
+	// Each element of string_data is a UTF-8 encoded Unicode
+	// string. No trailing null, no leading BOM. The protobuf "string"
+	// scalar type is not used to match ML community conventions.
+	// When this field is present, the data_type field MUST be STRING
+	StringData [][]byte `protobuf:"bytes,6,rep,name=string_data,json=stringData" json:"string_data,omitempty"`
+	// For int64.
+	// When this field is present, the data_type field MUST be INT64
+	Int64Data []int64 `protobuf:"varint,7,rep,packed,name=int64_data,json=int64Data" json:"int64_data,omitempty"`
+	// Optionally, a name for the tensor.
+	Name *string `protobuf:"bytes,8,opt,name=name" json:"name,omitempty"` // namespace Value
+	// A human-readable documentation for this tensor. Markdown is allowed.
+	DocString *string `protobuf:"bytes,12,opt,name=doc_string,json=docString" json:"doc_string,omitempty"`
+	// Serializations can either use one of the fields above, or use this
+	// raw bytes field. The only exception is the string case, where one is
+	// required to store the content in the repeated bytes string_data field.
+	//
+	// When this raw_data field is used to store tensor value, elements MUST
+	// be stored in as fixed-width, little-endian order.
+	// Floating-point data types MUST be stored in IEEE 754 format.
+	// Complex64 elements must be written as two consecutive FLOAT values, real component first.
+	// Complex128 elements must be written as two consecutive DOUBLE values, real component first.
+	// Boolean type MUST be written one byte per tensor element (00000001 for true, 00000000 for false).
+	// uint4 and int4 values must be packed to 4bitx2, the first element is stored in the 4 LSB and the second element is stored in the 4 MSB.
+	// uint2 and int2 values must be packed to 2bitx4, with elements packed from LSB to MSB in a single byte as: x0 | (x1 << 2) | (x2 << 4) | (x3 << 6)
+	// where x0, x1, x2, x3 are consecutive elements.
+	//
+	// Note: the advantage of specific field rather than the raw_data field is
+	// that in some cases (e.g. int data), protobuf does a better packing via
+	// variable length storage, and may lead to smaller binary footprint.
+	// When this field is present, the data_type field MUST NOT be STRING or UNDEFINED
+	RawData []byte `protobuf:"bytes,9,opt,name=raw_data,json=rawData" json:"raw_data,omitempty"`
+	// Data can be stored inside the protobuf file using type-specific fields or raw_data.
+	// Alternatively, raw bytes data can be stored in an external file, using the external_data field.
+	// external_data stores key-value pairs describing data location. Recognized keys are:
+	//   - "location" (required) - POSIX filesystem path relative to the directory where the ONNX
+	//     protobuf model was stored
+	//   - "offset" (optional) - position of byte at which stored data begins. Integer stored as string.
+	//     Offset values SHOULD be multiples 4096 (page size) to enable mmap support.
+	//   - "length" (optional) - number of bytes containing data. Integer stored as string.
+	//   - "checksum" (optional) - SHA1 digest of file specified in under 'location' key.
+	ExternalData []*StringStringEntryProto `protobuf:"bytes,13,rep,name=external_data,json=externalData" json:"external_data,omitempty"`
+	// If value not set, data is stored in raw_data (if set) otherwise in type-specified field.
+	DataLocation *TensorProto_DataLocation `protobuf:"varint,14,opt,name=data_location,json=dataLocation,enum=onnx.TensorProto_DataLocation" json:"data_location,omitempty"`
+	// For double
+	// Complex128 tensors are encoded as a single array of doubles,
+	// with the real components appearing in odd numbered positions,
+	// and the corresponding imaginary component appearing in the
+	// subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i]
+	// is encoded as [1.0, 2.0 ,3.0 ,4.0]
+	// When this field is present, the data_type field MUST be DOUBLE or COMPLEX128
+	DoubleData []float64 `protobuf:"fixed64,10,rep,packed,name=double_data,json=doubleData" json:"double_data,omitempty"`
+	// For uint64 and uint32 values
+	// When this field is present, the data_type field MUST be
+	// UINT32 or UINT64
+	Uint64Data []uint64 `protobuf:"varint,11,rep,packed,name=uint64_data,json=uint64Data" json:"uint64_data,omitempty"`
+	// Named metadata values; keys should be distinct.
+	MetadataProps []*StringStringEntryProto `protobuf:"bytes,16,rep,name=metadata_props,json=metadataProps" json:"metadata_props,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *TensorProto) Reset() {
+	*x = TensorProto{}
+	mi := &file_onnx_proto_msgTypes[14]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *TensorProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TensorProto) ProtoMessage() {}
+
+func (x *TensorProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[14]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TensorProto.ProtoReflect.Descriptor instead.
+func (*TensorProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *TensorProto) GetDims() []int64 {
+	if x != nil {
+		return x.Dims
+	}
+	return nil
+}
+
+func (x *TensorProto) GetDataType() int32 {
+	if x != nil && x.DataType != nil {
+		return *x.DataType
+	}
+	return 0
+}
+
+func (x *TensorProto) GetSegment() *TensorProto_Segment {
+	if x != nil {
+		return x.Segment
+	}
+	return nil
+}
+
+func (x *TensorProto) GetFloatData() []float32 {
+	if x != nil {
+		return x.FloatData
+	}
+	return nil
+}
+
+func (x *TensorProto) GetInt32Data() []int32 {
+	if x != nil {
+		return x.Int32Data
+	}
+	return nil
+}
+
+func (x *TensorProto) GetStringData() [][]byte {
+	if x != nil {
+		return x.StringData
+	}
+	return nil
+}
+
+func (x *TensorProto) GetInt64Data() []int64 {
+	if x != nil {
+		return x.Int64Data
+	}
+	return nil
+}
+
+func (x *TensorProto) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
+	}
+	return ""
+}
+
+func (x *TensorProto) GetDocString() string {
+	if x != nil && x.DocString != nil {
+		return *x.DocString
+	}
+	return ""
+}
+
+func (x *TensorProto) GetRawData() []byte {
+	if x != nil {
+		return x.RawData
+	}
+	return nil
+}
+
+func (x *TensorProto) GetExternalData() []*StringStringEntryProto {
+	if x != nil {
+		return x.ExternalData
+	}
+	return nil
+}
+
+func (x *TensorProto) GetDataLocation() TensorProto_DataLocation {
+	if x != nil && x.DataLocation != nil {
+		return *x.DataLocation
+	}
+	return TensorProto_DEFAULT
+}
+
+func (x *TensorProto) GetDoubleData() []float64 {
+	if x != nil {
+		return x.DoubleData
+	}
+	return nil
+}
+
+func (x *TensorProto) GetUint64Data() []uint64 {
+	if x != nil {
+		return x.Uint64Data
+	}
+	return nil
+}
+
+func (x *TensorProto) GetMetadataProps() []*StringStringEntryProto {
+	if x != nil {
+		return x.MetadataProps
+	}
+	return nil
+}
+
+// A serialized sparse-tensor value
+type SparseTensorProto struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// The sequence of non-default values are encoded as a tensor of shape [NNZ].
+	// The default-value is zero for numeric tensors, and empty-string for string tensors.
+	// values must have a non-empty name present which serves as a name for SparseTensorProto
+	// when used in sparse_initializer list.
+	Values *TensorProto `protobuf:"bytes,1,opt,name=values" json:"values,omitempty"`
+	// The indices of the non-default values, which may be stored in one of two formats.
+	// (a) Indices can be a tensor of shape [NNZ, rank] with the [i,j]-th value
+	// corresponding to the j-th index of the i-th value (in the values tensor).
+	// (b) Indices can be a tensor of shape [NNZ], in which case the i-th value
+	// must be the linearized-index of the i-th value (in the values tensor).
+	// The linearized-index can be converted into an index tuple (k_1,...,k_rank)
+	// using the shape provided below.
+	// The indices must appear in ascending order without duplication.
+	// In the first format, the ordering is lexicographic-ordering:
+	// e.g., index-value [1,4] must appear before [2,1]
+	Indices *TensorProto `protobuf:"bytes,2,opt,name=indices" json:"indices,omitempty"`
+	// The shape of the underlying dense-tensor: [dim_1, dim_2, ... dim_rank]
+	Dims          []int64 `protobuf:"varint,3,rep,name=dims" json:"dims,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *SparseTensorProto) Reset() {
+	*x = SparseTensorProto{}
+	mi := &file_onnx_proto_msgTypes[15]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *SparseTensorProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SparseTensorProto) ProtoMessage() {}
+
+func (x *SparseTensorProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[15]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SparseTensorProto.ProtoReflect.Descriptor instead.
+func (*SparseTensorProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{15}
+}
+
+func (x *SparseTensorProto) GetValues() *TensorProto {
+	if x != nil {
+		return x.Values
+	}
+	return nil
+}
+
+func (x *SparseTensorProto) GetIndices() *TensorProto {
+	if x != nil {
+		return x.Indices
+	}
+	return nil
+}
+
+func (x *SparseTensorProto) GetDims() []int64 {
+	if x != nil {
+		return x.Dims
+	}
+	return nil
+}
+
+// Defines a tensor shape. A dimension can be either an integer value
+// or a symbolic variable. A symbolic variable represents an unknown
+// dimension.
+type TensorShapeProto struct {
+	state         protoimpl.MessageState        `protogen:"open.v1"`
+	Dim           []*TensorShapeProto_Dimension `protobuf:"bytes,1,rep,name=dim" json:"dim,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *TensorShapeProto) Reset() {
+	*x = TensorShapeProto{}
+	mi := &file_onnx_proto_msgTypes[16]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *TensorShapeProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TensorShapeProto) ProtoMessage() {}
+
+func (x *TensorShapeProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[16]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TensorShapeProto.ProtoReflect.Descriptor instead.
+func (*TensorShapeProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *TensorShapeProto) GetDim() []*TensorShapeProto_Dimension {
+	if x != nil {
+		return x.Dim
+	}
+	return nil
+}
+
+// Types
+//
+// The standard ONNX data types.
+type TypeProto struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// Types that are valid to be assigned to Value:
+	//
+	//	*TypeProto_TensorType
+	//	*TypeProto_SequenceType
+	//	*TypeProto_MapType
+	//	*TypeProto_OptionalType
+	//	*TypeProto_SparseTensorType
+	Value isTypeProto_Value `protobuf_oneof:"value"`
+	// An optional denotation can be used to denote the whole
+	// type with a standard semantic description as to what is
+	// stored inside. Refer to https://github.com/onnx/onnx/blob/main/docs/TypeDenotation.md#type-denotation-definition
+	// for pre-defined type denotations.
+	Denotation    *string `protobuf:"bytes,6,opt,name=denotation" json:"denotation,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *TypeProto) Reset() {
+	*x = TypeProto{}
+	mi := &file_onnx_proto_msgTypes[17]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *TypeProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TypeProto) ProtoMessage() {}
+
+func (x *TypeProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[17]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TypeProto.ProtoReflect.Descriptor instead.
+func (*TypeProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{17}
+}
+
+func (x *TypeProto) GetValue() isTypeProto_Value {
+	if x != nil {
+		return x.Value
+	}
+	return nil
+}
+
+func (x *TypeProto) GetTensorType() *TypeProto_Tensor {
+	if x != nil {
+		if x, ok := x.Value.(*TypeProto_TensorType); ok {
+			return x.TensorType
+		}
+	}
+	return nil
+}
+
+func (x *TypeProto) GetSequenceType() *TypeProto_Sequence {
+	if x != nil {
+		if x, ok := x.Value.(*TypeProto_SequenceType); ok {
+			return x.SequenceType
+		}
+	}
+	return nil
+}
+
+func (x *TypeProto) GetMapType() *TypeProto_Map {
+	if x != nil {
+		if x, ok := x.Value.(*TypeProto_MapType); ok {
+			return x.MapType
+		}
+	}
+	return nil
+}
+
+func (x *TypeProto) GetOptionalType() *TypeProto_Optional {
+	if x != nil {
+		if x, ok := x.Value.(*TypeProto_OptionalType); ok {
+			return x.OptionalType
+		}
+	}
+	return nil
+}
+
+func (x *TypeProto) GetSparseTensorType() *TypeProto_SparseTensor {
+	if x != nil {
+		if x, ok := x.Value.(*TypeProto_SparseTensorType); ok {
+			return x.SparseTensorType
+		}
+	}
+	return nil
+}
+
+func (x *TypeProto) GetDenotation() string {
+	if x != nil && x.Denotation != nil {
+		return *x.Denotation
+	}
+	return ""
+}
+
+type isTypeProto_Value interface {
+	isTypeProto_Value()
+}
+
+type TypeProto_TensorType struct {
+	// The type of a tensor.
+	TensorType *TypeProto_Tensor `protobuf:"bytes,1,opt,name=tensor_type,json=tensorType,oneof"`
+}
+
+type TypeProto_SequenceType struct {
+	// The type of a sequence.
+	SequenceType *TypeProto_Sequence `protobuf:"bytes,4,opt,name=sequence_type,json=sequenceType,oneof"`
+}
+
+type TypeProto_MapType struct {
+	// The type of a map.
+	MapType *TypeProto_Map `protobuf:"bytes,5,opt,name=map_type,json=mapType,oneof"`
+}
+
+type TypeProto_OptionalType struct {
+	// The type of an optional.
+	OptionalType *TypeProto_Optional `protobuf:"bytes,9,opt,name=optional_type,json=optionalType,oneof"`
+}
+
+type TypeProto_SparseTensorType struct {
+	// Type of the sparse tensor
+	SparseTensorType *TypeProto_SparseTensor `protobuf:"bytes,8,opt,name=sparse_tensor_type,json=sparseTensorType,oneof"`
+}
+
+func (*TypeProto_TensorType) isTypeProto_Value() {}
+
+func (*TypeProto_SequenceType) isTypeProto_Value() {}
+
+func (*TypeProto_MapType) isTypeProto_Value() {}
+
+func (*TypeProto_OptionalType) isTypeProto_Value() {}
+
+func (*TypeProto_SparseTensorType) isTypeProto_Value() {}
+
+// Operator Sets
+//
+// OperatorSets are uniquely identified by a (domain, opset_version) pair.
+type OperatorSetIdProto struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// The domain of the operator set being identified.
+	// The empty string ("") or absence of this field implies the operator
+	// set that is defined as part of the ONNX specification.
+	// This field MUST be present in this version of the IR when referring to any other operator set.
+	Domain *string `protobuf:"bytes,1,opt,name=domain" json:"domain,omitempty"`
+	// The version of the operator set being identified.
+	// This field MUST be present in this version of the IR.
+	Version       *int64 `protobuf:"varint,2,opt,name=version" json:"version,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *OperatorSetIdProto) Reset() {
+	*x = OperatorSetIdProto{}
+	mi := &file_onnx_proto_msgTypes[18]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *OperatorSetIdProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*OperatorSetIdProto) ProtoMessage() {}
+
+func (x *OperatorSetIdProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[18]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use OperatorSetIdProto.ProtoReflect.Descriptor instead.
+func (*OperatorSetIdProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{18}
+}
+
+func (x *OperatorSetIdProto) GetDomain() string {
+	if x != nil && x.Domain != nil {
+		return *x.Domain
+	}
+	return ""
+}
+
+func (x *OperatorSetIdProto) GetVersion() int64 {
+	if x != nil && x.Version != nil {
+		return *x.Version
+	}
+	return 0
+}
+
+type FunctionProto struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// The name of the function, similar to op_type in NodeProto.
+	// This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+	Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	// The inputs and outputs of the function.
+	Input  []string `protobuf:"bytes,4,rep,name=input" json:"input,omitempty"`
+	Output []string `protobuf:"bytes,5,rep,name=output" json:"output,omitempty"`
+	// The attribute parameters of the function.
+	// It is for function parameters without default values.
+	Attribute []string `protobuf:"bytes,6,rep,name=attribute" json:"attribute,omitempty"`
+	// 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.
+	AttributeProto []*AttributeProto `protobuf:"bytes,11,rep,name=attribute_proto,json=attributeProto" json:"attribute_proto,omitempty"`
+	// The nodes in the function.
+	Node []*NodeProto `protobuf:"bytes,7,rep,name=node" json:"node,omitempty"`
+	// A human-readable documentation for this function. Markdown is allowed.
+	DocString   *string               `protobuf:"bytes,8,opt,name=doc_string,json=docString" json:"doc_string,omitempty"`
+	OpsetImport []*OperatorSetIdProto `protobuf:"bytes,9,rep,name=opset_import,json=opsetImport" json:"opset_import,omitempty"`
+	// The domain which this function belongs to.
+	// This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+	Domain *string `protobuf:"bytes,10,opt,name=domain" json:"domain,omitempty"`
+	// The overload identifier of the function.
+	// This is part of the unique-id (domain, name, overload) of FunctionProtos in a model.
+	Overload *string `protobuf:"bytes,13,opt,name=overload" json:"overload,omitempty"`
+	// Information for the values in the function. The ValueInfoProto.name's
+	// must be distinct and refer to names in the function (including inputs,
+	// outputs, and intermediate values). It is optional for a value to appear
+	// in value_info list.
+	ValueInfo []*ValueInfoProto `protobuf:"bytes,12,rep,name=value_info,json=valueInfo" json:"value_info,omitempty"`
+	// Named metadata values; keys should be distinct.
+	MetadataProps []*StringStringEntryProto `protobuf:"bytes,14,rep,name=metadata_props,json=metadataProps" json:"metadata_props,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *FunctionProto) Reset() {
+	*x = FunctionProto{}
+	mi := &file_onnx_proto_msgTypes[19]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *FunctionProto) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FunctionProto) ProtoMessage() {}
+
+func (x *FunctionProto) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[19]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FunctionProto.ProtoReflect.Descriptor instead.
+func (*FunctionProto) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{19}
+}
+
+func (x *FunctionProto) GetName() string {
+	if x != nil && x.Name != nil {
+		return *x.Name
+	}
+	return ""
+}
+
+func (x *FunctionProto) GetInput() []string {
+	if x != nil {
+		return x.Input
+	}
+	return nil
+}
+
+func (x *FunctionProto) GetOutput() []string {
+	if x != nil {
+		return x.Output
+	}
+	return nil
+}
+
+func (x *FunctionProto) GetAttribute() []string {
+	if x != nil {
+		return x.Attribute
+	}
+	return nil
+}
+
+func (x *FunctionProto) GetAttributeProto() []*AttributeProto {
+	if x != nil {
+		return x.AttributeProto
+	}
+	return nil
+}
+
+func (x *FunctionProto) GetNode() []*NodeProto {
+	if x != nil {
+		return x.Node
+	}
+	return nil
+}
+
+func (x *FunctionProto) GetDocString() string {
+	if x != nil && x.DocString != nil {
+		return *x.DocString
+	}
+	return ""
+}
+
+func (x *FunctionProto) GetOpsetImport() []*OperatorSetIdProto {
+	if x != nil {
+		return x.OpsetImport
+	}
+	return nil
+}
+
+func (x *FunctionProto) GetDomain() string {
+	if x != nil && x.Domain != nil {
+		return *x.Domain
+	}
+	return ""
+}
+
+func (x *FunctionProto) GetOverload() string {
+	if x != nil && x.Overload != nil {
+		return *x.Overload
+	}
+	return ""
+}
+
+func (x *FunctionProto) GetValueInfo() []*ValueInfoProto {
+	if x != nil {
+		return x.ValueInfo
+	}
+	return nil
+}
+
+func (x *FunctionProto) GetMetadataProps() []*StringStringEntryProto {
+	if x != nil {
+		return x.MetadataProps
+	}
+	return nil
+}
+
+// For very large tensors, we may want to store them in chunks, in which
+// case the following fields will specify the segment that is stored in
+// the current TensorProto.
+type TensorProto_Segment struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Begin         *int64                 `protobuf:"varint,1,opt,name=begin" json:"begin,omitempty"`
+	End           *int64                 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *TensorProto_Segment) Reset() {
+	*x = TensorProto_Segment{}
+	mi := &file_onnx_proto_msgTypes[20]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *TensorProto_Segment) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TensorProto_Segment) ProtoMessage() {}
+
+func (x *TensorProto_Segment) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[20]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TensorProto_Segment.ProtoReflect.Descriptor instead.
+func (*TensorProto_Segment) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{14, 0}
+}
+
+func (x *TensorProto_Segment) GetBegin() int64 {
+	if x != nil && x.Begin != nil {
+		return *x.Begin
+	}
+	return 0
+}
+
+func (x *TensorProto_Segment) GetEnd() int64 {
+	if x != nil && x.End != nil {
+		return *x.End
+	}
+	return 0
+}
+
+type TensorShapeProto_Dimension struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// Types that are valid to be assigned to Value:
+	//
+	//	*TensorShapeProto_Dimension_DimValue
+	//	*TensorShapeProto_Dimension_DimParam
+	Value isTensorShapeProto_Dimension_Value `protobuf_oneof:"value"`
+	// Standard denotation can optionally be used to denote tensor
+	// dimensions with standard semantic descriptions to ensure
+	// that operations are applied to the correct axis of a tensor.
+	// Refer to https://github.com/onnx/onnx/blob/main/docs/DimensionDenotation.md#denotation-definition
+	// for pre-defined dimension denotations.
+	Denotation    *string `protobuf:"bytes,3,opt,name=denotation" json:"denotation,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *TensorShapeProto_Dimension) Reset() {
+	*x = TensorShapeProto_Dimension{}
+	mi := &file_onnx_proto_msgTypes[21]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *TensorShapeProto_Dimension) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TensorShapeProto_Dimension) ProtoMessage() {}
+
+func (x *TensorShapeProto_Dimension) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[21]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TensorShapeProto_Dimension.ProtoReflect.Descriptor instead.
+func (*TensorShapeProto_Dimension) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{16, 0}
+}
+
+func (x *TensorShapeProto_Dimension) GetValue() isTensorShapeProto_Dimension_Value {
+	if x != nil {
+		return x.Value
+	}
+	return nil
+}
+
+func (x *TensorShapeProto_Dimension) GetDimValue() int64 {
+	if x != nil {
+		if x, ok := x.Value.(*TensorShapeProto_Dimension_DimValue); ok {
+			return x.DimValue
+		}
+	}
+	return 0
+}
+
+func (x *TensorShapeProto_Dimension) GetDimParam() string {
+	if x != nil {
+		if x, ok := x.Value.(*TensorShapeProto_Dimension_DimParam); ok {
+			return x.DimParam
+		}
+	}
+	return ""
+}
+
+func (x *TensorShapeProto_Dimension) GetDenotation() string {
+	if x != nil && x.Denotation != nil {
+		return *x.Denotation
+	}
+	return ""
+}
+
+type isTensorShapeProto_Dimension_Value interface {
+	isTensorShapeProto_Dimension_Value()
+}
+
+type TensorShapeProto_Dimension_DimValue struct {
+	DimValue int64 `protobuf:"varint,1,opt,name=dim_value,json=dimValue,oneof"`
+}
+
+type TensorShapeProto_Dimension_DimParam struct {
+	DimParam string `protobuf:"bytes,2,opt,name=dim_param,json=dimParam,oneof"` // namespace Shape
+}
+
+func (*TensorShapeProto_Dimension_DimValue) isTensorShapeProto_Dimension_Value() {}
+
+func (*TensorShapeProto_Dimension_DimParam) isTensorShapeProto_Dimension_Value() {}
+
+type TypeProto_Tensor struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// This field MUST NOT have the value of UNDEFINED
+	// This field MUST have a valid TensorProto.DataType value
+	// This field MUST be present for this version of the IR.
+	ElemType      *int32            `protobuf:"varint,1,opt,name=elem_type,json=elemType" json:"elem_type,omitempty"`
+	Shape         *TensorShapeProto `protobuf:"bytes,2,opt,name=shape" json:"shape,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *TypeProto_Tensor) Reset() {
+	*x = TypeProto_Tensor{}
+	mi := &file_onnx_proto_msgTypes[22]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *TypeProto_Tensor) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TypeProto_Tensor) ProtoMessage() {}
+
+func (x *TypeProto_Tensor) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[22]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TypeProto_Tensor.ProtoReflect.Descriptor instead.
+func (*TypeProto_Tensor) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{17, 0}
+}
+
+func (x *TypeProto_Tensor) GetElemType() int32 {
+	if x != nil && x.ElemType != nil {
+		return *x.ElemType
+	}
+	return 0
+}
+
+func (x *TypeProto_Tensor) GetShape() *TensorShapeProto {
+	if x != nil {
+		return x.Shape
+	}
+	return nil
+}
+
+// repeated T
+type TypeProto_Sequence struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// The type and optional shape of each element of the sequence.
+	// This field MUST be present for this version of the IR.
+	ElemType      *TypeProto `protobuf:"bytes,1,opt,name=elem_type,json=elemType" json:"elem_type,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *TypeProto_Sequence) Reset() {
+	*x = TypeProto_Sequence{}
+	mi := &file_onnx_proto_msgTypes[23]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *TypeProto_Sequence) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TypeProto_Sequence) ProtoMessage() {}
+
+func (x *TypeProto_Sequence) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[23]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TypeProto_Sequence.ProtoReflect.Descriptor instead.
+func (*TypeProto_Sequence) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{17, 1}
+}
+
+func (x *TypeProto_Sequence) GetElemType() *TypeProto {
+	if x != nil {
+		return x.ElemType
+	}
+	return nil
+}
+
+// map<K,V>
+type TypeProto_Map struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// This field MUST have a valid TensorProto.DataType value
+	// This field MUST be present for this version of the IR.
+	// This field MUST refer to an integral type ([U]INT{8|16|32|64}) or STRING
+	KeyType *int32 `protobuf:"varint,1,opt,name=key_type,json=keyType" json:"key_type,omitempty"`
+	// This field MUST be present for this version of the IR.
+	ValueType     *TypeProto `protobuf:"bytes,2,opt,name=value_type,json=valueType" json:"value_type,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *TypeProto_Map) Reset() {
+	*x = TypeProto_Map{}
+	mi := &file_onnx_proto_msgTypes[24]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *TypeProto_Map) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TypeProto_Map) ProtoMessage() {}
+
+func (x *TypeProto_Map) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[24]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TypeProto_Map.ProtoReflect.Descriptor instead.
+func (*TypeProto_Map) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{17, 2}
+}
+
+func (x *TypeProto_Map) GetKeyType() int32 {
+	if x != nil && x.KeyType != nil {
+		return *x.KeyType
+	}
+	return 0
+}
+
+func (x *TypeProto_Map) GetValueType() *TypeProto {
+	if x != nil {
+		return x.ValueType
+	}
+	return nil
+}
+
+// wrapper for Tensor, Sequence, or Map
+type TypeProto_Optional struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// The type and optional shape of the element wrapped.
+	// This field MUST be present for this version of the IR.
+	// Possible values correspond to OptionalProto.DataType enum
+	ElemType      *TypeProto `protobuf:"bytes,1,opt,name=elem_type,json=elemType" json:"elem_type,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *TypeProto_Optional) Reset() {
+	*x = TypeProto_Optional{}
+	mi := &file_onnx_proto_msgTypes[25]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *TypeProto_Optional) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TypeProto_Optional) ProtoMessage() {}
+
+func (x *TypeProto_Optional) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[25]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TypeProto_Optional.ProtoReflect.Descriptor instead.
+func (*TypeProto_Optional) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{17, 3}
+}
+
+func (x *TypeProto_Optional) GetElemType() *TypeProto {
+	if x != nil {
+		return x.ElemType
+	}
+	return nil
+}
+
+type TypeProto_SparseTensor struct {
+	state protoimpl.MessageState `protogen:"open.v1"`
+	// This field MUST NOT have the value of UNDEFINED
+	// This field MUST have a valid TensorProto.DataType value
+	// This field MUST be present for this version of the IR.
+	ElemType      *int32            `protobuf:"varint,1,opt,name=elem_type,json=elemType" json:"elem_type,omitempty"`
+	Shape         *TensorShapeProto `protobuf:"bytes,2,opt,name=shape" json:"shape,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *TypeProto_SparseTensor) Reset() {
+	*x = TypeProto_SparseTensor{}
+	mi := &file_onnx_proto_msgTypes[26]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *TypeProto_SparseTensor) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*TypeProto_SparseTensor) ProtoMessage() {}
+
+func (x *TypeProto_SparseTensor) ProtoReflect() protoreflect.Message {
+	mi := &file_onnx_proto_msgTypes[26]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use TypeProto_SparseTensor.ProtoReflect.Descriptor instead.
+func (*TypeProto_SparseTensor) Descriptor() ([]byte, []int) {
+	return file_onnx_proto_rawDescGZIP(), []int{17, 4}
+}
+
+func (x *TypeProto_SparseTensor) GetElemType() int32 {
+	if x != nil && x.ElemType != nil {
+		return *x.ElemType
+	}
+	return 0
+}
+
+func (x *TypeProto_SparseTensor) GetShape() *TensorShapeProto {
+	if x != nil {
+		return x.Shape
+	}
+	return nil
+}
+
+var File_onnx_proto protoreflect.FileDescriptor
+
+const file_onnx_proto_rawDesc = "" +
+	"\n" +
+	"\n" +
+	"onnx.proto\x12\x04onnx\"\xe3\x06\n" +
+	"\x0eAttributeProto\x12\x12\n" +
+	"\x04name\x18\x01 \x01(\tR\x04name\x12\"\n" +
+	"\rref_attr_name\x18\x15 \x01(\tR\vrefAttrName\x12\x1d\n" +
+	"\n" +
+	"doc_string\x18\r \x01(\tR\tdocString\x126\n" +
+	"\x04type\x18\x14 \x01(\x0e2\".onnx.AttributeProto.AttributeTypeR\x04type\x12\f\n" +
+	"\x01f\x18\x02 \x01(\x02R\x01f\x12\f\n" +
+	"\x01i\x18\x03 \x01(\x03R\x01i\x12\f\n" +
+	"\x01s\x18\x04 \x01(\fR\x01s\x12\x1f\n" +
+	"\x01t\x18\x05 \x01(\v2\x11.onnx.TensorProtoR\x01t\x12\x1e\n" +
+	"\x01g\x18\x06 \x01(\v2\x10.onnx.GraphProtoR\x01g\x12<\n" +
+	"\rsparse_tensor\x18\x16 \x01(\v2\x17.onnx.SparseTensorProtoR\fsparseTensor\x12\x1f\n" +
+	"\x02tp\x18\x0e \x01(\v2\x0f.onnx.TypeProtoR\x02tp\x12\x16\n" +
+	"\x06floats\x18\a \x03(\x02R\x06floats\x12\x12\n" +
+	"\x04ints\x18\b \x03(\x03R\x04ints\x12\x18\n" +
+	"\astrings\x18\t \x03(\fR\astrings\x12+\n" +
+	"\atensors\x18\n" +
+	" \x03(\v2\x11.onnx.TensorProtoR\atensors\x12(\n" +
+	"\x06graphs\x18\v \x03(\v2\x10.onnx.GraphProtoR\x06graphs\x12>\n" +
+	"\x0esparse_tensors\x18\x17 \x03(\v2\x17.onnx.SparseTensorProtoR\rsparseTensors\x120\n" +
+	"\vtype_protos\x18\x0f \x03(\v2\x0f.onnx.TypeProtoR\n" +
+	"typeProtos\"\xd9\x01\n" +
+	"\rAttributeType\x12\r\n" +
+	"\tUNDEFINED\x10\x00\x12\t\n" +
+	"\x05FLOAT\x10\x01\x12\a\n" +
+	"\x03INT\x10\x02\x12\n" +
+	"\n" +
+	"\x06STRING\x10\x03\x12\n" +
+	"\n" +
+	"\x06TENSOR\x10\x04\x12\t\n" +
+	"\x05GRAPH\x10\x05\x12\x11\n" +
+	"\rSPARSE_TENSOR\x10\v\x12\x0e\n" +
+	"\n" +
+	"TYPE_PROTO\x10\r\x12\n" +
+	"\n" +
+	"\x06FLOATS\x10\x06\x12\b\n" +
+	"\x04INTS\x10\a\x12\v\n" +
+	"\aSTRINGS\x10\b\x12\v\n" +
+	"\aTENSORS\x10\t\x12\n" +
+	"\n" +
+	"\x06GRAPHS\x10\n" +
+	"\x12\x12\n" +
+	"\x0eSPARSE_TENSORS\x10\f\x12\x0f\n" +
+	"\vTYPE_PROTOS\x10\x0eJ\x04\b\f\x10\rJ\x04\b\x10\x10\x14R\x01v\"\xad\x01\n" +
+	"\x0eValueInfoProto\x12\x12\n" +
+	"\x04name\x18\x01 \x01(\tR\x04name\x12#\n" +
+	"\x04type\x18\x02 \x01(\v2\x0f.onnx.TypeProtoR\x04type\x12\x1d\n" +
+	"\n" +
+	"doc_string\x18\x03 \x01(\tR\tdocString\x12C\n" +
+	"\x0emetadata_props\x18\x04 \x03(\v2\x1c.onnx.StringStringEntryProtoR\rmetadataProps\"\x8b\x03\n" +
+	"\tNodeProto\x12\x14\n" +
+	"\x05input\x18\x01 \x03(\tR\x05input\x12\x16\n" +
+	"\x06output\x18\x02 \x03(\tR\x06output\x12\x12\n" +
+	"\x04name\x18\x03 \x01(\tR\x04name\x12\x17\n" +
+	"\aop_type\x18\x04 \x01(\tR\x06opType\x12\x16\n" +
+	"\x06domain\x18\a \x01(\tR\x06domain\x12\x1a\n" +
+	"\boverload\x18\b \x01(\tR\boverload\x122\n" +
+	"\tattribute\x18\x05 \x03(\v2\x14.onnx.AttributeProtoR\tattribute\x12\x1d\n" +
+	"\n" +
+	"doc_string\x18\x06 \x01(\tR\tdocString\x12C\n" +
+	"\x0emetadata_props\x18\t \x03(\v2\x1c.onnx.StringStringEntryProtoR\rmetadataProps\x12W\n" +
+	"\x15device_configurations\x18\n" +
+	" \x03(\v2\".onnx.NodeDeviceConfigurationProtoR\x14deviceConfigurations\">\n" +
+	"\x14IntIntListEntryProto\x12\x10\n" +
+	"\x03key\x18\x01 \x01(\x03R\x03key\x12\x14\n" +
+	"\x05value\x18\x02 \x03(\x03R\x05value\"\xae\x01\n" +
+	"\x1cNodeDeviceConfigurationProto\x12)\n" +
+	"\x10configuration_id\x18\x01 \x01(\tR\x0fconfigurationId\x12<\n" +
+	"\rsharding_spec\x18\x02 \x03(\v2\x17.onnx.ShardingSpecProtoR\fshardingSpec\x12%\n" +
+	"\x0epipeline_stage\x18\x03 \x01(\x05R\rpipelineStage\"\xda\x01\n" +
+	"\x11ShardingSpecProto\x12\x1f\n" +
+	"\vtensor_name\x18\x01 \x01(\tR\n" +
+	"tensorName\x12\x16\n" +
+	"\x06device\x18\x02 \x03(\x03R\x06device\x12T\n" +
+	"\x19index_to_device_group_map\x18\x03 \x03(\v2\x1a.onnx.IntIntListEntryProtoR\x15indexToDeviceGroupMap\x126\n" +
+	"\vsharded_dim\x18\x04 \x03(\v2\x15.onnx.ShardedDimProtoR\n" +
+	"shardedDim\"k\n" +
+	"\x0fShardedDimProto\x12\x12\n" +
+	"\x04axis\x18\x01 \x01(\x03R\x04axis\x12D\n" +
+	"\x0fsimple_sharding\x18\x02 \x03(\v2\x1b.onnx.SimpleShardedDimProtoR\x0esimpleSharding\"{\n" +
+	"\x15SimpleShardedDimProto\x12\x1d\n" +
+	"\tdim_value\x18\x01 \x01(\x03H\x00R\bdimValue\x12\x1d\n" +
+	"\tdim_param\x18\x02 \x01(\tH\x00R\bdimParam\x12\x1d\n" +
+	"\n" +
+	"num_shards\x18\x03 \x01(\x03R\tnumShardsB\x05\n" +
+	"\x03dim\"\x97\x02\n" +
+	"\x11TrainingInfoProto\x128\n" +
+	"\x0einitialization\x18\x01 \x01(\v2\x10.onnx.GraphProtoR\x0einitialization\x12.\n" +
+	"\talgorithm\x18\x02 \x01(\v2\x10.onnx.GraphProtoR\talgorithm\x12S\n" +
+	"\x16initialization_binding\x18\x03 \x03(\v2\x1c.onnx.StringStringEntryProtoR\x15initializationBinding\x12C\n" +
+	"\x0eupdate_binding\x18\x04 \x03(\v2\x1c.onnx.StringStringEntryProtoR\rupdateBinding\"\xb8\x04\n" +
+	"\n" +
+	"ModelProto\x12\x1d\n" +
+	"\n" +
+	"ir_version\x18\x01 \x01(\x03R\tirVersion\x12;\n" +
+	"\fopset_import\x18\b \x03(\v2\x18.onnx.OperatorSetIdProtoR\vopsetImport\x12#\n" +
+	"\rproducer_name\x18\x02 \x01(\tR\fproducerName\x12)\n" +
+	"\x10producer_version\x18\x03 \x01(\tR\x0fproducerVersion\x12\x16\n" +
+	"\x06domain\x18\x04 \x01(\tR\x06domain\x12#\n" +
+	"\rmodel_version\x18\x05 \x01(\x03R\fmodelVersion\x12\x1d\n" +
+	"\n" +
+	"doc_string\x18\x06 \x01(\tR\tdocString\x12&\n" +
+	"\x05graph\x18\a \x01(\v2\x10.onnx.GraphProtoR\x05graph\x12C\n" +
+	"\x0emetadata_props\x18\x0e \x03(\v2\x1c.onnx.StringStringEntryProtoR\rmetadataProps\x12<\n" +
+	"\rtraining_info\x18\x14 \x03(\v2\x17.onnx.TrainingInfoProtoR\ftrainingInfo\x121\n" +
+	"\tfunctions\x18\x19 \x03(\v2\x13.onnx.FunctionProtoR\tfunctions\x12D\n" +
+	"\rconfiguration\x18\x1a \x03(\v2\x1e.onnx.DeviceConfigurationProtoR\rconfiguration\"g\n" +
+	"\x18DeviceConfigurationProto\x12\x12\n" +
+	"\x04name\x18\x01 \x01(\tR\x04name\x12\x1f\n" +
+	"\vnum_devices\x18\x02 \x01(\x05R\n" +
+	"numDevices\x12\x16\n" +
+	"\x06device\x18\x03 \x03(\tR\x06device\"@\n" +
+	"\x16StringStringEntryProto\x12\x10\n" +
+	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
+	"\x05value\x18\x02 \x01(\tR\x05value\"\x92\x01\n" +
+	"\x10TensorAnnotation\x12\x1f\n" +
+	"\vtensor_name\x18\x01 \x01(\tR\n" +
+	"tensorName\x12]\n" +
+	"\x1cquant_parameter_tensor_names\x18\x02 \x03(\v2\x1c.onnx.StringStringEntryProtoR\x19quantParameterTensorNames\"\xcc\x04\n" +
+	"\n" +
+	"GraphProto\x12#\n" +
+	"\x04node\x18\x01 \x03(\v2\x0f.onnx.NodeProtoR\x04node\x12\x12\n" +
+	"\x04name\x18\x02 \x01(\tR\x04name\x123\n" +
+	"\vinitializer\x18\x05 \x03(\v2\x11.onnx.TensorProtoR\vinitializer\x12F\n" +
+	"\x12sparse_initializer\x18\x0f \x03(\v2\x17.onnx.SparseTensorProtoR\x11sparseInitializer\x12\x1d\n" +
+	"\n" +
+	"doc_string\x18\n" +
+	" \x01(\tR\tdocString\x12*\n" +
+	"\x05input\x18\v \x03(\v2\x14.onnx.ValueInfoProtoR\x05input\x12,\n" +
+	"\x06output\x18\f \x03(\v2\x14.onnx.ValueInfoProtoR\x06output\x123\n" +
+	"\n" +
+	"value_info\x18\r \x03(\v2\x14.onnx.ValueInfoProtoR\tvalueInfo\x12O\n" +
+	"\x17quantization_annotation\x18\x0e \x03(\v2\x16.onnx.TensorAnnotationR\x16quantizationAnnotation\x12C\n" +
+	"\x0emetadata_props\x18\x10 \x03(\v2\x1c.onnx.StringStringEntryProtoR\rmetadataPropsJ\x04\b\x03\x10\x04J\x04\b\x04\x10\x05J\x04\b\x06\x10\n" +
+	"R\n" +
+	"ir_versionR\x10producer_versionR\fproducer_tagR\x06domain\"\xb1\b\n" +
+	"\vTensorProto\x12\x12\n" +
+	"\x04dims\x18\x01 \x03(\x03R\x04dims\x12\x1b\n" +
+	"\tdata_type\x18\x02 \x01(\x05R\bdataType\x123\n" +
+	"\asegment\x18\x03 \x01(\v2\x19.onnx.TensorProto.SegmentR\asegment\x12!\n" +
+	"\n" +
+	"float_data\x18\x04 \x03(\x02B\x02\x10\x01R\tfloatData\x12!\n" +
+	"\n" +
+	"int32_data\x18\x05 \x03(\x05B\x02\x10\x01R\tint32Data\x12\x1f\n" +
+	"\vstring_data\x18\x06 \x03(\fR\n" +
+	"stringData\x12!\n" +
+	"\n" +
+	"int64_data\x18\a \x03(\x03B\x02\x10\x01R\tint64Data\x12\x12\n" +
+	"\x04name\x18\b \x01(\tR\x04name\x12\x1d\n" +
+	"\n" +
+	"doc_string\x18\f \x01(\tR\tdocString\x12\x19\n" +
+	"\braw_data\x18\t \x01(\fR\arawData\x12A\n" +
+	"\rexternal_data\x18\r \x03(\v2\x1c.onnx.StringStringEntryProtoR\fexternalData\x12C\n" +
+	"\rdata_location\x18\x0e \x01(\x0e2\x1e.onnx.TensorProto.DataLocationR\fdataLocation\x12#\n" +
+	"\vdouble_data\x18\n" +
+	" \x03(\x01B\x02\x10\x01R\n" +
+	"doubleData\x12#\n" +
+	"\vuint64_data\x18\v \x03(\x04B\x02\x10\x01R\n" +
+	"uint64Data\x12C\n" +
+	"\x0emetadata_props\x18\x10 \x03(\v2\x1c.onnx.StringStringEntryProtoR\rmetadataProps\x1a1\n" +
+	"\aSegment\x12\x14\n" +
+	"\x05begin\x18\x01 \x01(\x03R\x05begin\x12\x10\n" +
+	"\x03end\x18\x02 \x01(\x03R\x03end\"\xee\x02\n" +
+	"\bDataType\x12\r\n" +
+	"\tUNDEFINED\x10\x00\x12\t\n" +
+	"\x05FLOAT\x10\x01\x12\t\n" +
+	"\x05UINT8\x10\x02\x12\b\n" +
+	"\x04INT8\x10\x03\x12\n" +
+	"\n" +
+	"\x06UINT16\x10\x04\x12\t\n" +
+	"\x05INT16\x10\x05\x12\t\n" +
+	"\x05INT32\x10\x06\x12\t\n" +
+	"\x05INT64\x10\a\x12\n" +
+	"\n" +
+	"\x06STRING\x10\b\x12\b\n" +
+	"\x04BOOL\x10\t\x12\v\n" +
+	"\aFLOAT16\x10\n" +
+	"\x12\n" +
+	"\n" +
+	"\x06DOUBLE\x10\v\x12\n" +
+	"\n" +
+	"\x06UINT32\x10\f\x12\n" +
+	"\n" +
+	"\x06UINT64\x10\r\x12\r\n" +
+	"\tCOMPLEX64\x10\x0e\x12\x0e\n" +
+	"\n" +
+	"COMPLEX128\x10\x0f\x12\f\n" +
+	"\bBFLOAT16\x10\x10\x12\x10\n" +
+	"\fFLOAT8E4M3FN\x10\x11\x12\x12\n" +
+	"\x0eFLOAT8E4M3FNUZ\x10\x12\x12\x0e\n" +
+	"\n" +
+	"FLOAT8E5M2\x10\x13\x12\x12\n" +
+	"\x0eFLOAT8E5M2FNUZ\x10\x14\x12\t\n" +
+	"\x05UINT4\x10\x15\x12\b\n" +
+	"\x04INT4\x10\x16\x12\x0e\n" +
+	"\n" +
+	"FLOAT4E2M1\x10\x17\x12\x0e\n" +
+	"\n" +
+	"FLOAT8E8M0\x10\x18\x12\t\n" +
+	"\x05UINT2\x10\x19\x12\b\n" +
+	"\x04INT2\x10\x1a\")\n" +
+	"\fDataLocation\x12\v\n" +
+	"\aDEFAULT\x10\x00\x12\f\n" +
+	"\bEXTERNAL\x10\x01\"\x7f\n" +
+	"\x11SparseTensorProto\x12)\n" +
+	"\x06values\x18\x01 \x01(\v2\x11.onnx.TensorProtoR\x06values\x12+\n" +
+	"\aindices\x18\x02 \x01(\v2\x11.onnx.TensorProtoR\aindices\x12\x12\n" +
+	"\x04dims\x18\x03 \x03(\x03R\x04dims\"\xba\x01\n" +
+	"\x10TensorShapeProto\x122\n" +
+	"\x03dim\x18\x01 \x03(\v2 .onnx.TensorShapeProto.DimensionR\x03dim\x1ar\n" +
+	"\tDimension\x12\x1d\n" +
+	"\tdim_value\x18\x01 \x01(\x03H\x00R\bdimValue\x12\x1d\n" +
+	"\tdim_param\x18\x02 \x01(\tH\x00R\bdimParam\x12\x1e\n" +
+	"\n" +
+	"denotation\x18\x03 \x01(\tR\n" +
+	"denotationB\a\n" +
+	"\x05value\"\xe7\x05\n" +
+	"\tTypeProto\x129\n" +
+	"\vtensor_type\x18\x01 \x01(\v2\x16.onnx.TypeProto.TensorH\x00R\n" +
+	"tensorType\x12?\n" +
+	"\rsequence_type\x18\x04 \x01(\v2\x18.onnx.TypeProto.SequenceH\x00R\fsequenceType\x120\n" +
+	"\bmap_type\x18\x05 \x01(\v2\x13.onnx.TypeProto.MapH\x00R\amapType\x12?\n" +
+	"\roptional_type\x18\t \x01(\v2\x18.onnx.TypeProto.OptionalH\x00R\foptionalType\x12L\n" +
+	"\x12sparse_tensor_type\x18\b \x01(\v2\x1c.onnx.TypeProto.SparseTensorH\x00R\x10sparseTensorType\x12\x1e\n" +
+	"\n" +
+	"denotation\x18\x06 \x01(\tR\n" +
+	"denotation\x1aS\n" +
+	"\x06Tensor\x12\x1b\n" +
+	"\telem_type\x18\x01 \x01(\x05R\belemType\x12,\n" +
+	"\x05shape\x18\x02 \x01(\v2\x16.onnx.TensorShapeProtoR\x05shape\x1a8\n" +
+	"\bSequence\x12,\n" +
+	"\telem_type\x18\x01 \x01(\v2\x0f.onnx.TypeProtoR\belemType\x1aP\n" +
+	"\x03Map\x12\x19\n" +
+	"\bkey_type\x18\x01 \x01(\x05R\akeyType\x12.\n" +
+	"\n" +
+	"value_type\x18\x02 \x01(\v2\x0f.onnx.TypeProtoR\tvalueType\x1a8\n" +
+	"\bOptional\x12,\n" +
+	"\telem_type\x18\x01 \x01(\v2\x0f.onnx.TypeProtoR\belemType\x1aY\n" +
+	"\fSparseTensor\x12\x1b\n" +
+	"\telem_type\x18\x01 \x01(\x05R\belemType\x12,\n" +
+	"\x05shape\x18\x02 \x01(\v2\x16.onnx.TensorShapeProtoR\x05shapeB\a\n" +
+	"\x05value\"F\n" +
+	"\x12OperatorSetIdProto\x12\x16\n" +
+	"\x06domain\x18\x01 \x01(\tR\x06domain\x12\x18\n" +
+	"\aversion\x18\x02 \x01(\x03R\aversion\"\x80\x04\n" +
+	"\rFunctionProto\x12\x12\n" +
+	"\x04name\x18\x01 \x01(\tR\x04name\x12\x14\n" +
+	"\x05input\x18\x04 \x03(\tR\x05input\x12\x16\n" +
+	"\x06output\x18\x05 \x03(\tR\x06output\x12\x1c\n" +
+	"\tattribute\x18\x06 \x03(\tR\tattribute\x12=\n" +
+	"\x0fattribute_proto\x18\v \x03(\v2\x14.onnx.AttributeProtoR\x0eattributeProto\x12#\n" +
+	"\x04node\x18\a \x03(\v2\x0f.onnx.NodeProtoR\x04node\x12\x1d\n" +
+	"\n" +
+	"doc_string\x18\b \x01(\tR\tdocString\x12;\n" +
+	"\fopset_import\x18\t \x03(\v2\x18.onnx.OperatorSetIdProtoR\vopsetImport\x12\x16\n" +
+	"\x06domain\x18\n" +
+	" \x01(\tR\x06domain\x12\x1a\n" +
+	"\boverload\x18\r \x01(\tR\boverload\x123\n" +
+	"\n" +
+	"value_info\x18\f \x03(\v2\x14.onnx.ValueInfoProtoR\tvalueInfo\x12C\n" +
+	"\x0emetadata_props\x18\x0e \x03(\v2\x1c.onnx.StringStringEntryProtoR\rmetadataPropsJ\x04\b\x02\x10\x03J\x04\b\x03\x10\x04R\rsince_versionR\x06status*\xe7\x02\n" +
+	"\aVersion\x12\x12\n" +
+	"\x0e_START_VERSION\x10\x00\x12\x19\n" +
+	"\x15IR_VERSION_2017_10_10\x10\x01\x12\x19\n" +
+	"\x15IR_VERSION_2017_10_30\x10\x02\x12\x18\n" +
+	"\x14IR_VERSION_2017_11_3\x10\x03\x12\x18\n" +
+	"\x14IR_VERSION_2019_1_22\x10\x04\x12\x18\n" +
+	"\x14IR_VERSION_2019_3_18\x10\x05\x12\x18\n" +
+	"\x14IR_VERSION_2019_9_19\x10\x06\x12\x17\n" +
+	"\x13IR_VERSION_2020_5_8\x10\a\x12\x18\n" +
+	"\x14IR_VERSION_2021_7_30\x10\b\x12\x17\n" +
+	"\x13IR_VERSION_2023_5_5\x10\t\x12\x18\n" +
+	"\x14IR_VERSION_2024_3_25\x10\n" +
+	"\x12\x19\n" +
+	"\x15IR_VERSION_2025_05_12\x10\v\x12\x19\n" +
+	"\x15IR_VERSION_2025_08_26\x10\f\x12\x0e\n" +
+	"\n" +
+	"IR_VERSION\x10\r*.\n" +
+	"\x0eOperatorStatus\x12\x10\n" +
+	"\fEXPERIMENTAL\x10\x00\x12\n" +
+	"\n" +
+	"\x06STABLE\x10\x01B\x02H\x03"
+
+var (
+	file_onnx_proto_rawDescOnce sync.Once
+	file_onnx_proto_rawDescData []byte
+)
+
+func file_onnx_proto_rawDescGZIP() []byte {
+	file_onnx_proto_rawDescOnce.Do(func() {
+		file_onnx_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_onnx_proto_rawDesc), len(file_onnx_proto_rawDesc)))
+	})
+	return file_onnx_proto_rawDescData
+}
+
+var file_onnx_proto_enumTypes = make([]protoimpl.EnumInfo, 5)
+var file_onnx_proto_msgTypes = make([]protoimpl.MessageInfo, 27)
+var file_onnx_proto_goTypes = []any{
+	(Version)(0),                         // 0: onnx.Version
+	(OperatorStatus)(0),                  // 1: onnx.OperatorStatus
+	(AttributeProto_AttributeType)(0),    // 2: onnx.AttributeProto.AttributeType
+	(TensorProto_DataType)(0),            // 3: onnx.TensorProto.DataType
+	(TensorProto_DataLocation)(0),        // 4: onnx.TensorProto.DataLocation
+	(*AttributeProto)(nil),               // 5: onnx.AttributeProto
+	(*ValueInfoProto)(nil),               // 6: onnx.ValueInfoProto
+	(*NodeProto)(nil),                    // 7: onnx.NodeProto
+	(*IntIntListEntryProto)(nil),         // 8: onnx.IntIntListEntryProto
+	(*NodeDeviceConfigurationProto)(nil), // 9: onnx.NodeDeviceConfigurationProto
+	(*ShardingSpecProto)(nil),            // 10: onnx.ShardingSpecProto
+	(*ShardedDimProto)(nil),              // 11: onnx.ShardedDimProto
+	(*SimpleShardedDimProto)(nil),        // 12: onnx.SimpleShardedDimProto
+	(*TrainingInfoProto)(nil),            // 13: onnx.TrainingInfoProto
+	(*ModelProto)(nil),                   // 14: onnx.ModelProto
+	(*DeviceConfigurationProto)(nil),     // 15: onnx.DeviceConfigurationProto
+	(*StringStringEntryProto)(nil),       // 16: onnx.StringStringEntryProto
+	(*TensorAnnotation)(nil),             // 17: onnx.TensorAnnotation
+	(*GraphProto)(nil),                   // 18: onnx.GraphProto
+	(*TensorProto)(nil),                  // 19: onnx.TensorProto
+	(*SparseTensorProto)(nil),            // 20: onnx.SparseTensorProto
+	(*TensorShapeProto)(nil),             // 21: onnx.TensorShapeProto
+	(*TypeProto)(nil),                    // 22: onnx.TypeProto
+	(*OperatorSetIdProto)(nil),           // 23: onnx.OperatorSetIdProto
+	(*FunctionProto)(nil),                // 24: onnx.FunctionProto
+	(*TensorProto_Segment)(nil),          // 25: onnx.TensorProto.Segment
+	(*TensorShapeProto_Dimension)(nil),   // 26: onnx.TensorShapeProto.Dimension
+	(*TypeProto_Tensor)(nil),             // 27: onnx.TypeProto.Tensor
+	(*TypeProto_Sequence)(nil),           // 28: onnx.TypeProto.Sequence
+	(*TypeProto_Map)(nil),                // 29: onnx.TypeProto.Map
+	(*TypeProto_Optional)(nil),           // 30: onnx.TypeProto.Optional
+	(*TypeProto_SparseTensor)(nil),       // 31: onnx.TypeProto.SparseTensor
+}
+var file_onnx_proto_depIdxs = []int32{
+	2,  // 0: onnx.AttributeProto.type:type_name -> onnx.AttributeProto.AttributeType
+	19, // 1: onnx.AttributeProto.t:type_name -> onnx.TensorProto
+	18, // 2: onnx.AttributeProto.g:type_name -> onnx.GraphProto
+	20, // 3: onnx.AttributeProto.sparse_tensor:type_name -> onnx.SparseTensorProto
+	22, // 4: onnx.AttributeProto.tp:type_name -> onnx.TypeProto
+	19, // 5: onnx.AttributeProto.tensors:type_name -> onnx.TensorProto
+	18, // 6: onnx.AttributeProto.graphs:type_name -> onnx.GraphProto
+	20, // 7: onnx.AttributeProto.sparse_tensors:type_name -> onnx.SparseTensorProto
+	22, // 8: onnx.AttributeProto.type_protos:type_name -> onnx.TypeProto
+	22, // 9: onnx.ValueInfoProto.type:type_name -> onnx.TypeProto
+	16, // 10: onnx.ValueInfoProto.metadata_props:type_name -> onnx.StringStringEntryProto
+	5,  // 11: onnx.NodeProto.attribute:type_name -> onnx.AttributeProto
+	16, // 12: onnx.NodeProto.metadata_props:type_name -> onnx.StringStringEntryProto
+	9,  // 13: onnx.NodeProto.device_configurations:type_name -> onnx.NodeDeviceConfigurationProto
+	10, // 14: onnx.NodeDeviceConfigurationProto.sharding_spec:type_name -> onnx.ShardingSpecProto
+	8,  // 15: onnx.ShardingSpecProto.index_to_device_group_map:type_name -> onnx.IntIntListEntryProto
+	11, // 16: onnx.ShardingSpecProto.sharded_dim:type_name -> onnx.ShardedDimProto
+	12, // 17: onnx.ShardedDimProto.simple_sharding:type_name -> onnx.SimpleShardedDimProto
+	18, // 18: onnx.TrainingInfoProto.initialization:type_name -> onnx.GraphProto
+	18, // 19: onnx.TrainingInfoProto.algorithm:type_name -> onnx.GraphProto
+	16, // 20: onnx.TrainingInfoProto.initialization_binding:type_name -> onnx.StringStringEntryProto
+	16, // 21: onnx.TrainingInfoProto.update_binding:type_name -> onnx.StringStringEntryProto
+	23, // 22: onnx.ModelProto.opset_import:type_name -> onnx.OperatorSetIdProto
+	18, // 23: onnx.ModelProto.graph:type_name -> onnx.GraphProto
+	16, // 24: onnx.ModelProto.metadata_props:type_name -> onnx.StringStringEntryProto
+	13, // 25: onnx.ModelProto.training_info:type_name -> onnx.TrainingInfoProto
+	24, // 26: onnx.ModelProto.functions:type_name -> onnx.FunctionProto
+	15, // 27: onnx.ModelProto.configuration:type_name -> onnx.DeviceConfigurationProto
+	16, // 28: onnx.TensorAnnotation.quant_parameter_tensor_names:type_name -> onnx.StringStringEntryProto
+	7,  // 29: onnx.GraphProto.node:type_name -> onnx.NodeProto
+	19, // 30: onnx.GraphProto.initializer:type_name -> onnx.TensorProto
+	20, // 31: onnx.GraphProto.sparse_initializer:type_name -> onnx.SparseTensorProto
+	6,  // 32: onnx.GraphProto.input:type_name -> onnx.ValueInfoProto
+	6,  // 33: onnx.GraphProto.output:type_name -> onnx.ValueInfoProto
+	6,  // 34: onnx.GraphProto.value_info:type_name -> onnx.ValueInfoProto
+	17, // 35: onnx.GraphProto.quantization_annotation:type_name -> onnx.TensorAnnotation
+	16, // 36: onnx.GraphProto.metadata_props:type_name -> onnx.StringStringEntryProto
+	25, // 37: onnx.TensorProto.segment:type_name -> onnx.TensorProto.Segment
+	16, // 38: onnx.TensorProto.external_data:type_name -> onnx.StringStringEntryProto
+	4,  // 39: onnx.TensorProto.data_location:type_name -> onnx.TensorProto.DataLocation
+	16, // 40: onnx.TensorProto.metadata_props:type_name -> onnx.StringStringEntryProto
+	19, // 41: onnx.SparseTensorProto.values:type_name -> onnx.TensorProto
+	19, // 42: onnx.SparseTensorProto.indices:type_name -> onnx.TensorProto
+	26, // 43: onnx.TensorShapeProto.dim:type_name -> onnx.TensorShapeProto.Dimension
+	27, // 44: onnx.TypeProto.tensor_type:type_name -> onnx.TypeProto.Tensor
+	28, // 45: onnx.TypeProto.sequence_type:type_name -> onnx.TypeProto.Sequence
+	29, // 46: onnx.TypeProto.map_type:type_name -> onnx.TypeProto.Map
+	30, // 47: onnx.TypeProto.optional_type:type_name -> onnx.TypeProto.Optional
+	31, // 48: onnx.TypeProto.sparse_tensor_type:type_name -> onnx.TypeProto.SparseTensor
+	5,  // 49: onnx.FunctionProto.attribute_proto:type_name -> onnx.AttributeProto
+	7,  // 50: onnx.FunctionProto.node:type_name -> onnx.NodeProto
+	23, // 51: onnx.FunctionProto.opset_import:type_name -> onnx.OperatorSetIdProto
+	6,  // 52: onnx.FunctionProto.value_info:type_name -> onnx.ValueInfoProto
+	16, // 53: onnx.FunctionProto.metadata_props:type_name -> onnx.StringStringEntryProto
+	21, // 54: onnx.TypeProto.Tensor.shape:type_name -> onnx.TensorShapeProto
+	22, // 55: onnx.TypeProto.Sequence.elem_type:type_name -> onnx.TypeProto
+	22, // 56: onnx.TypeProto.Map.value_type:type_name -> onnx.TypeProto
+	22, // 57: onnx.TypeProto.Optional.elem_type:type_name -> onnx.TypeProto
+	21, // 58: onnx.TypeProto.SparseTensor.shape:type_name -> onnx.TensorShapeProto
+	59, // [59:59] is the sub-list for method output_type
+	59, // [59:59] is the sub-list for method input_type
+	59, // [59:59] is the sub-list for extension type_name
+	59, // [59:59] is the sub-list for extension extendee
+	0,  // [0:59] is the sub-list for field type_name
+}
+
+func init() { file_onnx_proto_init() }
+func file_onnx_proto_init() {
+	if File_onnx_proto != nil {
+		return
+	}
+	file_onnx_proto_msgTypes[7].OneofWrappers = []any{
+		(*SimpleShardedDimProto_DimValue)(nil),
+		(*SimpleShardedDimProto_DimParam)(nil),
+	}
+	file_onnx_proto_msgTypes[17].OneofWrappers = []any{
+		(*TypeProto_TensorType)(nil),
+		(*TypeProto_SequenceType)(nil),
+		(*TypeProto_MapType)(nil),
+		(*TypeProto_OptionalType)(nil),
+		(*TypeProto_SparseTensorType)(nil),
+	}
+	file_onnx_proto_msgTypes[21].OneofWrappers = []any{
+		(*TensorShapeProto_Dimension_DimValue)(nil),
+		(*TensorShapeProto_Dimension_DimParam)(nil),
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_onnx_proto_rawDesc), len(file_onnx_proto_rawDesc)),
+			NumEnums:      5,
+			NumMessages:   27,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_onnx_proto_goTypes,
+		DependencyIndexes: file_onnx_proto_depIdxs,
+		EnumInfos:         file_onnx_proto_enumTypes,
+		MessageInfos:      file_onnx_proto_msgTypes,
+	}.Build()
+	File_onnx_proto = out.File
+	file_onnx_proto_goTypes = nil
+	file_onnx_proto_depIdxs = nil
+}
diff --git a/onnx/onnx.go b/onnx/onnx.go
new file mode 100644
index 0000000..85db619
--- /dev/null
+++ b/onnx/onnx.go
@@ -0,0 +1,68 @@
+package onnx
+
+//go:generate bash scripts/gen.sh
+
+import (
+	"encoding/binary"
+	"math"
+	"os"
+
+	"google.golang.org/protobuf/proto"
+
+	"go.jknobloc.com/x/onnx/internal/pb"
+)
+
+func ExtractInitializer(name string, initializer string) ([]float32, []int, error) {
+	var data []byte
+
+	if d, err := os.ReadFile(name); err != nil {
+		return nil, nil, err
+	} else {
+		data = d
+	}
+
+	model := &pb.ModelProto{}
+
+	if err := proto.Unmarshal(data, model); err != nil {
+		return nil, nil, err
+	}
+
+	g := model.GetGraph()
+
+	var result []float32
+	var shape []int64
+
+	ok := false
+
+	for _, init := range g.GetInitializer() {
+		if init.GetName() == initializer {
+			raw := init.GetRawData()
+
+			result = make([]float32, len(raw)/4)
+
+			for i := 0; i < len(result); i++ {
+				bits := binary.LittleEndian.Uint32(raw[i*4 : (i+1)*4])
+
+				result[i] = math.Float32frombits(bits)
+			}
+
+			shape = init.GetDims()
+
+			ok = true
+
+			break
+		}
+	}
+
+	if !ok {
+		panic("initializer not found")
+	}
+
+	shapeInt := make([]int, len(shape))
+
+	for i, v := range shape {
+		shapeInt[i] = int(v)
+	}
+
+	return result, shapeInt, nil
+}
diff --git a/onnx/scripts/gen.sh b/onnx/scripts/gen.sh
new file mode 100644
index 0000000..683e51b
--- /dev/null
+++ b/onnx/scripts/gen.sh
@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd "$(dirname "$0")"
+
+PROTO_URL="https://raw.githubusercontent.com/onnx/onnx/v1.21.0/onnx/onnx.proto"
+PROTO_SHA256="a05cfbcd1370608b809c5b84c44e3198d3369036458e0b5f297e76ceaf9c4e1b"
+
+if [ ! -f onnx.proto ]; then
+    curl -fsSL "$PROTO_URL" -o onnx.proto
+fi
+
+echo "$PROTO_SHA256  onnx.proto" | shasum -a 256 -c
+
+protoc \
+    --go_out=../internal/pb \
+    --go_opt=paths=source_relative \
+    --go_opt=Monnx.proto=go.jknobloc.com/x/onnx/internal/pb \
+    onnx.proto