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

Implementations on Foreign Types

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<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<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 Relu

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<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 MseLoss

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 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 Linear<B>

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

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 LayerNorm<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 RotaryEncoding<B>

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>, u32), f32> for CrossEntropyLayer

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

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

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

impl AI<f32, f32> for MeanLayer

impl AI<f32, f32> for SumLayer

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

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

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

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

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

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

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

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<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, 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, 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, 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 Abs<A>

where AbsLayer: 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 Sum<A>

where SumLayer: AI<Y, 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 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 Softmax<A>

where SoftmaxLayer: 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 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 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> 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<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: Clone, const N: usize> AI<X, [Y; N]> for Duplicate<A>

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

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

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

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

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

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

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

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

impl<B: Backend> AI<Value<B>, (Value<B>, 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 SquaredErrorLayer

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

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

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 SoftmaxLayer

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 KQV<B>

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<B: Backend> AI<Value<B>, Vec<u32>> for ChooseLayer

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<LossOutput<B>, ClassificationOutput<B>> for ClassificationLayer

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

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

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

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<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: OpsNeg, Y> AI<X, Y> for NegLayer

where X::Output: Into<Y>,

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

where X::Output: Into<Y>,

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: 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>,