Trait AI 

pub trait AI<X, Y> {
    // Required method
    fn forward(&self, input: X) -> Y;

    // Provided method
    fn forward_mut(&mut self, input: X) -> Y { ... }
}

general ai trait

Required Methods

fn forward(&self, input: X) -> Y

applies to the input

Provided Methods

fn forward_mut(&mut self, input: X) -> Y

applies to the input, possibly updating internal caches

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<A: ?Sized + AI<X, Y>, X, Y> AI<X, Y> for &A

fn forward(&self, input: X) -> Y

impl<A: ?Sized + AI<X, Y>, X, Y> AI<X, Y> for &mut A

fn forward(&self, input: X) -> Y

fn forward_mut(&mut self, input: X) -> Y

impl<A: AI<X, X>, X> AI<X, X> for Option<A>

fn forward(&self, x: X) -> X

fn forward_mut(&mut self, x: X) -> X

impl<B: Backend> AI<(Value<B>, Value<B>), Value<B>> for CrossEntropyLoss<B>

fn forward(&self, (output, target): (Value<B>, Value<B>)) -> Value<B>

impl<B: Backend> AI<(Value<B>, usize), (Value<B>, usize)> for RotaryEncoding<B>

fn forward(&self, (input, offset): (Value<B>, usize)) -> (Value<B>, usize)

impl<B: Backend> AI<Value<B>, Value<B>> for BatchNorm<B>

fn forward(&self, input: Value<B>) -> Value<B>

impl<B: Backend> AI<Value<B>, Value<B>> for Conv2d<B>

fn forward(&self, input: Value<B>) -> Value<B>

impl<B: Backend> AI<Value<B>, Value<B>> for CrossEntropyLoss<B>

fn forward(&self, input: Value<B>) -> Value<B>

impl<B: Backend> AI<Value<B>, Value<B>> for Dropout

fn forward(&self, input: Value<B>) -> Value<B>

impl<B: Backend> AI<Value<B>, Value<B>> for Embedding<B>

fn forward(&self, input: Value<B>) -> Value<B>

impl<B: Backend> AI<Value<B>, Value<B>> for LayerNorm<B>

fn forward(&self, input: Value<B>) -> Value<B>

impl<B: Backend> AI<Value<B>, Value<B>> for Linear<B>

fn forward(&self, input: Value<B>) -> Value<B>

impl<B: Backend> AI<Value<B>, Value<B>> for MaxPool2d

fn forward(&self, input: Value<B>) -> Value<B>

impl<B: Backend> AI<Value<B>, Value<B>> for MseLoss

fn forward(&self, input: Value<B>) -> Value<B>

impl<B: Backend> AI<Value<B>, Value<B>> for Relu

fn forward(&self, input: Value<B>) -> Value<B>

impl<B: Backend> AI<Value<B>, Value<B>> for RotaryEncoding<B>

fn forward(&self, input: Value<B>) -> Value<B>

impl<B: Backend> AI<Value<B>, Value<B>> for Tanh

fn forward(&self, input: Value<B>) -> Value<B>

impl<X: Into<Y>, Y> AI<X, Y> for ()

fn forward(&self, input: X) -> Y

Implementors

impl AI<(Vec<f32>, Vec<f32>), Vec<f32>> for SquaredErrorLayer

impl AI<(Vec<f32>, Vec<f32>), f32> for CrossEntropyLayer

impl AI<(Vec<f32>, Vec<f32>), f32> for SquaredErrorLayer

impl AI<(Vec<f32>, u32), f32> for CrossEntropyLayer

impl AI<Vec<f32>, Vec<f32>> for AbnormalSoftmaxLayer

impl AI<Vec<f32>, Vec<f32>> for AccQLayer

impl AI<Vec<f32>, Vec<f32>> for LogSoftmaxLayer

impl AI<Vec<f32>, Vec<f32>> for SoftmaxLayer

impl AI<Vec<f32>, f32> for MeanLayer

impl AI<Vec<f32>, f32> for SumLayer

impl AI<f32, f32> for MeanLayer

impl AI<f32, f32> for SumLayer

impl<A: AI<K, S>, K, S, B: AI<L, T>, L, T, C: AI<M, U>, M, U, D: AI<N, V>, N, V, E: AI<O, W>, O, W, F: AI<P, X>, P, X, G: AI<Q, Y>, Q, Y, H: AI<R, Z>, R, Z> AI<(K, L, M, N, O, P, Q, R), (S, T, U, V, W, X, Y, Z)> for Zip<(A, B, C, D, E, F, G, H)>

impl<A: AI<M, T>, M, T, B: AI<N, U>, N, U, C: AI<O, V>, O, V, D: AI<P, W>, P, W, E: AI<Q, X>, Q, X, F: AI<R, Y>, R, Y, G: AI<S, Z>, S, Z> AI<(M, N, O, P, Q, R, S), (T, U, V, W, X, Y, Z)> for Zip<(A, B, C, D, E, F, G)>

impl<A: AI<O, U>, O, U, B: AI<P, V>, P, V, C: AI<Q, W>, Q, W, D: AI<R, X>, R, X, E: AI<S, Y>, S, Y, F: AI<T, Z>, T, Z> AI<(O, P, Q, R, S, T), (U, V, W, X, Y, Z)> for Zip<(A, B, C, D, E, F)>

impl<A: AI<Q, V>, Q, V, B: AI<R, W>, R, W, C: AI<S, X>, S, X, D: AI<T, Y>, T, Y, E: AI<U, Z>, U, Z> AI<(Q, R, S, T, U), (V, W, X, Y, Z)> for Zip<(A, B, C, D, E)>

impl<A: AI<R, S> + Op<Output = S>, B: AI<S, T> + Op<Output = T>, C: AI<T, U> + Op<Output = U>, D: AI<U, V> + Op<Output = V>, E: AI<V, W> + Op<Output = W>, F: AI<W, X> + Op<Output = X>, G: AI<X, Y> + Op<Output = Y>, H: AI<Y, Z>, R, S, T, U, V, W, X, Y, Z> AI<R, Z> for Sequential<(A, B, C, D, E, F, G, H)>

impl<A: AI<S, T> + Op<Output = T>, B: AI<T, U> + Op<Output = U>, C: AI<U, V> + Op<Output = V>, D: AI<V, W> + Op<Output = W>, E: AI<W, X> + Op<Output = X>, F: AI<X, Y> + Op<Output = Y>, G: AI<Y, Z>, S, T, U, V, W, X, Y, Z> AI<S, Z> for Sequential<(A, B, C, D, E, F, G)>

impl<A: AI<S, W>, S, W, B: AI<T, X>, T, X, C: AI<U, Y>, U, Y, D: AI<V, Z>, V, Z> AI<(S, T, U, V), (W, X, Y, Z)> for Zip<(A, B, C, D)>

impl<A: AI<T, U> + Op<Output = U>, B: AI<U, V> + Op<Output = V>, C: AI<V, W> + Op<Output = W>, D: AI<W, X> + Op<Output = X>, E: AI<X, Y> + Op<Output = Y>, F: AI<Y, Z>, T, U, V, W, X, Y, Z> AI<T, Z> for Sequential<(A, B, C, D, E, F)>

impl<A: AI<U, V> + Op<Output = V>, B: AI<V, W> + Op<Output = W>, C: AI<W, X> + Op<Output = X>, D: AI<X, Y> + Op<Output = Y>, E: AI<Y, Z>, U, V, W, X, Y, Z> AI<U, Z> for Sequential<(A, B, C, D, E)>

impl<A: AI<U, X>, U, X, B: AI<V, Y>, V, Y, C: AI<W, Z>, W, Z> AI<(U, V, W), (X, Y, Z)> for Zip<(A, B, C)>

impl<A: AI<V, W> + Op<Output = W>, B: AI<W, X> + Op<Output = X>, C: AI<X, Y> + Op<Output = Y>, D: AI<Y, Z>, V, W, X, Y, Z> AI<V, Z> for Sequential<(A, B, C, D)>

impl<A: AI<Vec<X>, Vec<Y>>, X, Y> AI<X, Y> for Unvec<A>

impl<A: AI<W, X> + Op<Output = X>, B: AI<X, Y> + Op<Output = Y>, C: AI<Y, Z>, W, X, Y, Z> AI<W, Z> for Sequential<(A, B, C)>

impl<A: AI<W, Y>, W, Y, B: AI<X, Z>, X, Z> AI<(W, X), (Y, Z)> for Zip<(A, B)>

impl<A: AI<W, Z> + AI<X, Y>, W, X, Y, Z> AI<W, Z> for SetType<A, X, Y>

impl<A: AI<X, L> + Op<Output = L>, L, R, X, Y> AI<(X, R), Y> for Add<A>

where AddLayer: AI<(L, R), Y>,

impl<A: AI<X, L> + Op<Output = L>, L, R, X, Y> AI<(X, R), Y> for Mul<A>

where MulLayer: AI<(L, R), Y>,

impl<A: AI<X, L> + Op<Output = L>, L, R, X, Y> AI<(X, R), Y> for SquaredError<A>

where SquaredErrorLayer: AI<(L, R), Y>,

impl<A: AI<X, LossOutput<B>>, B: Backend, X> AI<X, ClassificationOutput<B>> for Classification<A>

impl<A: AI<X, LossOutput<B>>, B: Backend, X> AI<X, RegressionOutput<B>> for Regression<A>

impl<A: AI<X, X>, X> AI<X, X> for Sequential<&[A]>

impl<A: AI<X, X>, X> AI<X, X> for Sequential<&mut [A]>

impl<A: AI<X, X>, X> AI<X, X> for Sequential<Vec<A>>

impl<A: AI<X, Y> + Op<Output = Y>, B: AI<Y, Z>, X, Y, Z> AI<X, Z> for Sequential<(A, B)>

impl<A: AI<X, Y> + Op<Output = Y>, I: IntoIterator<Item = X>, J: FromIterator<Y>, X, Y> AI<I, J> for Map<A>

impl<A: AI<X, Y> + Op<Output = Y>, R: Clone, X, Y, Z> AI<X, Z> for Flatten<A, R>

where FlattenLayer<R>: AI<Y, Z>,

impl<A: AI<X, Y> + Op<Output = Y>, R: Clone, X, Y, Z> AI<X, Z> for Reshape<A, R>

where ReshapeLayer<R>: AI<Y, Z>,

impl<A: AI<X, Y> + Op<Output = Y>, T, X, Y, Z> AI<(X, T), Z> for CrossEntropy<A>

where CrossEntropyLayer: AI<(Y, T), Z>,

impl<A: AI<X, Y> + Op<Output = Y>, X, Y, Z> AI<X, Z> for AbnormalSoftmax<A>

where AbnormalSoftmaxLayer: AI<Y, Z>,

impl<A: AI<X, Y> + Op<Output = Y>, X, Y, Z> AI<X, Z> for Abs<A>

where AbsLayer: AI<Y, Z>,

impl<A: AI<X, Y> + Op<Output = Y>, X, Y, Z> AI<X, Z> for Cat<A>

where CatLayer: AI<Y, Z>,

impl<A: AI<X, Y> + Op<Output = Y>, X, Y, Z> AI<X, Z> for Choose<A>

where ChooseLayer: AI<Y, Z>,

impl<A: AI<X, Y> + Op<Output = Y>, X, Y, Z> AI<X, Z> for LogSoftmax<A>

where LogSoftmaxLayer: AI<Y, Z>,

impl<A: AI<X, Y> + Op<Output = Y>, X, Y, Z> AI<X, Z> for Mean<A>

where MeanLayer: AI<Y, Z>,

impl<A: AI<X, Y> + Op<Output = Y>, X, Y, Z> AI<X, Z> for Neg<A>

where NegLayer: AI<Y, Z>,

impl<A: AI<X, Y> + Op<Output = Y>, X, Y, Z> AI<X, Z> for Softmax<A>

where SoftmaxLayer: AI<Y, Z>,

impl<A: AI<X, Y> + Op<Output = Y>, X, Y, Z> AI<X, Z> for Squeeze<A>

where SqueezeLayer: AI<Y, Z>,

impl<A: AI<X, Y> + Op<Output = Y>, X, Y, Z> AI<X, Z> for Stack<A>

where StackLayer: AI<Y, Z>,

impl<A: AI<X, Y> + Op<Output = Y>, X, Y, Z> AI<X, Z> for Sum<A>

where SumLayer: AI<Y, Z>,

impl<A: AI<X, Y> + Op<Output = Y>, X, Y, Z> AI<X, Z> for Unsqueeze<A>

where UnsqueezeLayer: AI<Y, Z>,

impl<A: AI<X, Y> + Op<Output = Y>, X: Clone + OpsAdd<Y, Output = Z>, Y: Into<Z>, Z> AI<X, Z> for Residual<A>

impl<A: AI<X, Y>, X, Y: Clone, const N: usize> AI<X, [Y; N]> for Duplicate<A>

impl<A: AI<X, Y>, X, Y: Clone> AI<X, (Y, Y)> for Duplicate<A>

impl<A: AI<X, Y>, X, Y: Clone> AI<X, (Y, Y, Y)> for Duplicate<A>

impl<A: AI<X, Y>, X, Y: Clone> AI<X, (Y, Y, Y, Y)> for Duplicate<A>

impl<A: AI<X, Y>, X, Y: Clone> AI<X, (Y, Y, Y, Y, Y)> for Duplicate<A>

impl<A: AI<X, Y>, X, Y: Clone> AI<X, (Y, Y, Y, Y, Y, Y)> for Duplicate<A>

impl<A: AI<X, Y>, X, Y: Clone> AI<X, (Y, Y, Y, Y, Y, Y, Y)> for Duplicate<A>

impl<A: AI<X, Y>, X, Y: Clone> AI<X, (Y, Y, Y, Y, Y, Y, Y, Y)> for Duplicate<A>

impl<A: AI<X, Y>, X, Y> AI<X, Y> for AccQ<A>

where AccQLayer: AI<Y, Y>,

impl<A: AI<X, Y>, X, Y> AI<X, Y> for Inner<A>

impl<B: Backend, X: Into<Y>, Y> AI<X, Y> for Identity<B>

impl<B: Backend> AI<(Value<B>, Value<B>), LossOutput<B>> for CrossEntropyLayer

impl<B: Backend> AI<(Value<B>, Value<B>), LossOutput<B>> for SquaredErrorLayer

impl<B: Backend> AI<(Value<B>, Value<B>), Value<B>> for CrossEntropyLayer

impl<B: Backend> AI<(Value<B>, Value<B>), Value<B>> for SquaredErrorLayer

impl<B: Backend> AI<(Value<B>, Value<B>), Vec<f32>> for CrossEntropyLayer

impl<B: Backend> AI<(Value<B>, Value<B>), Vec<f32>> for SquaredErrorLayer

impl<B: Backend> AI<(Value<B>, Value<B>), f32> for SquaredErrorLayer

impl<B: Backend> AI<(Value<B>, Value<B>, Value<B>), Value<B>> for Attention<B>

impl<B: Backend> AI<LossOutput<B>, ClassificationOutput<B>> for ClassificationLayer

impl<B: Backend> AI<LossOutput<B>, RegressionOutput<B>> for RegressionLayer

impl<B: Backend> AI<Value<B>, (Value<B>, Value<B>, Value<B>)> for KQV<B>

impl<B: Backend> AI<Value<B>, Tensor<B, 1>> for MeanLayer

impl<B: Backend> AI<Value<B>, Tensor<B, 1>> for SumLayer

impl<B: Backend> AI<Value<B>, Value<B>> for AccQLayer

impl<B: Backend> AI<Value<B>, Value<B>> for Attention<B>

impl<B: Backend> AI<Value<B>, Value<B>> for Cache<B>

impl<B: Backend> AI<Value<B>, Value<B>> for ChooseLayer

impl<B: Backend> AI<Value<B>, Value<B>> for CrossEntropyLayer

impl<B: Backend> AI<Value<B>, Value<B>> for KQV<B>

impl<B: Backend> AI<Value<B>, Value<B>> for Layer<B>

impl<B: Backend> AI<Value<B>, Value<B>> for MeanLayer

impl<B: Backend> AI<Value<B>, Value<B>> for SoftmaxLayer

impl<B: Backend> AI<Value<B>, Value<B>> for SquaredErrorLayer

impl<B: Backend> AI<Value<B>, Value<B>> for SumLayer

impl<B: Backend> AI<Value<B>, Vec<u32>> for ChooseLayer

impl<B: Backend> AI<Value<B>, f32> for MeanLayer

impl<B: Backend> AI<Value<B>, f32> for SumLayer

impl<B: Backend> AI<Value<B>, u32> for ChooseLayer

impl<C: AI<V, V> + Op<Output = V>, V: Clone + Default + Merge, S: BuildHasher> AI<HashMap<Label, V, S>, HashMap<Label, V, S>> for Graph<C>

impl<C: AI<V, V> + Op<Output = V>, V: Clone + Default + Merge> AI<Vec<V>, Vec<V>> for Graph<C>

impl<F: Fn(X) -> Y, X, Y> AI<X, Y> for Apply<F, X, Y>

impl<L: OpsAdd<R>, R, Y> AI<(L, R), Y> for AddLayer

where L::Output: Into<Y>,

impl<L: OpsMul<R>, R, Y> AI<(L, R), Y> for MulLayer

where L::Output: Into<Y>,

impl<W: AI<X, Y> + Wrappable, X, Y> AI<X, Y> for Wrapped<W>

impl<X: Cat, Y> AI<X, Y> for CatLayer

where X::Output: Into<Y>,

impl<X: Flatten<R>, R: Clone, Y> AI<X, Y> for FlattenLayer<R>

where X::Output: Into<Y>,

impl<X: OpsAbs, Y> AI<X, Y> for AbsLayer

where X::Output: Into<Y>,

impl<X: OpsNeg, Y> AI<X, Y> for NegLayer

where X::Output: Into<Y>,

impl<X: Reshape<R>, R: Clone, Y> AI<X, Y> for ReshapeLayer<R>

where X::Output: Into<Y>,

impl<X: Squeeze, Y> AI<X, Y> for SqueezeLayer

where X::Output: Into<Y>,

impl<X: Stack, Y> AI<X, Y> for StackLayer

where X::Output: Into<Y>,

impl<X: Unsqueeze, Y> AI<X, Y> for UnsqueezeLayer

where X::Output: Into<Y>,