Struct tract_tensorflow::tfpb::tensorflow::OpDef

pub struct OpDef {
    pub name: String,
    pub input_arg: Vec<ArgDef>,
    pub output_arg: Vec<ArgDef>,
    pub attr: Vec<AttrDef>,
    pub deprecation: Option<OpDeprecation>,
    pub summary: String,
    pub description: String,
    pub is_commutative: bool,
    pub is_aggregate: bool,
    pub is_stateful: bool,
    pub allows_uninitialized_input: bool,
}

Defines an operation. A NodeDef in a GraphDef specifies an Op by using the “op” field which should match the name of a OpDef. LINT.IfChange

Fields

name: String

Op names starting with an underscore are reserved for internal use. Names should be CamelCase and match the regexp “[A-Z][a-zA-Z0-9_]*”.

input_arg: Vec<ArgDef>

Description of the input(s).

output_arg: Vec<ArgDef>

Description of the output(s).

attr: Vec<AttrDef>

deprecation: Option<OpDeprecation>

Optional deprecation based on GraphDef versions.

summary: String

One-line human-readable description of what the Op does.

description: String

Additional, longer human-readable description of what the Op does.

is_commutative: bool

True if the operation is commutative (“op(a,b) == op(b,a)” for all inputs)

is_aggregate: bool

If is_aggregate is true, then this operation accepts N >= 2 inputs and produces 1 output all of the same type. Should be associative and commutative, and produce output with the same shape as the input. The optimizer may replace an aggregate op taking input from multiple devices with a tree of aggregate ops that aggregate locally within each device (and possibly within groups of nearby devices) before communicating. TODO(josh11b): Implement that optimization.

for things like add

is_stateful: bool

Ops are marked as stateful if their behavior depends on some state beyond their input tensors (e.g. variable reading op) or if they have a side-effect (e.g. printing or asserting ops). Equivalently, stateless ops must always produce the same output for the same input and have no side-effects.

By default Ops may be moved between devices. Stateful ops should either not be moved, or should only be moved if that state can also be moved (e.g. via some sort of save / restore). Stateful ops are guaranteed to never be optimized away by Common Subexpression Elimination (CSE).

for things like variables, queue

allows_uninitialized_input: bool

By default, all inputs to an Op must be initialized Tensors. Ops that may initialize tensors for the first time should set this field to true, to allow the Op to take an uninitialized Tensor as input.

for Assign, etc.

Trait Implementations

impl Clone for OpDef

fn clone(&self) -> OpDef

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OpDef

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

Formats the value using the given formatter.

impl Default for OpDef

fn default() -> Self

Returns the “default value” for a type.

impl Message for OpDef

fn encode_raw<B>(&self, buf: &mut B) where
    B: BufMut, 

fn merge_field<B>(
    &mut self,
    tag: u32,
    wire_type: WireType,
    buf: &mut B,
    ctx: DecodeContext
) -> Result<(), DecodeError> where
    B: Buf, 

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, 

Encodes the message to a buffer.

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

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

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

Decodes an instance of the message from a buffer.

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

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

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

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, 

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

impl PartialEq<OpDef> for OpDef

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralPartialEq for OpDef