Struct ModelProto 

pub struct ModelProto {
    pub ir_version: i64,
    pub opset_import: Vec<OperatorSetIdProto>,
    pub producer_name: String,
    pub producer_version: String,
    pub domain: String,
    pub model_version: i64,
    pub doc_string: String,
    pub graph: Option<GraphProto>,
    pub metadata_props: Vec<StringStringEntryProto>,
    pub training_info: Vec<TrainingInfoProto>,
    pub functions: Vec<FunctionProto>,
}

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.

Fields

ir_version: i64

The version of the IR this model targets. See Version enum above. This field MUST be present.

opset_import: Vec<OperatorSetIdProto>

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.

producer_name: String

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.

producer_version: 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.

domain: 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.

model_version: i64

The version of the graph encoded. See Version enum below.

doc_string: String

A human-readable documentation for this model. Markdown is allowed.

graph: Option<GraphProto>

The parameterized graph that is evaluated to execute the model.

metadata_props: Vec<StringStringEntryProto>

Named metadata values; keys should be distinct.

training_info: Vec<TrainingInfoProto>

Training-specific information. Sequentially executing all stored TrainingInfoProto.algorithms and assigning their outputs following the corresponding TrainingInfoProto.update_bindings is one training iteration. Similarly, to initialize the model (as if training hasn’t happened), the user should sequentially execute all stored TrainingInfoProto.initializations and assigns their outputs using TrainingInfoProto.initialization_bindings.

If this field is empty, the training behavior of the model is undefined.

functions: Vec<FunctionProto>

A list of function protos local to the model.

Name of the function “FunctionProto.name” should be unique within the domain “FunctionProto.domain”. In case of any conflicts the behavior (whether the model local functions are given higher priority, or standard opserator sets are given higher priotity 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.

Trait Implementations

impl Clone for ModelProto

fn clone(&self) -> ModelProto

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ModelProto

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ModelProto

fn default() -> Self

Returns the “default value” for a type.

impl Framework<ModelProto, Graph<InferenceFact, Box<dyn InferenceOp>>> for Onnx

fn model_for_path(&self, p: impl AsRef<Path>) -> TractResult<InferenceModel>

Build a model from a filename.

fn proto_model_for_path(&self, p: impl AsRef<Path>) -> TractResult<ModelProto>

Read a proto model from a filename.

fn proto_model_for_read(&self, r: &mut dyn Read) -> TractResult<ModelProto>

Parse a proto model from a reader.

fn model_for_proto_model_with_model_template( &self, proto: &ModelProto, template: InferenceModel, ) -> TractResult<InferenceModel>

Translate a proto model into a model, with some symbols already listed.

fn model_for_read(&self, r: &mut dyn Read) -> TractResult<InferenceModel>

Read a model from a reader

fn model_for_proto_model(&self, proto: &ProtoModel) -> Result<Model, Error>

Translate a proto model into a model.

impl Message for ModelProto

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode<B>(&self, buf: &mut B) -> Result<(), EncodeError>

where B: BufMut, Self: Sized,

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited<B>(&self, buf: &mut B) -> Result<(), EncodeError>

where B: BufMut, Self: Sized,

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode<B>(buf: B) -> Result<Self, DecodeError>

where B: Buf, Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited<B>(buf: B) -> Result<Self, DecodeError>

where B: Buf, Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge<B>(&mut self, buf: B) -> Result<(), DecodeError>

where B: Buf, Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited<B>(&mut self, buf: B) -> Result<(), DecodeError>

where B: Buf, Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq for ModelProto

fn eq(&self, other: &ModelProto) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ModelProto