Trait tract_pulse::internal::TypedOp[−]

pub trait TypedOp: 'static + Op + Debug + DynClone + Send + Sync + Downcast + EvalOp + DynHash {

Show methods    fn as_op(&self) -> &(dyn Op + 'static);

    fn as_op_mut(&mut self) -> &mut (dyn Op + 'static);

    fn output_facts(
        &self, 
        inputs: &[&TypedFact]
    ) -> Result<SmallVec<[TypedFact; 4]>, Error>;

    fn invariants(
        &self, 
        inputs: &[&TypedFact], 
        outputs: &[&TypedFact]
    ) -> Result<Invariants, Error> { ... }

    fn fuse(
        &self, 
        _model: &Graph<TypedFact, Box<dyn TypedOp + 'static, Global>>, 
        _node: &Node<TypedFact, Box<dyn TypedOp + 'static, Global>>
    ) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static, Global>>>, Error> { ... }

    fn declutter(
        &self, 
        model: &Graph<TypedFact, Box<dyn TypedOp + 'static, Global>>, 
        node: &Node<TypedFact, Box<dyn TypedOp + 'static, Global>>
    ) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static, Global>>>, Error> { ... }

    fn cost(
        &self, 
        _inputs: &[&TypedFact]
    ) -> Result<SmallVec<[(Cost, TDim); 4]>, Error> { ... }

    fn suggested_axis_changes(
        &self
    ) -> Result<SmallVec<[(InOut, AxisOp); 4]>, Error> { ... }

    fn change_axes(
        &self, 
        model: &Graph<TypedFact, Box<dyn TypedOp + 'static, Global>>, 
        node: &Node<TypedFact, Box<dyn TypedOp + 'static, Global>>, 
        io: InOut, 
        change: &AxisOp
    ) -> Result<Option<AxisChangeConsequence>, Error> { ... }

    fn slice_output(
        &self, 
        model: &Graph<TypedFact, Box<dyn TypedOp + 'static, Global>>, 
        node: &Node<TypedFact, Box<dyn TypedOp + 'static, Global>>, 
        patch: &mut ModelPatch<TypedFact, Box<dyn TypedOp + 'static, Global>>, 
        output_slot: usize, 
        axis: usize, 
        start: usize, 
        end: usize
    ) -> Result<Option<OutletId>, Error> { ... }

    fn quantize(
        &self, 
        model: &Graph<TypedFact, Box<dyn TypedOp + 'static, Global>>, 
        node: &Node<TypedFact, Box<dyn TypedOp + 'static, Global>>, 
        dt: DatumType, 
        scale: f32, 
        zero_point: i32
    ) -> Result<Option<Box<dyn TypedOp + 'static, Global>>, Error> { ... }

    fn concretize_dims(
        &self, 
        source: &Graph<TypedFact, Box<dyn TypedOp + 'static, Global>>, 
        node: &Node<TypedFact, Box<dyn TypedOp + 'static, Global>>, 
        target: &mut Graph<TypedFact, Box<dyn TypedOp + 'static, Global>>, 
        mapping: &HashMap<OutletId, OutletId, RandomState>, 
        values: &SymbolValues
    ) -> Result<SmallVec<[OutletId; 4]>, Error> { ... }

    fn codegen(
        &self, 
        model: &Graph<TypedFact, Box<dyn TypedOp + 'static, Global>>, 
        node: &Node<TypedFact, Box<dyn TypedOp + 'static, Global>>
    ) -> Result<Option<ModelPatch<TypedFact, Box<dyn TypedOp + 'static, Global>>>, Error> { ... }

    fn nested_model_multipliers(
        &self, 
        inputs: &[&TypedFact]
    ) -> Vec<(Cow<'_, str>, f64), Global>ⓘ
Notable traits for Vec<u8, A>
impl<A> Write for Vec<u8, A> where
    A: Allocator, 
 { ... }

}

Required methods

Reinterpret the TypedOp as an Op.

Reinterpret the TypedOp as an Op, mutably.

Deduce output facts from input facts.

Provided methods

Fuse op after codegen to deal with local optimisations.

Declutter the op to the tract_core operator set as much as possible.

Computes a cost hint of the operation.

Each pair is a type of operation and a number per call on eval.

Transforms the op in an equivalent one, operating on dt (i8 or u8).

Returns None if the op can not be translated.

Transform the op into by providing a value to one or more symbols.

Translate the op into the most efficient form possible for execution.

This transformation is supposed to be final, no more pass are expected to be run on the codegen networks.

Nested model multipliers, with label (for profiling).

Trait Implementations

Performs the conversion.

Performs the conversion.

Implementations on Foreign Types

Implementors