Struct LogicalOutput 

pub struct LogicalOutput {

    pub name: Option<String>,
    pub type_: Option<LogicalType>,
    pub shape: Vec<usize>,
    pub dshape: Vec<(DimName, usize)>,
    pub decoder: Option<DecoderKind>,
    pub encoding: Option<BoxEncoding>,
    pub score_format: Option<ScoreFormat>,
    pub normalized: Option<bool>,
    pub anchors: Option<Vec<[f32; 2]>>,
    pub stride: Option<Stride>,
    pub dtype: Option<DType>,
    pub quantization: Option<Quantization>,
    pub outputs: Vec<PhysicalOutput>,
    pub activation_applied: Option<Activation>,
    pub activation_required: Option<Activation>,
}

Logical output: the semantic contract the model exposes.

When outputs is empty, the logical output IS the physical tensor (dtype and quantization carry the tensor-level fields directly). When outputs contains one or more PhysicalOutput entries, those children are the real physical tensors and the logical shape is the reconstructed shape produced by the fallback merge path.

Fields

name: Option<String>

Logical output name (optional at the logical level).

type_: Option<LogicalType>

Semantic type. None marks the output as “additional” — carried in the schema for completeness (e.g. diagnostic or auxiliary tensors) but not participating in decoder dispatch. See SchemaV2::to_legacy_config_outputs for how typeless outputs are filtered out of the legacy config, and the module docs for when to use this vs. a recognised LogicalType variant.

shape: Vec<usize>

Reconstructed logical shape (what the fallback dequant+merge path produces).

dshape: Vec<(DimName, usize)>

Named dimensions ordered to match shape.

decoder: Option<DecoderKind>

Decoder to use for post-processing. Omitted for outputs consumed directly (e.g. protos) where no decode step is required.

encoding: Option<BoxEncoding>

Box encoding. Required on boxes logical outputs in v2.

score_format: Option<ScoreFormat>

Score format. Scores only.

normalized: Option<bool>

Coordinate format. true means [0, 1] normalized; false means pixel coordinates relative to the letterboxed model input. None means unspecified (decoder must infer). boxes and detections only.

anchors: Option<Vec<[f32; 2]>>

Anchor boxes for anchor-encoded logical outputs. Required when encoding: anchor.

stride: Option<Stride>

Spatial stride. For non-split logical outputs this is a spatial hint (e.g. protos at stride 4). For per-scale splits each child carries its own stride instead.

dtype: Option<DType>

Tensor dtype. Present when outputs is empty (this logical IS the physical tensor).

quantization: Option<Quantization>

Quantization parameters. Present when outputs is empty. None means the tensor is not quantized (float model).

outputs: Vec<PhysicalOutput>

Physical children that realize this logical output. Empty when the logical IS the physical tensor. At most one level of nesting is permitted.

activation_applied: Option<Activation>

Activation already applied by the model graph or runtime. The HAL must NOT re-apply an activation declared here.

On per-scale models the converter writes this on the logical parent (e.g. scores.activation_applied = sigmoid) when the model graph already includes the activation; the per-physical children inherit it.

activation_required: Option<Activation>

Activation NOT yet applied. The HAL MUST apply the declared activation before consuming the tensor.

On per-scale models the converter writes this on the logical parent (e.g. scores.activation_required = sigmoid) when the score-activation step was stripped from the model graph and must be re-applied by the runtime; per-physical children inherit the parent’s declaration.

Implementations

impl LogicalOutput

pub fn is_split(&self) -> bool

Returns true if this logical output has been split into physical children by the converter.

Trait Implementations

impl Clone for LogicalOutput

fn clone(&self) -> LogicalOutput

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LogicalOutput

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LogicalOutput

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for LogicalOutput

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LogicalOutput