1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
/// 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. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AttributeProto { /// The name field MUST be present for this version of the IR. /// /// namespace Attribute #[prost(string, tag="1")] pub name: std::string::String, /// 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. #[prost(string, tag="21")] pub ref_attr_name: std::string::String, /// A human-readable documentation for this attribute. Markdown is allowed. #[prost(string, tag="13")] pub doc_string: std::string::String, /// 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 hueristics 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 accomodate proto3 implementations. /// /// discriminator that indicates which field below is in use #[prost(enumeration="attribute_proto::AttributeType", tag="20")] pub r#type: i32, /// Exactly ONE of the following fields must be present for this version of the IR /// /// float #[prost(float, tag="2")] pub f: f32, /// int #[prost(int64, tag="3")] pub i: i64, /// UTF-8 string #[prost(bytes, tag="4")] pub s: std::vec::Vec<u8>, /// tensor value #[prost(message, optional, tag="5")] pub t: ::std::option::Option<TensorProto>, /// graph #[prost(message, optional, tag="6")] pub g: ::std::option::Option<GraphProto>, /// sparse tensor value #[prost(message, optional, tag="22")] pub sparse_tensor: ::std::option::Option<SparseTensorProto>, // Do not use field below, it's deprecated. // optional ValueProto v = 12; // value - subsumes everything but graph /// list of floats #[prost(float, repeated, tag="7")] pub floats: ::std::vec::Vec<f32>, /// list of ints #[prost(int64, repeated, tag="8")] pub ints: ::std::vec::Vec<i64>, /// list of UTF-8 strings #[prost(bytes, repeated, tag="9")] pub strings: ::std::vec::Vec<std::vec::Vec<u8>>, /// list of tensors #[prost(message, repeated, tag="10")] pub tensors: ::std::vec::Vec<TensorProto>, /// list of graph #[prost(message, repeated, tag="11")] pub graphs: ::std::vec::Vec<GraphProto>, /// list of sparse tensors #[prost(message, repeated, tag="23")] pub sparse_tensors: ::std::vec::Vec<SparseTensorProto>, } pub mod attribute_proto { /// 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. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum AttributeType { Undefined = 0, Float = 1, Int = 2, String = 3, Tensor = 4, Graph = 5, SparseTensor = 11, Floats = 6, Ints = 7, Strings = 8, Tensors = 9, Graphs = 10, SparseTensors = 12, } } /// Defines information on value, including the name, the type, and /// the shape of the value. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ValueInfoProto { /// This field MUST be present in this version of the IR. /// /// namespace Value #[prost(string, tag="1")] pub name: std::string::String, /// This field MUST be present in this version of the IR for /// inputs and outputs of the top-level graph. #[prost(message, optional, tag="2")] pub r#type: ::std::option::Option<TypeProto>, /// A human-readable documentation for this value. Markdown is allowed. #[prost(string, tag="3")] pub doc_string: std::string::String, } /// 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. #[derive(Clone, PartialEq, ::prost::Message)] pub struct NodeProto { /// namespace Value #[prost(string, repeated, tag="1")] pub input: ::std::vec::Vec<std::string::String>, /// namespace Value #[prost(string, repeated, tag="2")] pub output: ::std::vec::Vec<std::string::String>, /// An optional identifier for this node in a graph. /// This field MAY be absent in ths version of the IR. /// /// namespace Node #[prost(string, tag="3")] pub name: std::string::String, /// The symbolic identifier of the Operator to execute. /// /// namespace Operator #[prost(string, tag="4")] pub op_type: std::string::String, /// The domain of the OperatorSet that specifies the operator named by op_type. /// /// namespace Domain #[prost(string, tag="7")] pub domain: std::string::String, /// Additional named attributes. #[prost(message, repeated, tag="5")] pub attribute: ::std::vec::Vec<AttributeProto>, /// A human-readable documentation for this node. Markdown is allowed. #[prost(string, tag="6")] pub doc_string: std::string::String, } /// 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. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ModelProto { /// The version of the IR this model targets. See Version enum above. /// This field MUST be present. #[prost(int64, tag="1")] pub ir_version: i64, /// 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. #[prost(message, repeated, tag="8")] pub opset_import: ::std::vec::Vec<OperatorSetIdProto>, /// 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. #[prost(string, tag="2")] pub producer_name: std::string::String, /// 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. #[prost(string, tag="3")] pub producer_version: std::string::String, /// 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. #[prost(string, tag="4")] pub domain: std::string::String, /// The version of the graph encoded. See Version enum below. #[prost(int64, tag="5")] pub model_version: i64, /// A human-readable documentation for this model. Markdown is allowed. #[prost(string, tag="6")] pub doc_string: std::string::String, /// The parameterized graph that is evaluated to execute the model. #[prost(message, optional, tag="7")] pub graph: ::std::option::Option<GraphProto>, /// Named metadata values; keys should be distinct. #[prost(message, repeated, tag="14")] pub metadata_props: ::std::vec::Vec<StringStringEntryProto>, } /// StringStringEntryProto follows the pattern for cross-proto-version maps. /// See https://developers.google.com/protocol-buffers/docs/proto3#maps #[derive(Clone, PartialEq, ::prost::Message)] pub struct StringStringEntryProto { #[prost(string, tag="1")] pub key: std::string::String, #[prost(string, tag="2")] pub value: std::string::String, } #[derive(Clone, PartialEq, ::prost::Message)] pub struct TensorAnnotation { #[prost(string, tag="1")] pub tensor_name: std::string::String, /// <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. #[prost(message, repeated, tag="2")] pub quant_parameter_tensor_names: ::std::vec::Vec<StringStringEntryProto>, } /// 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. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GraphProto { /// The nodes in the graph, sorted topologically. #[prost(message, repeated, tag="1")] pub node: ::std::vec::Vec<NodeProto>, /// The name of the graph. /// /// namespace Graph #[prost(string, tag="2")] pub name: std::string::String, /// A list of named tensor values, used to specify constant inputs of the graph. /// Each TensorProto entry must have a distinct name (within the list) that /// MAY also appear in the input list. #[prost(message, repeated, tag="5")] pub initializer: ::std::vec::Vec<TensorProto>, /// Initializers (see above) stored in sparse format. #[prost(message, repeated, tag="15")] pub sparse_initializer: ::std::vec::Vec<SparseTensorProto>, /// A human-readable documentation for this graph. Markdown is allowed. #[prost(string, tag="10")] pub doc_string: std::string::String, /// The inputs and outputs of the graph. #[prost(message, repeated, tag="11")] pub input: ::std::vec::Vec<ValueInfoProto>, #[prost(message, repeated, tag="12")] pub output: ::std::vec::Vec<ValueInfoProto>, /// 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. #[prost(message, repeated, tag="13")] pub value_info: ::std::vec::Vec<ValueInfoProto>, /// 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. #[prost(message, repeated, tag="14")] pub quantization_annotation: ::std::vec::Vec<TensorAnnotation>, } /// Tensors /// /// A serialized tensor value. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TensorProto { /// The shape of the tensor. #[prost(int64, repeated, tag="1")] pub dims: ::std::vec::Vec<i64>, /// The data type of the tensor. /// This field MUST have a valid TensorProto.DataType value #[prost(int32, tag="2")] pub data_type: i32, #[prost(message, optional, tag="3")] pub segment: ::std::option::Option<tensor_proto::Segment>, // Tensor content must be organized in row-major order. // // Depending on the data_type field, exactly one of the fields below with // name ending in _data is used to store the elements of the tensor. /// 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 apparing 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. #[prost(float, repeated, tag="4")] pub float_data: ::std::vec::Vec<f32>, /// For int32, uint8, int8, uint16, int16, bool, and float16 values /// float16 values must be bit-wise converted to an uint16_t prior /// to writing to the buffer. /// When this field is present, the data_type field MUST be /// INT32, INT16, INT8, UINT16, UINT8, BOOL, or FLOAT16 #[prost(int32, repeated, tag="5")] pub int32_data: ::std::vec::Vec<i32>, /// 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 #[prost(bytes, repeated, tag="6")] pub string_data: ::std::vec::Vec<std::vec::Vec<u8>>, /// For int64. /// When this field is present, the data_type field MUST be INT64 #[prost(int64, repeated, tag="7")] pub int64_data: ::std::vec::Vec<i64>, /// Optionally, a name for the tensor. /// /// namespace Value #[prost(string, tag="8")] pub name: std::string::String, /// A human-readable documentation for this tensor. Markdown is allowed. #[prost(string, tag="12")] pub doc_string: std::string::String, /// 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). /// /// 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 #[prost(bytes, tag="9")] pub raw_data: std::vec::Vec<u8>, /// 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. #[prost(message, repeated, tag="13")] pub external_data: ::std::vec::Vec<StringStringEntryProto>, /// If value not set, data is stored in raw_data (if set) otherwise in type-specified field. #[prost(enumeration="tensor_proto::DataLocation", tag="14")] pub data_location: i32, /// 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 apparing 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 #[prost(double, repeated, tag="10")] pub double_data: ::std::vec::Vec<f64>, /// For uint64 and uint32 values /// When this field is present, the data_type field MUST be /// UINT32 or UINT64 #[prost(uint64, repeated, tag="11")] pub uint64_data: ::std::vec::Vec<u64>, } pub mod tensor_proto { /// 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. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Segment { #[prost(int64, tag="1")] pub begin: i64, #[prost(int64, tag="2")] pub end: i64, } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum DataType { Undefined = 0, /// Basic types. /// /// float Float = 1, /// uint8_t Uint8 = 2, /// int8_t Int8 = 3, /// uint16_t Uint16 = 4, /// int16_t Int16 = 5, /// int32_t Int32 = 6, /// int64_t Int64 = 7, /// string String = 8, /// bool Bool = 9, /// IEEE754 half-precision floating-point format (16 bits wide). /// This format has 1 sign bit, 5 exponent bits, and 10 mantissa bits. Float16 = 10, Double = 11, Uint32 = 12, Uint64 = 13, /// complex with float32 real and imaginary components Complex64 = 14, /// complex with float64 real and imaginary components Complex128 = 15, /// 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. Bfloat16 = 16, } /// 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. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum DataLocation { Default = 0, External = 1, } } /// A serialized sparse-tensor value #[derive(Clone, PartialEq, ::prost::Message)] pub struct SparseTensorProto { /// 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. #[prost(message, optional, tag="1")] pub values: ::std::option::Option<TensorProto>, /// 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] #[prost(message, optional, tag="2")] pub indices: ::std::option::Option<TensorProto>, /// The shape of the underlying dense-tensor: [dim_1, dim_2, ... dim_rank] #[prost(int64, repeated, tag="3")] pub dims: ::std::vec::Vec<i64>, } /// Defines a tensor shape. A dimension can be either an integer value /// or a symbolic variable. A symbolic variable represents an unknown /// dimension. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TensorShapeProto { #[prost(message, repeated, tag="1")] pub dim: ::std::vec::Vec<tensor_shape_proto::Dimension>, } pub mod tensor_shape_proto { #[derive(Clone, PartialEq, ::prost::Message)] pub struct Dimension { /// 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/master/docs/DimensionDenotation.md#denotation-definition /// for pre-defined dimension denotations. #[prost(string, tag="3")] pub denotation: std::string::String, #[prost(oneof="dimension::Value", tags="1, 2")] pub value: ::std::option::Option<dimension::Value>, } pub mod dimension { #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Value { #[prost(int64, tag="1")] DimValue(i64), /// namespace Shape #[prost(string, tag="2")] DimParam(std::string::String), } } } /// Types /// /// The standard ONNX data types. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TypeProto { /// 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/master/docs/TypeDenotation.md#type-denotation-definition /// for pre-defined type denotations. #[prost(string, tag="6")] pub denotation: std::string::String, #[prost(oneof="type_proto::Value", tags="1, 4, 5")] pub value: ::std::option::Option<type_proto::Value>, } pub mod type_proto { #[derive(Clone, PartialEq, ::prost::Message)] pub struct Tensor { /// 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. #[prost(int32, tag="1")] pub elem_type: i32, #[prost(message, optional, tag="2")] pub shape: ::std::option::Option<super::TensorShapeProto>, } /// repeated T #[derive(Clone, PartialEq, ::prost::Message)] pub struct Sequence { /// The type and optional shape of each element of the sequence. /// This field MUST be present for this version of the IR. #[prost(message, optional, boxed, tag="1")] pub elem_type: ::std::option::Option<::std::boxed::Box<super::TypeProto>>, } /// map<K,V> #[derive(Clone, PartialEq, ::prost::Message)] pub struct Map { /// 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 #[prost(int32, tag="1")] pub key_type: i32, /// This field MUST be present for this version of the IR. #[prost(message, optional, boxed, tag="2")] pub value_type: ::std::option::Option<::std::boxed::Box<super::TypeProto>>, } #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum Value { /// The type of a tensor. #[prost(message, tag="1")] TensorType(Tensor), // NOTE: DNN-only implementations of ONNX MAY elect to not support non-tensor values // as input and output to graphs and nodes. These types are needed to naturally // support classical ML operators. DNN operators SHOULD restrict their input // and output types to tensors. /// The type of a sequence. #[prost(message, tag="4")] SequenceType(Box<Sequence>), /// The type of a map. #[prost(message, tag="5")] MapType(Box<Map>), } } /// Operator Sets /// /// OperatorSets are uniquely identified by a (domain, opset_version) pair. #[derive(Clone, PartialEq, ::prost::Message)] pub struct OperatorSetIdProto { /// 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. #[prost(string, tag="1")] pub domain: std::string::String, /// The version of the operator set being identified. /// This field MUST be present in this version of the IR. #[prost(int64, tag="2")] pub version: i64, } // Overview // // ONNX is an open specification that is comprised of the following components: // // 1) A definition of an extensible computation graph model. // 2) Definitions of standard data types. // 3) Definitions of built-in operators. // // This document describes the syntax of models and their computation graphs, // as well as the standard data types. Together, they are referred to as the ONNX // Intermediate Representation, or 'IR' for short. // // The normative semantic specification of the ONNX IR is found in docs/IR.md. // Definitions of the built-in neural network operators may be found in docs/Operators.md. // Notes // // Release // // We are still in the very early stage of defining ONNX. The current // version of ONNX is a starting point. While we are actively working // towards a complete spec, we would like to get the community involved // by sharing our working version of ONNX. // // Protobuf compatibility // // To simplify framework compatibility, ONNX is defined using the subset of protobuf // that is compatible with both protobuf v2 and v3. This means that we do not use any // protobuf features that are only available in one of the two versions. // // Here are the most notable contortions we have to carry out to work around // these limitations: // // - No 'map' (added protobuf 3.0). We instead represent mappings as lists // of key-value pairs, where order does not matter and duplicates // are not allowed. /// 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. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Version { /// proto3 requires the first enum value to be zero. /// We add this just to appease the compiler. StartVersion = 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 with 0x00000001, /// which was the version we published on Oct 10, 2017. IrVersion20171010 = 1, /// IR_VERSION 2 published on Oct 30, 2017 /// - Added type discriminator to AttributeProto to support proto3 users IrVersion20171030 = 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 IrVersion2017113 = 3, /// IR VERSION 4 published on Jan 22, 2019 /// - Relax constraint that initializers should be a subset of graph inputs /// - Add type BFLOAT16 IrVersion2019122 = 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. IrVersion2019318 = 5, /// IR VERSION 6 published on Sep 19, 2019 /// - Add support for sparse tensor constants stored in model. /// - Add message SparseTensorProto /// - Add sparse initializers IrVersion = 6, }