Struct DeviceCpu

pub struct DeviceCpu<U>
where
    U: UnitValue<U>,
{ /* private fields */ }

Implementation of Device to be computed by CPU

Implementations

impl<U> DeviceCpu<U>

where U: UnitValue<U>,

pub fn new() -> Result<DeviceCpu<U>, DeviceError>

note: For the sake of implementation uniformity, DeviceCpu::new is defined as if it may return a DeviceError of type Result, but this error is never actually returned.

Trait Implementations

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceCpu<U>> for Identity<U, DeviceCpu<U>>

where U: UnitValue<U>,

fn apply( &self, _: &DeviceCpu<U>, input: &Arr<U, N>, ) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, _: &DeviceCpu<U>, _: &Arr<U, N>, loss: &Arr<U, N>, _: &Arr<U, N>, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, l: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceCpu<U>> for ReLu<U, DeviceCpu<U>>

where U: UnitValue<U>,

fn apply( &self, device: &DeviceCpu<U>, input: &Arr<U, N>, ) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, device: &DeviceCpu<U>, o: &Arr<U, N>, loss: &Arr<U, N>, u: &Arr<U, N>, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, _: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceCpu<U>> for Sigmoid<U, DeviceCpu<U>>

where U: UnitValue<U>,

fn apply( &self, device: &DeviceCpu<U>, input: &Arr<U, N>, ) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, device: &DeviceCpu<U>, o: &Arr<U, N>, loss: &Arr<U, N>, u: &Arr<U, N>, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, l: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceCpu<U>> for SoftMax<U, DeviceCpu<U>>

where U: UnitValue<U>,

fn apply( &self, device: &DeviceCpu<U>, input: &Arr<U, N>, ) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, device: &DeviceCpu<U>, o: &Arr<U, N>, loss: &Arr<U, N>, u: &Arr<U, N>, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, l: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceCpu<U>> for Swish<U, DeviceCpu<U>>

where U: UnitValue<U>,

fn apply( &self, device: &DeviceCpu<U>, input: &Arr<U, N>, ) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, device: &DeviceCpu<U>, o: &Arr<U, N>, loss: &Arr<U, N>, u: &Arr<U, N>, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, _: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceCpu<U>> for Tanh<U, DeviceCpu<U>>

where U: UnitValue<U>,

fn apply( &self, device: &DeviceCpu<U>, input: &Arr<U, N>, ) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, device: &DeviceCpu<U>, o: &Arr<U, N>, loss: &Arr<U, N>, u: &Arr<U, N>, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, _: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<'a, U, const N: usize> Activation<U, ArrView<'a, U, N>, Arr<U, N>, DeviceCpu<U>> for Identity<U, DeviceCpu<U>>

where U: UnitValue<U>,

fn apply( &self, _: &DeviceCpu<U>, input: &ArrView<'a, U, N>, ) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, _: &DeviceCpu<U>, _: &ArrView<'a, U, N>, loss: &ArrView<'a, U, N>, _: &ArrView<'a, U, N>, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, l: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<'a, U, const N: usize> Activation<U, ArrView<'a, U, N>, Arr<U, N>, DeviceCpu<U>> for ReLu<U, DeviceCpu<U>>

where U: UnitValue<U>,

fn apply( &self, device: &DeviceCpu<U>, input: &ArrView<'a, U, N>, ) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, device: &DeviceCpu<U>, o: &ArrView<'a, U, N>, loss: &ArrView<'a, U, N>, u: &ArrView<'a, U, N>, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, _: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<'a, U, const N: usize> Activation<U, ArrView<'a, U, N>, Arr<U, N>, DeviceCpu<U>> for Sigmoid<U, DeviceCpu<U>>

where U: UnitValue<U>,

fn apply( &self, device: &DeviceCpu<U>, input: &ArrView<'a, U, N>, ) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, device: &DeviceCpu<U>, o: &ArrView<'a, U, N>, loss: &ArrView<'a, U, N>, u: &ArrView<'a, U, N>, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, l: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<'a, U, const N: usize> Activation<U, ArrView<'a, U, N>, Arr<U, N>, DeviceCpu<U>> for SoftMax<U, DeviceCpu<U>>

where U: UnitValue<U>,

fn apply( &self, device: &DeviceCpu<U>, input: &ArrView<'a, U, N>, ) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, device: &DeviceCpu<U>, o: &ArrView<'a, U, N>, loss: &ArrView<'a, U, N>, u: &ArrView<'a, U, N>, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, l: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<'a, U, const N: usize> Activation<U, ArrView<'a, U, N>, Arr<U, N>, DeviceCpu<U>> for Swish<U, DeviceCpu<U>>

where U: UnitValue<U>,

fn apply( &self, device: &DeviceCpu<U>, input: &ArrView<'a, U, N>, ) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, device: &DeviceCpu<U>, o: &ArrView<'a, U, N>, loss: &ArrView<'a, U, N>, u: &ArrView<'a, U, N>, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, _: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<'a, U, const N: usize> Activation<U, ArrView<'a, U, N>, Arr<U, N>, DeviceCpu<U>> for Tanh<U, DeviceCpu<U>>

where U: UnitValue<U>,

fn apply( &self, device: &DeviceCpu<U>, input: &ArrView<'a, U, N>, ) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, device: &DeviceCpu<U>, o: &ArrView<'a, U, N>, loss: &ArrView<'a, U, N>, u: &ArrView<'a, U, N>, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, _: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<U, I, const N: usize> Activation<U, I, Arr<U, N>, DeviceCpu<U>> for Identity<U, DeviceCpu<U>>

where U: UnitValue<U>, I: Iterator<Item = U> + Clone,

fn apply(&self, _: &DeviceCpu<U>, input: &I) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, _: &DeviceCpu<U>, _: &I, loss: &I, _: &I, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, l: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<U, I, const N: usize> Activation<U, I, Arr<U, N>, DeviceCpu<U>> for ReLu<U, DeviceCpu<U>>

where U: UnitValue<U>, I: Iterator<Item = U> + Clone,

fn apply(&self, _: &DeviceCpu<U>, input: &I) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, _: &DeviceCpu<U>, _: &I, loss: &I, u: &I, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, _: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<U, I, const N: usize> Activation<U, I, Arr<U, N>, DeviceCpu<U>> for Sigmoid<U, DeviceCpu<U>>

where U: UnitValue<U>, I: Iterator<Item = U> + Clone,

fn apply(&self, _: &DeviceCpu<U>, input: &I) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, _: &DeviceCpu<U>, o: &I, loss: &I, _: &I, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, l: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<U, I, const N: usize> Activation<U, I, Arr<U, N>, DeviceCpu<U>> for SoftMax<U, DeviceCpu<U>>

where U: UnitValue<U>, I: Iterator<Item = U> + Clone,

fn apply(&self, _: &DeviceCpu<U>, input: &I) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, _: &DeviceCpu<U>, o: &I, loss: &I, _: &I, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, l: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<U, I, const N: usize> Activation<U, I, Arr<U, N>, DeviceCpu<U>> for Swish<U, DeviceCpu<U>>

where U: UnitValue<U>, I: Iterator<Item = U> + Clone,

fn apply(&self, _: &DeviceCpu<U>, input: &I) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, _: &DeviceCpu<U>, o: &I, loss: &I, u: &I, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, _: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<U, I, const N: usize> Activation<U, I, Arr<U, N>, DeviceCpu<U>> for Tanh<U, DeviceCpu<U>>

where U: UnitValue<U>, I: Iterator<Item = U> + Clone,

fn apply(&self, _: &DeviceCpu<U>, input: &I) -> Result<Arr<U, N>, EvaluateError>

Apply the activation function

fn derive( &self, _: &DeviceCpu<U>, o: &I, loss: &I, _: &I, ) -> Result<Arr<U, N>, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, _: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<U, const N: usize> BatchActivation<U, SerializedVec<U, Arr<U, N>>, SerializedVec<U, Arr<U, N>>, DeviceCpu<U>> for Identity<U, DeviceCpu<U>>

where U: UnitValue<U>, Vec<Arr<U, N>>: FromParallelIterator<Arr<U, N>>,

fn batch_apply( &self, _: &DeviceCpu<U>, input: &SerializedVec<U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply the activation function

fn batch_derive( &self, _: &DeviceCpu<U>, _: &SerializedVec<U, Arr<U, N>>, loss: &SerializedVec<U, Arr<U, N>>, _: &SerializedVec<U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function

impl<U, const N: usize> BatchActivation<U, SerializedVec<U, Arr<U, N>>, SerializedVec<U, Arr<U, N>>, DeviceCpu<U>> for ReLu<U, DeviceCpu<U>>

where U: UnitValue<U>, Vec<Arr<U, N>>: FromParallelIterator<Arr<U, N>>,

fn batch_apply( &self, device: &DeviceCpu<U>, input: &SerializedVec<U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply the activation function

fn batch_derive( &self, device: &DeviceCpu<U>, o: &SerializedVec<U, Arr<U, N>>, loss: &SerializedVec<U, Arr<U, N>>, u: &SerializedVec<U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function

impl<U, const N: usize> BatchActivation<U, SerializedVec<U, Arr<U, N>>, SerializedVec<U, Arr<U, N>>, DeviceCpu<U>> for Sigmoid<U, DeviceCpu<U>>

where U: UnitValue<U>, Vec<Arr<U, N>>: FromParallelIterator<Arr<U, N>>,

fn batch_apply( &self, device: &DeviceCpu<U>, input: &SerializedVec<U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply the activation function

fn batch_derive( &self, device: &DeviceCpu<U>, o: &SerializedVec<U, Arr<U, N>>, loss: &SerializedVec<U, Arr<U, N>>, u: &SerializedVec<U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function

impl<U, const N: usize> BatchActivation<U, SerializedVec<U, Arr<U, N>>, SerializedVec<U, Arr<U, N>>, DeviceCpu<U>> for SoftMax<U, DeviceCpu<U>>

where U: UnitValue<U>, Vec<Arr<U, N>>: FromParallelIterator<Arr<U, N>>,

fn batch_apply( &self, device: &DeviceCpu<U>, input: &SerializedVec<U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply the activation function

fn batch_derive( &self, device: &DeviceCpu<U>, o: &SerializedVec<U, Arr<U, N>>, loss: &SerializedVec<U, Arr<U, N>>, u: &SerializedVec<U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function

impl<U, const N: usize> BatchActivation<U, SerializedVec<U, Arr<U, N>>, SerializedVec<U, Arr<U, N>>, DeviceCpu<U>> for Swish<U, DeviceCpu<U>>

where U: UnitValue<U>, Vec<Arr<U, N>>: FromParallelIterator<Arr<U, N>>,

fn batch_apply( &self, device: &DeviceCpu<U>, input: &SerializedVec<U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply the activation function

fn batch_derive( &self, device: &DeviceCpu<U>, o: &SerializedVec<U, Arr<U, N>>, loss: &SerializedVec<U, Arr<U, N>>, u: &SerializedVec<U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function

impl<U, const N: usize> BatchActivation<U, SerializedVec<U, Arr<U, N>>, SerializedVec<U, Arr<U, N>>, DeviceCpu<U>> for Tanh<U, DeviceCpu<U>>

where U: UnitValue<U>, Vec<Arr<U, N>>: FromParallelIterator<Arr<U, N>>,

fn batch_apply( &self, device: &DeviceCpu<U>, input: &SerializedVec<U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply the activation function

fn batch_derive( &self, device: &DeviceCpu<U>, o: &SerializedVec<U, Arr<U, N>>, loss: &SerializedVec<U, Arr<U, N>>, u: &SerializedVec<U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function

impl<'a, U, const N: usize> BatchActivation<U, SerializedVecView<'a, U, Arr<U, N>>, SerializedVec<U, Arr<U, N>>, DeviceCpu<U>> for Identity<U, DeviceCpu<U>>

where U: UnitValue<U>, Vec<Arr<U, N>>: FromParallelIterator<Arr<U, N>>,

fn batch_apply( &self, _: &DeviceCpu<U>, input: &SerializedVecView<'a, U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply the activation function

fn batch_derive( &self, _: &DeviceCpu<U>, _: &SerializedVecView<'a, U, Arr<U, N>>, loss: &SerializedVecView<'a, U, Arr<U, N>>, _: &SerializedVecView<'a, U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function

impl<'a, U, const N: usize> BatchActivation<U, SerializedVecView<'a, U, Arr<U, N>>, SerializedVec<U, Arr<U, N>>, DeviceCpu<U>> for ReLu<U, DeviceCpu<U>>

where U: UnitValue<U>, Vec<Arr<U, N>>: FromParallelIterator<Arr<U, N>>,

fn batch_apply( &self, device: &DeviceCpu<U>, input: &SerializedVecView<'a, U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply the activation function

fn batch_derive( &self, device: &DeviceCpu<U>, o: &SerializedVecView<'a, U, Arr<U, N>>, loss: &SerializedVecView<'a, U, Arr<U, N>>, u: &SerializedVecView<'a, U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function

impl<'a, U, const N: usize> BatchActivation<U, SerializedVecView<'a, U, Arr<U, N>>, SerializedVec<U, Arr<U, N>>, DeviceCpu<U>> for Sigmoid<U, DeviceCpu<U>>

where U: UnitValue<U>, Vec<Arr<U, N>>: FromParallelIterator<Arr<U, N>>,

fn batch_apply( &self, device: &DeviceCpu<U>, input: &SerializedVecView<'a, U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply the activation function

fn batch_derive( &self, device: &DeviceCpu<U>, o: &SerializedVecView<'a, U, Arr<U, N>>, loss: &SerializedVecView<'a, U, Arr<U, N>>, u: &SerializedVecView<'a, U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function

impl<'a, U, const N: usize> BatchActivation<U, SerializedVecView<'a, U, Arr<U, N>>, SerializedVec<U, Arr<U, N>>, DeviceCpu<U>> for SoftMax<U, DeviceCpu<U>>

where U: UnitValue<U>, Vec<Arr<U, N>>: FromParallelIterator<Arr<U, N>>,

fn batch_apply( &self, device: &DeviceCpu<U>, input: &SerializedVecView<'a, U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply the activation function

fn batch_derive( &self, device: &DeviceCpu<U>, o: &SerializedVecView<'a, U, Arr<U, N>>, loss: &SerializedVecView<'a, U, Arr<U, N>>, u: &SerializedVecView<'a, U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function

impl<'a, U, const N: usize> BatchActivation<U, SerializedVecView<'a, U, Arr<U, N>>, SerializedVec<U, Arr<U, N>>, DeviceCpu<U>> for Swish<U, DeviceCpu<U>>

where U: UnitValue<U>, Vec<Arr<U, N>>: FromParallelIterator<Arr<U, N>>,

fn batch_apply( &self, device: &DeviceCpu<U>, input: &SerializedVecView<'a, U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply the activation function

fn batch_derive( &self, device: &DeviceCpu<U>, o: &SerializedVecView<'a, U, Arr<U, N>>, loss: &SerializedVecView<'a, U, Arr<U, N>>, u: &SerializedVecView<'a, U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function

impl<'a, U, const N: usize> BatchActivation<U, SerializedVecView<'a, U, Arr<U, N>>, SerializedVec<U, Arr<U, N>>, DeviceCpu<U>> for Tanh<U, DeviceCpu<U>>

where U: UnitValue<U>, Vec<Arr<U, N>>: FromParallelIterator<Arr<U, N>>,

fn batch_apply( &self, device: &DeviceCpu<U>, input: &SerializedVecView<'a, U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply the activation function

fn batch_derive( &self, device: &DeviceCpu<U>, o: &SerializedVecView<'a, U, Arr<U, N>>, loss: &SerializedVecView<'a, U, Arr<U, N>>, u: &SerializedVecView<'a, U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function

impl<U, P, OP, I, PI, const N: usize> BatchNormalizationLayerInstantiation<U, Arr<U, N>, P, OP, DeviceCpu<U>, I, PI, Arr<U, N>, N> for BatchNormalizationLayer<U, Arr<U, N>, P, OP, DeviceCpu<U>, I, PI, Arr<U, N>, N>

where P: ForwardAll<Input = I, Output = PI> + BackwardAll<U, LossInput = PI> + PreTrain<U> + Loss<U>, U: Default + Clone + Copy + Send + UnitValue<U>, I: Debug + Send + Sync, OP: Optimizer<U, DeviceCpu<U>>,

fn with_params<B: OptimizerBuilder<U, DeviceCpu<U>, Output = OP>>( parent: P, device: &DeviceCpu<U>, scale: Arr<U, N>, bias: Arr<U, N>, momentum: U, b: &B, ) -> Result<BatchNormalizationLayer<U, Arr<U, N>, P, OP, DeviceCpu<U>, I, PI, Arr<U, N>, N>, LayerInstantiationError>

Create and return an instance with the specified scale, bias, and momentum.

fn with_momentum<B: OptimizerBuilder<U, DeviceCpu<U>, Output = OP>>( parent: P, device: &DeviceCpu<U>, momentum: U, b: &B, ) -> Result<BatchNormalizationLayer<U, Arr<U, N>, P, OP, DeviceCpu<U>, I, PI, Arr<U, N>, N>, LayerInstantiationError>

Create and return an instance with the momentum.

fn new<B: OptimizerBuilder<U, DeviceCpu<U>, Output = OP>>( parent: P, device: &DeviceCpu<U>, b: &B, ) -> Result<BatchNormalizationLayer<U, Arr<U, N>, P, OP, DeviceCpu<U>, I, PI, Arr<U, N>, N>, LayerInstantiationError>

Create and return an instance.

impl<U, P, OP, I, PI, const N: usize> BiasLayerInstantiation<U, Arr<U, N>, P, OP, DeviceCpu<U>, I, PI, N> for BiasLayer<U, Arr<U, N>, P, OP, DeviceCpu<U>, I, PI, N>

where P: ForwardAll<Input = I, Output = PI> + BackwardAll<U, LossInput = PI> + PreTrain<U> + Loss<U>, U: Default + Clone + Copy + Send + UnitValue<U>, I: Debug + Send + Sync, PI: Debug + BatchDataType, OP: Optimizer<U, DeviceCpu<U>>,

fn instantiation<UI: FnMut() -> U, B: OptimizerBuilder<U, DeviceCpu<U>, Output = OP>>( parent: P, device: &DeviceCpu<U>, ui: UI, b: &B, ) -> Result<BiasLayer<U, Arr<U, N>, P, OP, DeviceCpu<U>, I, PI, N>, LayerInstantiationError>

Create and return an instance with the specified scale, bias, and momentum.

impl<U> Clone for DeviceCpu<U>

where U: UnitValue<U>,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, U, I, A, const N: usize> DeviceActivation<U, I, A, N> for DeviceCpu<U>

where U: UnitValue<U>, I: BatchDataType + From<Arr<U, N>>, SerializedVec<U, Arr<U, N>>: IntoConverter, <I as BatchDataType>::Type: TryFrom<<SerializedVec<U, Arr<U, N>> as IntoConverter>::Converter, Error = TypeConvertError>, for<'b, 'b> A: Activation<U, ArrView<'b, U, N>, Arr<U, N>, Self> + BatchActivation<U, SerializedVecView<'b, U, Arr<U, N>>, SerializedVec<U, Arr<U, N>>, Self>, for<'b> ArrView<'b, U, N>: From<&'b I>, for<'b> SerializedVecView<'b, U, Arr<U, N>>: TryFrom<&'b <I as BatchDataType>::Type, Error = TypeConvertError>,

fn apply(&self, f: &A, input: &I) -> Result<I, EvaluateError>

Apply the activation function

fn derive(&self, f: &A, o: &I, loss: &I, u: &I) -> Result<I, TrainingError>

Apply derivatives of the activation function

fn batch_apply( &self, f: &A, input: &<I as BatchDataType>::Type, ) -> Result<<I as BatchDataType>::Type, TrainingError>

Apply the activation function

fn batch_derive( &self, f: &A, o: &<I as BatchDataType>::Type, loss: &<I as BatchDataType>::Type, u: &<I as BatchDataType>::Type, ) -> Result<<I as BatchDataType>::Type, TrainingError>

Apply derivatives of the activation function

fn is_canonical_link<L: LossFunction<U>>(&self, f: &A, l: &L) -> bool

Returns whether or not the canonical linkage function can be used.

impl<U, I, const N: usize> DeviceBatchNorm<U, Arr<U, N>, I, N> for DeviceCpu<U>

where U: UnitValue<U>, I: BatchDataType + Debug + From<Arr<U, N>> + 'static, <I as BatchDataType>::Type: Debug + 'static + TryFrom<<SerializedVec<U, Arr<U, N>> as IntoConverter>::Converter, Error = TypeConvertError>, SerializedVec<U, Arr<U, N>>: IntoConverter, for<'a> ArrView<'a, U, N>: From<&'a I>, for<'a> SerializedVecView<'a, U, Arr<U, N>>: TryFrom<&'a <I as BatchDataType>::Type, Error = TypeConvertError>,

fn forward_batch_norm<'a>( &self, input: &'a I, scale: &Arr<U, N>, bias: &Arr<U, N>, estimated_mean: &Arr<U, N>, estimated_variance: &Arr<U, N>, ) -> Result<I, EvaluateError>

Forward propagation calculation

fn forward_batch_norm_train<'a>( &self, input: &'a I, scale: &Arr<U, N>, bias: &Arr<U, N>, estimated_mean: &Arr<U, N>, estimated_variance: &Arr<U, N>, ) -> Result<(I, Arr<U, N>, Arr<U, N>), EvaluateError>

Forward propagation calculation (implemented in training mode)

fn batch_forward_batch_norm<'a>( &self, input: &'a <I as BatchDataType>::Type, scale: &Arr<U, N>, bias: &Arr<U, N>, estimated_mean: &Arr<U, N>, estimated_variance: &Arr<U, N>, ) -> Result<<I as BatchDataType>::Type, EvaluateError>

Forward propagation calculation in batch

fn batch_forward_batch_norm_train<'a>( &self, input: &'a <I as BatchDataType>::Type, scale: &Arr<U, N>, bias: &Arr<U, N>, running_mean: &Arr<U, N>, running_variance: &Arr<U, N>, momentum: U, ) -> Result<(<I as BatchDataType>::Type, Arr<U, N>, Arr<U, N>, Arr<U, N>, Arr<U, N>), TrainingError>

Forward propagation calculation in batch (implemented in training mode)

fn backward_batch_norm<'a>( &self, loss: &'a I, input: &'a I, scale: &Arr<U, N>, saved_mean: &Arr<U, N>, saved_inv_variance: &Arr<U, N>, ) -> Result<(I, Arr<U, N>, Arr<U, N>), TrainingError>

Error back propagation calculation

fn batch_backward_batch_norm<'a>( &self, loss: &'a <I as BatchDataType>::Type, input: &'a <I as BatchDataType>::Type, scale: &Arr<U, N>, saved_mean: &Arr<U, N>, saved_inv_variance: &Arr<U, N>, ) -> Result<(<I as BatchDataType>::Type, Arr<U, N>, Arr<U, N>), TrainingError>

Error back propagation calculation in batch

impl<U, IO, const N: usize> DeviceBias<U, Arr<U, N>, IO, N> for DeviceCpu<U>

where U: UnitValue<U>, IO: BatchDataType + Debug + Clone + From<Arr<U, N>>, <IO as BatchDataType>::Type: BatchSize + Debug + TryFrom<<SerializedVec<U, Arr<U, N>> as IntoConverter>::Converter, Error = TypeConvertError>, Arr<U, N>: From<IO>, SerializedVec<U, Arr<U, N>>: IntoConverter, for<'a> ArrView<'a, U, N>: From<&'a IO>, for<'a> SerializedVecView<'a, U, Arr<U, N>>: TryFrom<&'a <IO as BatchDataType>::Type, Error = TypeConvertError>, Self: DeviceReduce<<IO as BatchDataType>::Type, Arr<U, N>, U, N>,

fn forward_bias<'a>( &self, bias: &Arr<U, N>, input: &'a IO, ) -> Result<IO, EvaluateError>

Forward propagation calculation

fn backward_bias<'a>(&self, input: IO) -> Result<IO, TrainingError>

Error back propagation calculation

fn backward_bias_weight_gradient<'a>( &self, loss: &'a IO, ) -> Result<Arr<U, N>, TrainingError>

Calculate the gradient of the weights

fn batch_forward_bias<'a>( &self, bias: &Arr<U, N>, input: &'a <IO as BatchDataType>::Type, ) -> Result<<IO as BatchDataType>::Type, TrainingError>

Forward propagation calculation in batch

fn batch_backward_bias<'a>( &self, input: <IO as BatchDataType>::Type, ) -> Result<<IO as BatchDataType>::Type, TrainingError>

Error back propagation in batch

fn batch_backward_bias_weight_gradient<'a>( &self, loss: &'a <IO as BatchDataType>::Type, ) -> Result<Arr<U, N>, TrainingError>

Calculate the gradient of the weights in batch

impl<U, const NI: usize, const NO: usize> DeviceDiffLinear<U, Arr2<U, NI, NO>, Arr<U, NO>, NI, NO> for DeviceCpu<U>

where U: UnitValue<U>,

type Output = Arr<U, NO>

fn forward_diff_linear<'a>( &self, units: &Arr2<U, NI, NO>, bias: &Arr<U, NO>, input: &'a DiffInput<DiffArr<U, NI>, U, NI, NO>, ) -> Result<Arr<U, NO>, EvaluateError>

fn backward_diff_weight_gradient<'a>( &self, o: &'a DiffInput<DiffArr<U, NI>, U, NI, NO>, loss: &'a Arr<U, NO>, ) -> Result<Arr2<U, NI, NO>, TrainingError>

impl<U, I> DeviceInput<U, I> for DeviceCpu<U>

where U: UnitValue<U>, I: BatchDataType + Debug + 'static, <I as BatchDataType>::Type: Debug + 'static,

type Output = I

type BatchOutput = <I as BatchDataType>::Type

fn forward_input(&self, input: I) -> Result<Self::Output, TypeConvertError>

Type conversion during forward propagation

fn batch_forward_input( &self, input: <I as BatchDataType>::Type, ) -> Result<Self::BatchOutput, TypeConvertError>

Type conversion during forward propagation in batch

impl<U, I, const NI: usize, const NO: usize> DeviceLinear<U, Arr2<U, NI, NO>, Arr<U, NO>, I, NI, NO> for DeviceCpu<U>

where U: UnitValue<U>, I: BatchDataType + From<Arr<U, NI>> + Debug + 'static, <I as BatchDataType>::Type: Debug + 'static + TryFrom<<SerializedVec<U, Arr<U, NI>> as IntoConverter>::Converter, Error = TypeConvertError>, SerializedVec<U, Arr<U, NI>>: IntoConverter, for<'a> ArrView<'a, U, NI>: From<&'a I>, for<'a> SerializedVecView<'a, U, Arr<U, NI>>: TryFrom<&'a <I as BatchDataType>::Type, Error = TypeConvertError>, Self: DeviceReduce<SerializedVec<U, Arr<U, NO>>, Arr<U, NO>, U, NO>,

type Output = Arr<U, NO>

type BatchOutput = <Arr<U, NO> as BatchDataType>::Type

type LossOutput = I

type BatchLossOutput = <I as BatchDataType>::Type

fn forward_linear<'a>( &self, bias: &Arr<U, NO>, units: &Arr2<U, NI, NO>, input: &'a I, ) -> Result<Arr<U, NO>, EvaluateError>

Forward propagation calculation

fn backward_linear<'a>( &self, units: &Arr2<U, NI, NO>, input: &'a Arr<U, NO>, ) -> Result<I, TrainingError>

Error back propagation calculation

fn backward_weight_gradient<'a>( &self, o: &'a I, loss: &'a Arr<U, NO>, ) -> Result<Arr2<U, NI, NO>, TrainingError>

Calculate the gradient of the weights

fn backward_bias_weight_gradient<'a>( &self, loss: Self::Output, ) -> Result<Arr<U, NO>, TrainingError>

Calculate the gradient of the bias weights

fn batch_backward_linear<'a>( &self, units: &Arr2<U, NI, NO>, input: &'a SerializedVec<U, Arr<U, NO>>, ) -> Result<<I as BatchDataType>::Type, TrainingError>

Error back propagation in batch

fn batch_forward_linear<'a>( &self, bias: &Arr<U, NO>, units: &Arr2<U, NI, NO>, input: &'a <I as BatchDataType>::Type, ) -> Result<SerializedVec<U, Arr<U, NO>>, TrainingError>

Forward propagation calculation in batch

fn batch_backward_weight_gradient<'a>( &self, o: &'a <I as BatchDataType>::Type, loss: &'a SerializedVec<U, Arr<U, NO>>, ) -> Result<Arr2<U, NI, NO>, TrainingError>

Calculate the gradient of the weights in batch

fn batch_linear_reduce<'a>( &self, loss: &'a SerializedVec<U, Arr<U, NO>>, ) -> Result<Arr<U, NO>, TrainingError>

convolutional calculation

impl<'a, U, const N: usize> DeviceLinearOutput<'a, U, N> for DeviceCpu<U>

where U: UnitValue<U>,

type IO = Arr<U, N>

type BatchIO = SerializedVec<U, Arr<U, N>>

fn loss_linear<L>( &self, expected: &'a Arr<U, N>, actual: &'a Arr<U, N>, lossf: &L, ) -> Result<Arr<U, N>, TrainingError>

where L: LossFunction<U> + LossFunctionLinear<'a, U, Arr<U, N>, DeviceCpu<U>, N, Output = Arr<U, N>>,

Calculation of Losses

fn loss_linear_by_canonical_link( &self, expected: &'a Arr<U, N>, actual: &'a Arr<U, N>, ) -> Result<Arr<U, N>, TrainingError>

Calculation of Losses by canonical link

fn loss_linear_total<L: LossFunction<U>>( &self, exptected: &'a Arr<U, N>, actual: &'a Arr<U, N>, lossf: &L, ) -> Result<U, TrainingError>

Calculation of total Losses

fn loss_linear_batch_by_canonical_link( &self, expected: &'a SerializedVec<U, Arr<U, N>>, actual: &'a SerializedVec<U, Arr<U, N>>, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

where f64: From<U>,

Calculation of loss during batch execution by canonical link

fn batch_loss_linear<L>( &self, expected: &'a SerializedVec<U, Arr<U, N>>, actual: &'a SerializedVec<U, Arr<U, N>>, lossf: &L, ) -> Result<SerializedVec<U, Arr<U, N>>, TrainingError>

where L: LossFunction<U> + BatchLossFunctionLinear<'a, U, Self::BatchIO, DeviceCpu<U>, N, Output = Self::BatchIO>,

Calculation of Losses (all batch)

fn batch_loss_linear_total<L: LossFunction<U>>( &self, exptected: &'a SerializedVec<U, Arr<U, N>>, actual: &'a SerializedVec<U, Arr<U, N>>, lossf: &L, ) -> Result<U, TrainingError>

where f64: From<U> + FromPrimitive,

Calculation of total Losses (all batch)

impl<U, T, const N: usize> DeviceReduce<T, Arr<U, N>, U, N> for DeviceCpu<U>

where U: UnitValue<U> + Debug, for<'a> SerializedVecView<'a, U, Arr<U, N>>: TryFrom<&'a T, Error = TypeConvertError>,

fn reduce<'a>(&self, input: &'a T) -> Result<Arr<U, N>, TrainingError>

Convolutional computation of input

impl<U, P, OP, I, const NI: usize, const NO: usize> DiffLinearLayerInstantiation<U, Arr2<U, NI, NO>, Arr<U, NO>, P, OP, DeviceCpu<U>, I, NI, NO> for DiffLinearLayer<U, Arr2<U, NI, NO>, Arr<U, NO>, P, OP, DeviceCpu<U>, I, NI, NO>

where P: ForwardAll<Input = I, Output = DiffInput<DiffArr<U, NI>, U, NI, NO>> + BackwardAll<U, LossInput = ()> + PreTrain<U> + Loss<U>, U: Default + Clone + Copy + UnitValue<U>, I: Debug + Send + Sync, OP: Optimizer<U, DeviceCpu<U>>,

fn instantiation<UI: FnMut() -> U, BI: FnMut() -> U, B: OptimizerBuilder<U, DeviceCpu<U>, Output = OP>>( parent: P, device: &DeviceCpu<U>, ui: UI, bi: BI, b: &B, ) -> Result<DiffLinearLayer<U, Arr2<U, NI, NO>, Arr<U, NO>, P, OP, DeviceCpu<U>, I, NI, NO>, LayerInstantiationError>

Create an instance of DiffLinearLayers

impl<U, P, I, PI, OP, const NI: usize, const NO: usize> LinearLayerInstantiation<U, Arr2<U, NI, NO>, Arr<U, NO>, P, DeviceCpu<U>, I, PI, OP, NI, NO> for LinearLayer<U, Arr2<U, NI, NO>, Arr<U, NO>, P, DeviceCpu<U>, I, PI, OP, NI, NO>

where P: ForwardAll<Input = I, Output = PI> + BackwardAll<U, LossInput = PI> + PreTrain<U, PreOutput = PI> + Loss<U>, U: Default + Clone + Copy + UnitValue<U>, I: Debug + Send + Sync, PI: Debug, OP: Optimizer<U, DeviceCpu<U>>,

fn instantiation<B: OptimizerBuilder<U, DeviceCpu<U>, Output = OP>>( parent: P, device: &DeviceCpu<U>, ui: impl FnMut() -> U, bi: impl FnMut() -> U, b: &B, ) -> Result<LinearLayer<U, Arr2<U, NI, NO>, Arr<U, NO>, P, DeviceCpu<U>, I, PI, OP, NI, NO>, LayerInstantiationError>

Create an instance of LinearLayers

impl<U> Optimizer<U, DeviceCpu<U>> for Adagrad<U, DeviceCpu<U>>

where U: UnitValue<U>,

type InternalType = [U]

type InternalUpdateType<'a> = ShieldSlice<'a, U>

fn update<'a>( &mut self, e: &[U], w: Self::InternalUpdateType<'a>, ) -> Result<(), TrainingError>

Update Weights

impl<U> Optimizer<U, DeviceCpu<U>> for Adam<U, DeviceCpu<U>>

where U: UnitValue<U>,

type InternalType = [U]

type InternalUpdateType<'a> = ShieldSlice<'a, U>

fn update<'a>( &mut self, e: &'a [U], w: Self::InternalUpdateType<'a>, ) -> Result<(), TrainingError>

Update Weights

impl<U> Optimizer<U, DeviceCpu<U>> for MomentumSGD<U, DeviceCpu<U>>

where U: UnitValue<U>,

type InternalType = [U]

type InternalUpdateType<'a> = ShieldSlice<'a, U>

fn update<'a>( &mut self, e: &[U], w: Self::InternalUpdateType<'a>, ) -> Result<(), TrainingError>

Update Weights

impl<U> Optimizer<U, DeviceCpu<U>> for RMSprop<U, DeviceCpu<U>>

where U: UnitValue<U>,

type InternalType = [U]

type InternalUpdateType<'a> = ShieldSlice<'a, U>

fn update<'a>( &mut self, e: &'a [U], w: Self::InternalUpdateType<'a>, ) -> Result<(), TrainingError>

Update Weights

impl<U> Optimizer<U, DeviceCpu<U>> for SGD<U, DeviceCpu<U>>

where U: UnitValue<U>, DeviceCpu<U>: Device<U>,

type InternalType = [U]

type InternalUpdateType<'a> = ShieldSlice<'a, U>

fn update<'a>( &mut self, e: &'a [U], w: Self::InternalUpdateType<'a>, ) -> Result<(), TrainingError>

Update Weights

impl<U> OptimizerBuilder<U, DeviceCpu<U>> for AdagradBuilder<U, DeviceCpu<U>>

where U: UnitValue<U>, Adagrad<U, DeviceCpu<U>>: Optimizer<U, DeviceCpu<U>>,

type Output = Adagrad<U, DeviceCpu<U>>

fn build(&self, size: usize) -> Result<Self::Output, OptimizerBuildError>

Create and return an optimizer

impl<U> OptimizerBuilder<U, DeviceCpu<U>> for AdamBuilder<U, DeviceCpu<U>>

where U: UnitValue<U>, Adam<U, DeviceCpu<U>>: Optimizer<U, DeviceCpu<U>>,

type Output = Adam<U, DeviceCpu<U>>

fn build(&self, size: usize) -> Result<Self::Output, OptimizerBuildError>

Create and return an optimizer

impl<U> OptimizerBuilder<U, DeviceCpu<U>> for MomentumSGDBuilder<U, DeviceCpu<U>>

where U: UnitValue<U>, MomentumSGD<U, DeviceCpu<U>>: Optimizer<U, DeviceCpu<U>>,

type Output = MomentumSGD<U, DeviceCpu<U>>

fn build(&self, size: usize) -> Result<Self::Output, OptimizerBuildError>

Create and return an optimizer

impl<U> OptimizerBuilder<U, DeviceCpu<U>> for RMSpropBuilder<U, DeviceCpu<U>>

where U: UnitValue<U>, RMSprop<U, DeviceCpu<U>>: Optimizer<U, DeviceCpu<U>>,

type Output = RMSprop<U, DeviceCpu<U>>

fn build(&self, size: usize) -> Result<Self::Output, OptimizerBuildError>

Create and return an optimizer

impl<U> OptimizerState<U, DeviceCpu<U>> for Adagrad<U, DeviceCpu<U>>

where U: UnitValue<U>, DeviceCpu<U>: Device<U>,

type Type = Box<[U]>

State type

impl<U> OptimizerState<U, DeviceCpu<U>> for Adam<U, DeviceCpu<U>>

where U: UnitValue<U>, DeviceCpu<U>: Device<U>,

type Type = Box<[U]>

State type

impl<U> OptimizerState<U, DeviceCpu<U>> for MomentumSGD<U, DeviceCpu<U>>

where U: UnitValue<U>, DeviceCpu<U>: Device<U>,

type Type = Box<[U]>

State type

impl<U> OptimizerState<U, DeviceCpu<U>> for RMSprop<U, DeviceCpu<U>>

where U: UnitValue<U>, DeviceCpu<U>: Device<U>,

type Type = Box<[U]>

State type

impl<U> Device<U> for DeviceCpu<U>

where U: UnitValue<U>,