Struct TensorProto 

pub struct TensorProto {

    pub dims: Vec<i64>,
    pub data_type: i32,
    pub segment: Option<Segment>,
    pub float_data: Vec<f32>,
    pub int32_data: Vec<i32>,
    pub string_data: Vec<Vec<u8>>,
    pub int64_data: Vec<i64>,
    pub name: String,
    pub doc_string: String,
    pub raw_data: Vec<u8>,
    pub external_data: Vec<StringStringEntryProto>,
    pub data_location: i32,
    pub double_data: Vec<f64>,
    pub uint64_data: Vec<u64>,
    pub metadata_props: Vec<StringStringEntryProto>,
}

Tensors

A serialized tensor value.

Fields

dims: Vec<i64>

The shape of the tensor.

data_type: i32

The data type of the tensor. This field MUST have a valid TensorProto.DataType value

segment: Option<Segment>

float_data: Vec<f32>

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.

int32_data: Vec<i32>

For int32, uint8, int8, uint16, int16, uint4, int4, 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).

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.

When this field is present, the data_type field MUST be INT32, INT16, INT8, INT4, UINT16, UINT8, UINT4, BOOL, FLOAT16, BFLOAT16, FLOAT8E4M3FN, FLOAT8E4M3FNUZ, FLOAT8E5M2, FLOAT8E5M2FNUZ, FLOAT8E8M0, FLOAT4E2M1

string_data: Vec<Vec<u8>>

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

int64_data: Vec<i64>

For int64. When this field is present, the data_type field MUST be INT64

name: String

Optionally, a name for the tensor.

namespace Value

doc_string: String

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

raw_data: Vec<u8>

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.

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

external_data: Vec<StringStringEntryProto>

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.

data_location: i32

If value not set, data is stored in raw_data (if set) otherwise in type-specified field.

double_data: Vec<f64>

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

uint64_data: Vec<u64>

For uint64 and uint32 values When this field is present, the data_type field MUST be UINT32 or UINT64

metadata_props: Vec<StringStringEntryProto>

Named metadata values; keys should be distinct.

Implementations

impl TensorProto

pub fn data_location(&self) -> DataLocation

Returns the enum value of data_location, or the default if the field is set to an invalid enum value.

pub fn set_data_location(&mut self, value: DataLocation)

Sets data_location to the provided enum value.

Trait Implementations

impl Clone for TensorProto

fn clone(&self) -> TensorProto

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TensorProto

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

Formats the value using the given formatter.

impl Default for TensorProto

fn default() -> TensorProto

Returns the “default value” for a type.

impl Message for TensorProto

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(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>

where 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( &self, buf: &mut impl BufMut, ) -> Result<(), EncodeError>

where 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(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes an instance of the message from a buffer.

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

where Self: Default,

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

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

where Self: Sized,

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

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

where Self: Sized,

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

impl PartialEq for TensorProto

fn eq(&self, other: &TensorProto) -> 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 TensorProto