Struct nncombinator::device::DeviceGpu

source · [−]

pub struct DeviceGpu<U> {
    pub memory_pool: Arc<Mutex<MemoryPool>>,
    /* private fields */
}

Expand description

Implementation of Device to be computed by GPU

Fields

memory_pool: Arc<Mutex<MemoryPool>>

Memory pool for cuda memory allocation

Implementations

source

impl DeviceGpuwhere
U: UnitValue,

source

pub fn new(
memory_pool: &Arc<Mutex<MemoryPool>>
) -> Result<DeviceGpu, DeviceError>

Create an instance of DeviceGpu

Arguments

memory_pool - Memory pool for cuda memory allocation

Errors

This function may return the following errors

DeviceError

source

pub fn cublas(&self) -> &CublasContext

Returns the CublasContext owned by itself

Trait Implementations

source

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceGpu> for Identity<U, DeviceGpu>where
U: UnitValue,
DeviceGpu: Device,

source

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

Apply the activation function Read more

source

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

Apply derivatives of the activation function Read more

source

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

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

source

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceGpu> for ReLu<U, DeviceGpu>where
 U: UnitValue + DataTypeInfo,
 DeviceGpu: Device,
 ReLuForward: Kernel<Args = ActivationForwardArgs>,
 ReLuBackward: Kernel<Args = ActivationBackwardArgs>,

source

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

Apply the activation function Read more

source

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

Apply derivatives of the activation function Read more

source

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

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

source

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceGpu> for Sigmoid<U, DeviceGpu>where
 U: UnitValue + DataTypeInfo,
 DeviceGpu: Device,
 SigmoidForward: Kernel<Args = ActivationForwardArgs>,
 SigmoidBackward: Kernel<Args = ActivationBackwardArgs>,

source

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

Apply the activation function Read more

source

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

Apply derivatives of the activation function Read more

source

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

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

source

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceGpu> for SoftMax<U, DeviceGpu>where
 U: UnitValue + DataTypeInfo,
 DeviceGpu: Device,
 CudaPtr: TryFrom<U, Error = CudaError>,
 SoftMaxForward: Kernel<Args = ActivationForwardArgs>,
 SoftMaxBackward: Kernel<Args = ActivationBackwardArgs>,

source

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

Apply the activation function Read more

source

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

Apply derivatives of the activation function Read more

source

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

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

source

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceGpu> for Swish<U, DeviceGpu>where
 U: UnitValue + DataTypeInfo,
 DeviceGpu: Device,
 SwishForward: Kernel<Args = ActivationForwardArgs>,
 SwishBackward: Kernel<Args = ActivationBackwardArgs>,

source

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

Apply the activation function Read more

source

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

Apply derivatives of the activation function Read more

source

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

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

source

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceGpu> for Tanh<U, DeviceGpu>where
 U: UnitValue + DataTypeInfo,
 DeviceGpu: Device,
 TanhForward: Kernel<Args = ActivationForwardArgs>,
 TanhBackward: Kernel<Args = ActivationBackwardArgs>,

source

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

Apply the activation function Read more

source

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

Apply derivatives of the activation function Read more

source

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

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

source

impl<U, const N: usize> BatchActivation<U, Arr<U, N>, Arr<U, N>, DeviceGpu> for Identity<U, DeviceGpu>where
U: UnitValue,
DeviceGpu: Device,

source

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

Apply the activation function Read more

source

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

Apply derivatives of the activation function Read more

source

impl<U, const N: usize> BatchActivation<U, Arr<U, N>, Arr<U, N>, DeviceGpu> for ReLu<U, DeviceGpu>where
 U: UnitValue + DataTypeInfo,
 DeviceGpu: Device,
 ReLuForward: Kernel<Args = ActivationForwardArgs>,
 ReLuBackward: Kernel<Args = ActivationBackwardArgs>,

source

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

Apply the activation function Read more

source

fn batch_derive(
 &self,
 _: &DeviceGpu,
 _: &VecArr<U, Arr<U, N>>,
 loss: &VecArr<U, Arr<U, N>>,
 u: &VecArr<U, Arr<U, N>>
) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function Read more

source

impl<U, const N: usize> BatchActivation<U, Arr<U, N>, Arr<U, N>, DeviceGpu> for Sigmoid<U, DeviceGpu>where
 U: UnitValue + DataTypeInfo,
 DeviceGpu: Device,
 SigmoidForward: Kernel<Args = ActivationForwardArgs>,
 SigmoidBackward: Kernel<Args = ActivationBackwardArgs>,

source

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

Apply the activation function Read more

source

fn batch_derive(
 &self,
 _: &DeviceGpu,
 _: &VecArr<U, Arr<U, N>>,
 loss: &VecArr<U, Arr<U, N>>,
 u: &VecArr<U, Arr<U, N>>
) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function Read more

source

impl<U, const N: usize> BatchActivation<U, Arr<U, N>, Arr<U, N>, DeviceGpu> for SoftMax<U, DeviceGpu>where
 U: UnitValue + DataTypeInfo,
 DeviceGpu: Device,
 CudaPtr: TryFrom<U, Error = CudaError>,
 SoftMaxForward: Kernel<Args = ActivationForwardArgs>,
 SoftMaxBackward: Kernel<Args = ActivationBackwardArgs>,

source

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

Apply the activation function Read more

source

fn batch_derive(
 &self,
 _: &DeviceGpu,
 _: &VecArr<U, Arr<U, N>>,
 loss: &VecArr<U, Arr<U, N>>,
 u: &VecArr<U, Arr<U, N>>
) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function Read more

source

impl<U, const N: usize> BatchActivation<U, Arr<U, N>, Arr<U, N>, DeviceGpu> for Swish<U, DeviceGpu>where
 U: UnitValue + DataTypeInfo,
 DeviceGpu: Device,
 SwishForward: Kernel<Args = ActivationForwardArgs>,
 SwishBackward: Kernel<Args = ActivationBackwardArgs>,

source

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

Apply the activation function Read more

source

fn batch_derive(
 &self,
 _: &DeviceGpu,
 _: &VecArr<U, Arr<U, N>>,
 loss: &VecArr<U, Arr<U, N>>,
 u: &VecArr<U, Arr<U, N>>
) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function Read more

source

impl<U, const N: usize> BatchActivation<U, Arr<U, N>, Arr<U, N>, DeviceGpu> for Tanh<U, DeviceGpu>where
 U: UnitValue + DataTypeInfo,
 DeviceGpu: Device,
 TanhForward: Kernel<Args = ActivationForwardArgs>,
 TanhBackward: Kernel<Args = ActivationBackwardArgs>,

source

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

Apply the activation function Read more

source

fn batch_derive(
 &self,
 _: &DeviceGpu,
 _: &VecArr<U, Arr<U, N>>,
 loss: &VecArr<U, Arr<U, N>>,
 u: &VecArr<U, Arr<U, N>>
) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

Apply derivatives of the activation function Read more

source

impl BatchLossFunction<U, DeviceGpu> for CrossEntropywhere
 U: Clone + Copy + UnitValue + DataTypeInfo,
 DeviceGpu: Device,
 CudaPtr: TryFrom<U, Error = CudaError>,
 LinearBatchCrossEntropy: Kernel<Args = LinearBatchCrossEntropyArgs>,

source

fn batch_linear_derive<const N: usize>(
 &self,
 _: &DeviceGpu,
 expected: &VecArr<U, Arr<U, N>>,
 actual: &VecArr<U, Arr<U, N>>
) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

Differentiation of loss functions Read more

source

impl BatchLossFunction<U, DeviceGpu> for CrossEntropyMulticlasswhere
 U: Clone + Copy + UnitValue + DataTypeInfo,
 DeviceGpu: Device,
 CudaPtr: TryFrom<U, Error = CudaError>,
 LinearBatchCrossEntropyMulticlass: Kernel<Args = LinearBatchCrossEntropyMulticlassArgs>,

source

fn batch_linear_derive<const N: usize>(
 &self,
 _: &DeviceGpu,
 expected: &VecArr<U, Arr<U, N>>,
 actual: &VecArr<U, Arr<U, N>>
) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

Differentiation of loss functions Read more

source

impl BatchLossFunction<U, DeviceGpu> for Msewhere
 U: Clone + Copy + UnitValue + DataTypeInfo,
 DeviceGpu: Device,
 CudaPtr: TryFrom<U, Error = CudaError>,
 LinearBatchMse: Kernel<Args = LinearBatchMseArgs>,

source

fn batch_linear_derive<const N: usize>(
 &self,
 _: &DeviceGpu,
 expected: &VecArr<U, Arr<U, N>>,
 actual: &VecArr<U, Arr<U, N>>
) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

Differentiation of loss functions Read more

source

impl Clone for DeviceGpuwhere
U: UnitValue,

source

fn clone(&self) -> Self

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from source. Read more

source

impl Device<f32> for DeviceGpu<f32>

source

fn loss_linear<L, const N: usize>(
 &self,
 expected: &Arr<f32, N>,
 actual: &Arr<f32, N>,
 lossf: &L
) -> Arr<f32, N>where
 L: LossFunction<f32>,

Calculation of Losses Read more

source

fn loss_linear_by_canonical_link<const N: usize>(
 &self,
 expected: &Arr<f32, N>,
 actual: &Arr<f32, N>
) -> Arr<f32, N>

Calculation of Losses by canonical link Read more

source

fn loss_linear_total<L: LossFunction<f32>, const N: usize>(
 &self,
 exptected: &Arr<f32, N>,
 actual: &Arr<f32, N>,
 lossf: &L
) -> f32

Calculation of total Losses Read more

source

fn loss_linear_batch_by_canonical_link<const N: usize>(
 &self,
 expected: &VecArr<f32, Arr<f32, N>>,
 actual: &VecArr<f32, Arr<f32, N>>
) -> Result<VecArr<f32, Arr<f32, N>>, TrainingError>

Calculation of loss during batch execution by canonical link Read more

source

fn batch_linear_reduce<const N: usize>(
&self,
loss: &VecArr<f32, Arr<f32, N>>
) -> Result<Arr<f32, N>, TrainingError>

convolutional calculation Read more

source

fn batch_loss_linear_total<L: LossFunction, const N: usize>(
 &self,
 exptected: &VecArr<U, Arr<U, N>>,
 actual: &VecArr<U, Arr<U, N>>,
 lossf: &L
) -> U

Calculation of total Losses (all batch) Read more

source

impl Device<f64> for DeviceGpu<f64>

source

fn loss_linear<L, const N: usize>(
 &self,
 expected: &Arr<f64, N>,
 actual: &Arr<f64, N>,
 lossf: &L
) -> Arr<f64, N>where
 L: LossFunction<f64>,

Calculation of Losses Read more

source

fn loss_linear_by_canonical_link<const N: usize>(
 &self,
 expected: &Arr<f64, N>,
 actual: &Arr<f64, N>
) -> Arr<f64, N>

Calculation of Losses by canonical link Read more

source

fn loss_linear_total<L: LossFunction<f64>, const N: usize>(
 &self,
 exptected: &Arr<f64, N>,
 actual: &Arr<f64, N>,
 lossf: &L
) -> f64

Calculation of total Losses Read more

source

fn loss_linear_batch_by_canonical_link<const N: usize>(
 &self,
 expected: &VecArr<f64, Arr<f64, N>>,
 actual: &VecArr<f64, Arr<f64, N>>
) -> Result<VecArr<f64, Arr<f64, N>>, TrainingError>

Calculation of loss during batch execution by canonical link Read more

source

fn batch_linear_reduce<const N: usize>(
&self,
loss: &VecArr<f64, Arr<f64, N>>
) -> Result<Arr<f64, N>, TrainingError>

convolutional calculation Read more

source

fn batch_loss_linear_total<L: LossFunction, const N: usize>(
 &self,
 exptected: &VecArr<U, Arr<U, N>>,
 actual: &VecArr<U, Arr<U, N>>,
 lossf: &L
) -> U

Calculation of total Losses (all batch) Read more

source

impl<const NI: usize, const NO: usize> DeviceLinear<f32, CachedTensor<f32, Arr2<f32, NI, NO>>, NI, NO> for DeviceGpu<f32>

source

fn forward_linear(
 &self,
 bias: &Arr<f32, NO>,
 units: &CachedTensor<f32, Arr2<f32, NI, NO>>,
 input: &Arr<f32, NI>
) -> Result<Arr<f32, NO>, EvaluateError>

Forward propagation calculation Read more

source

fn backward_linear(
 &self,
 units: &CachedTensor<f32, Arr2<f32, NI, NO>>,
 input: &Arr<f32, NO>
) -> Result<Arr<f32, NI>, TrainingError>

Error back propagation calculation Read more

source

fn backward_weight_gradient(
 &self,
 o: &Arr<f32, NI>,
 loss: &Arr<f32, NO>
) -> Result<Arr2<f32, NI, NO>, TrainingError>

Calculate the gradient of the weights Read more

source

fn batch_forward_linear(
 &self,
 bias: &Arr<f32, NO>,
 units: &CachedTensor<f32, Arr2<f32, NI, NO>>,
 input: &VecArr<f32, Arr<f32, NI>>
) -> Result<VecArr<f32, Arr<f32, NO>>, TrainingError>

Forward propagation calculation in batch Read more

source

fn batch_backward_linear(
 &self,
 units: &CachedTensor<f32, Arr2<f32, NI, NO>>,
 input: &VecArr<f32, Arr<f32, NO>>
) -> Result<VecArr<f32, Arr<f32, NI>>, TrainingError>

Error back propagation in batch Read more

source

fn batch_backward_weight_gradient(
 &self,
 o: &VecArr<f32, Arr<f32, NI>>,
 loss: &VecArr<f32, Arr<f32, NO>>
) -> Result<Arr2<f32, NI, NO>, TrainingError>

Calculate the gradient of the weights in batch Read more

source

impl<const NI: usize, const NO: usize> DeviceLinear<f64, CachedTensor<f64, Arr2<f64, NI, NO>>, NI, NO> for DeviceGpu<f64>

source

fn forward_linear(
 &self,
 bias: &Arr<f64, NO>,
 units: &CachedTensor<f64, Arr2<f64, NI, NO>>,
 input: &Arr<f64, NI>
) -> Result<Arr<f64, NO>, EvaluateError>

Forward propagation calculation Read more

source

fn backward_linear(
 &self,
 units: &CachedTensor<f64, Arr2<f64, NI, NO>>,
 input: &Arr<f64, NO>
) -> Result<Arr<f64, NI>, TrainingError>

Error back propagation calculation Read more

source

fn backward_weight_gradient(
 &self,
 o: &Arr<f64, NI>,
 loss: &Arr<f64, NO>
) -> Result<Arr2<f64, NI, NO>, TrainingError>

Calculate the gradient of the weights Read more

source

fn batch_forward_linear(
 &self,
 bias: &Arr<f64, NO>,
 units: &CachedTensor<f64, Arr2<f64, NI, NO>>,
 input: &VecArr<f64, Arr<f64, NI>>
) -> Result<VecArr<f64, Arr<f64, NO>>, TrainingError>

Forward propagation calculation in batch Read more

source

fn batch_backward_linear(
 &self,
 units: &CachedTensor<f64, Arr2<f64, NI, NO>>,
 input: &VecArr<f64, Arr<f64, NO>>
) -> Result<VecArr<f64, Arr<f64, NI>>, TrainingError>

Error back propagation in batch Read more

source

fn batch_backward_weight_gradient(
 &self,
 o: &VecArr<f64, Arr<f64, NI>>,
 loss: &VecArr<f64, Arr<f64, NO>>
) -> Result<Arr2<f64, NI, NO>, TrainingError>

Calculate the gradient of the weights in batch Read more

source

impl DeviceMemoryPool for DeviceGpu

source

fn get_memory_pool(&self) -> &Arc<Mutex<MemoryPool>>

Returns the memory pool object owned by itself

Auto Trait Implementations

impl RefUnwindSafe for DeviceGpuwhere
U: RefUnwindSafe,

impl !Send for DeviceGpu

impl !Sync for DeviceGpu

impl Unpin for DeviceGpuwhere
U: Unpin,

impl UnwindSafe for DeviceGpuwhere
U: UnwindSafe,

Blanket Implementations

source

impl<T> Any for Twhere
T: 'static + ?Sized,

source

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

source

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

impl<T> From<T> for T

const: unstable · source

fn from(t: T) -> T

Returns the argument unchanged.

source

impl<T, U> Into for Twhere
U: From<T>,

const: unstable · source

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> Pointable for T

const ALIGN: usize = mem::align_of::<T>()

The alignment of pointer.

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

source

impl<T> ToOwned for Twhere
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

source

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

impl<T, U> TryFrom for Twhere
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

impl<T, U> TryInto for Twhere
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct nncombinator::device::DeviceGpu

Fields

Implementations

impl<U> DeviceGpu<U>where U: UnitValue<U>,

pub fn new( memory_pool: &Arc<Mutex<MemoryPool>>) -> Result<DeviceGpu<U>, DeviceError>

pub fn cublas(&self) -> &CublasContext

Trait Implementations

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for Identity<U, DeviceGpu<U>>where U: UnitValue<U>, DeviceGpu<U>: Device<U>,

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

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

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

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for ReLu<U, DeviceGpu<U>>where U: UnitValue<U> + DataTypeInfo, DeviceGpu<U>: Device<U>, ReLuForward<U>: Kernel<Args = ActivationForwardArgs<U>>, ReLuBackward<U>: Kernel<Args = ActivationBackwardArgs<U>>,

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

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

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

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for Sigmoid<U, DeviceGpu<U>>where U: UnitValue<U> + DataTypeInfo, DeviceGpu<U>: Device<U>, SigmoidForward<U>: Kernel<Args = ActivationForwardArgs<U>>, SigmoidBackward<U>: Kernel<Args = ActivationBackwardArgs<U>>,

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

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

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

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

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

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

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for Swish<U, DeviceGpu<U>>where U: UnitValue<U> + DataTypeInfo, DeviceGpu<U>: Device<U>, SwishForward<U>: Kernel<Args = ActivationForwardArgs<U>>, SwishBackward<U>: Kernel<Args = ActivationBackwardArgs<U>>,

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

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

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

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for Tanh<U, DeviceGpu<U>>where U: UnitValue<U> + DataTypeInfo, DeviceGpu<U>: Device<U>, TanhForward<U>: Kernel<Args = ActivationForwardArgs<U>>, TanhBackward<U>: Kernel<Args = ActivationBackwardArgs<U>>,

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

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

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

impl<U, const N: usize> BatchActivation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for Identity<U, DeviceGpu<U>>where U: UnitValue<U>, DeviceGpu<U>: Device<U>,

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

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

impl<U, const N: usize> BatchActivation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for ReLu<U, DeviceGpu<U>>where U: UnitValue<U> + DataTypeInfo, DeviceGpu<U>: Device<U>, ReLuForward<U>: Kernel<Args = ActivationForwardArgs<U>>, ReLuBackward<U>: Kernel<Args = ActivationBackwardArgs<U>>,

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

fn batch_derive( &self, _: &DeviceGpu<U>, _: &VecArr<U, Arr<U, N>>, loss: &VecArr<U, Arr<U, N>>, u: &VecArr<U, Arr<U, N>>) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

impl<U, const N: usize> BatchActivation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for Sigmoid<U, DeviceGpu<U>>where U: UnitValue<U> + DataTypeInfo, DeviceGpu<U>: Device<U>, SigmoidForward<U>: Kernel<Args = ActivationForwardArgs<U>>, SigmoidBackward<U>: Kernel<Args = ActivationBackwardArgs<U>>,

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

fn batch_derive( &self, _: &DeviceGpu<U>, _: &VecArr<U, Arr<U, N>>, loss: &VecArr<U, Arr<U, N>>, u: &VecArr<U, Arr<U, N>>) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

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

fn batch_derive( &self, _: &DeviceGpu<U>, _: &VecArr<U, Arr<U, N>>, loss: &VecArr<U, Arr<U, N>>, u: &VecArr<U, Arr<U, N>>) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

impl<U, const N: usize> BatchActivation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for Swish<U, DeviceGpu<U>>where U: UnitValue<U> + DataTypeInfo, DeviceGpu<U>: Device<U>, SwishForward<U>: Kernel<Args = ActivationForwardArgs<U>>, SwishBackward<U>: Kernel<Args = ActivationBackwardArgs<U>>,

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

fn batch_derive( &self, _: &DeviceGpu<U>, _: &VecArr<U, Arr<U, N>>, loss: &VecArr<U, Arr<U, N>>, u: &VecArr<U, Arr<U, N>>) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

impl<U, const N: usize> BatchActivation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for Tanh<U, DeviceGpu<U>>where U: UnitValue<U> + DataTypeInfo, DeviceGpu<U>: Device<U>, TanhForward<U>: Kernel<Args = ActivationForwardArgs<U>>, TanhBackward<U>: Kernel<Args = ActivationBackwardArgs<U>>,

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

fn batch_derive( &self, _: &DeviceGpu<U>, _: &VecArr<U, Arr<U, N>>, loss: &VecArr<U, Arr<U, N>>, u: &VecArr<U, Arr<U, N>>) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

impl<U> BatchLossFunction<U, DeviceGpu<U>> for CrossEntropy<U>where U: Clone + Copy + UnitValue<U> + DataTypeInfo, DeviceGpu<U>: Device<U>, CudaPtr<U>: TryFrom<U, Error = CudaError>, LinearBatchCrossEntropy<U>: Kernel<Args = LinearBatchCrossEntropyArgs<U>>,

fn batch_linear_derive<const N: usize>( &self, _: &DeviceGpu<U>, expected: &VecArr<U, Arr<U, N>>, actual: &VecArr<U, Arr<U, N>>) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

impl<U> BatchLossFunction<U, DeviceGpu<U>> for CrossEntropyMulticlass<U>where U: Clone + Copy + UnitValue<U> + DataTypeInfo, DeviceGpu<U>: Device<U>, CudaPtr<U>: TryFrom<U, Error = CudaError>, LinearBatchCrossEntropyMulticlass<U>: Kernel<Args = LinearBatchCrossEntropyMulticlassArgs<U>>,

fn batch_linear_derive<const N: usize>( &self, _: &DeviceGpu<U>, expected: &VecArr<U, Arr<U, N>>, actual: &VecArr<U, Arr<U, N>>) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

impl<U> BatchLossFunction<U, DeviceGpu<U>> for Mse<U>where U: Clone + Copy + UnitValue<U> + DataTypeInfo, DeviceGpu<U>: Device<U>, CudaPtr<U>: TryFrom<U, Error = CudaError>, LinearBatchMse<U>: Kernel<Args = LinearBatchMseArgs<U>>,

fn batch_linear_derive<const N: usize>( &self, _: &DeviceGpu<U>, expected: &VecArr<U, Arr<U, N>>, actual: &VecArr<U, Arr<U, N>>) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

impl<U> Clone for DeviceGpu<U>where U: UnitValue<U>,

fn clone(&self) -> Self

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

impl Device<f32> for DeviceGpu<f32>

fn loss_linear<L, const N: usize>( &self, expected: &Arr<f32, N>, actual: &Arr<f32, N>, lossf: &L) -> Arr<f32, N>where L: LossFunction<f32>,

fn loss_linear_by_canonical_link<const N: usize>( &self, expected: &Arr<f32, N>, actual: &Arr<f32, N>) -> Arr<f32, N>

fn loss_linear_total<L: LossFunction<f32>, const N: usize>( &self, exptected: &Arr<f32, N>, actual: &Arr<f32, N>, lossf: &L) -> f32

fn loss_linear_batch_by_canonical_link<const N: usize>( &self, expected: &VecArr<f32, Arr<f32, N>>, actual: &VecArr<f32, Arr<f32, N>>) -> Result<VecArr<f32, Arr<f32, N>>, TrainingError>

fn batch_linear_reduce<const N: usize>( &self, loss: &VecArr<f32, Arr<f32, N>>) -> Result<Arr<f32, N>, TrainingError>

fn batch_loss_linear_total<L: LossFunction<U>, const N: usize>( &self, exptected: &VecArr<U, Arr<U, N>>, actual: &VecArr<U, Arr<U, N>>, lossf: &L) -> U

impl Device<f64> for DeviceGpu<f64>

fn loss_linear<L, const N: usize>( &self, expected: &Arr<f64, N>, actual: &Arr<f64, N>, lossf: &L) -> Arr<f64, N>where L: LossFunction<f64>,

fn loss_linear_by_canonical_link<const N: usize>( &self, expected: &Arr<f64, N>, actual: &Arr<f64, N>) -> Arr<f64, N>

fn loss_linear_total<L: LossFunction<f64>, const N: usize>( &self, exptected: &Arr<f64, N>, actual: &Arr<f64, N>, lossf: &L) -> f64

fn loss_linear_batch_by_canonical_link<const N: usize>( &self, expected: &VecArr<f64, Arr<f64, N>>, actual: &VecArr<f64, Arr<f64, N>>) -> Result<VecArr<f64, Arr<f64, N>>, TrainingError>

fn batch_linear_reduce<const N: usize>( &self, loss: &VecArr<f64, Arr<f64, N>>) -> Result<Arr<f64, N>, TrainingError>

fn batch_loss_linear_total<L: LossFunction<U>, const N: usize>( &self, exptected: &VecArr<U, Arr<U, N>>, actual: &VecArr<U, Arr<U, N>>, lossf: &L) -> U

impl<const NI: usize, const NO: usize> DeviceLinear<f32, CachedTensor<f32, Arr2<f32, NI, NO>>, NI, NO> for DeviceGpu<f32>

fn forward_linear( &self, bias: &Arr<f32, NO>, units: &CachedTensor<f32, Arr2<f32, NI, NO>>, input: &Arr<f32, NI>) -> Result<Arr<f32, NO>, EvaluateError>

fn backward_linear( &self, units: &CachedTensor<f32, Arr2<f32, NI, NO>>, input: &Arr<f32, NO>) -> Result<Arr<f32, NI>, TrainingError>

fn backward_weight_gradient( &self, o: &Arr<f32, NI>, loss: &Arr<f32, NO>) -> Result<Arr2<f32, NI, NO>, TrainingError>

fn batch_forward_linear( &self, bias: &Arr<f32, NO>, units: &CachedTensor<f32, Arr2<f32, NI, NO>>, input: &VecArr<f32, Arr<f32, NI>>) -> Result<VecArr<f32, Arr<f32, NO>>, TrainingError>

fn batch_backward_linear( &self, units: &CachedTensor<f32, Arr2<f32, NI, NO>>, input: &VecArr<f32, Arr<f32, NO>>) -> Result<VecArr<f32, Arr<f32, NI>>, TrainingError>

fn batch_backward_weight_gradient( &self, o: &VecArr<f32, Arr<f32, NI>>, loss: &VecArr<f32, Arr<f32, NO>>) -> Result<Arr2<f32, NI, NO>, TrainingError>

impl<const NI: usize, const NO: usize> DeviceLinear<f64, CachedTensor<f64, Arr2<f64, NI, NO>>, NI, NO> for DeviceGpu<f64>

fn forward_linear( &self, bias: &Arr<f64, NO>, units: &CachedTensor<f64, Arr2<f64, NI, NO>>, input: &Arr<f64, NI>) -> Result<Arr<f64, NO>, EvaluateError>

fn backward_linear( &self, units: &CachedTensor<f64, Arr2<f64, NI, NO>>, input: &Arr<f64, NO>) -> Result<Arr<f64, NI>, TrainingError>

impl<U> DeviceGpu<U>where
U: UnitValue<U>,

pub fn new(
memory_pool: &Arc<Mutex<MemoryPool>>
) -> Result<DeviceGpu<U>, DeviceError>

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for Identity<U, DeviceGpu<U>>where
U: UnitValue<U>,
DeviceGpu<U>: Device<U>,

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

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

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for ReLu<U, DeviceGpu<U>>where
U: UnitValue<U> + DataTypeInfo,
DeviceGpu<U>: Device<U>,
ReLuForward<U>: Kernel<Args = ActivationForwardArgs<U>>,
ReLuBackward<U>: Kernel<Args = ActivationBackwardArgs<U>>,

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

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

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for Sigmoid<U, DeviceGpu<U>>where
U: UnitValue<U> + DataTypeInfo,
DeviceGpu<U>: Device<U>,
SigmoidForward<U>: Kernel<Args = ActivationForwardArgs<U>>,
SigmoidBackward<U>: Kernel<Args = ActivationBackwardArgs<U>>,

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

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

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

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

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for Swish<U, DeviceGpu<U>>where
U: UnitValue<U> + DataTypeInfo,
DeviceGpu<U>: Device<U>,
SwishForward<U>: Kernel<Args = ActivationForwardArgs<U>>,
SwishBackward<U>: Kernel<Args = ActivationBackwardArgs<U>>,

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

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

impl<U, const N: usize> Activation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for Tanh<U, DeviceGpu<U>>where
U: UnitValue<U> + DataTypeInfo,
DeviceGpu<U>: Device<U>,
TanhForward<U>: Kernel<Args = ActivationForwardArgs<U>>,
TanhBackward<U>: Kernel<Args = ActivationBackwardArgs<U>>,

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

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

impl<U, const N: usize> BatchActivation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for Identity<U, DeviceGpu<U>>where
U: UnitValue<U>,
DeviceGpu<U>: Device<U>,

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

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

impl<U, const N: usize> BatchActivation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for ReLu<U, DeviceGpu<U>>where
U: UnitValue<U> + DataTypeInfo,
DeviceGpu<U>: Device<U>,
ReLuForward<U>: Kernel<Args = ActivationForwardArgs<U>>,
ReLuBackward<U>: Kernel<Args = ActivationBackwardArgs<U>>,

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

fn batch_derive(
&self,
_: &DeviceGpu<U>,
_: &VecArr<U, Arr<U, N>>,
loss: &VecArr<U, Arr<U, N>>,
u: &VecArr<U, Arr<U, N>>
) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

impl<U, const N: usize> BatchActivation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for Sigmoid<U, DeviceGpu<U>>where
U: UnitValue<U> + DataTypeInfo,
DeviceGpu<U>: Device<U>,
SigmoidForward<U>: Kernel<Args = ActivationForwardArgs<U>>,
SigmoidBackward<U>: Kernel<Args = ActivationBackwardArgs<U>>,

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

fn batch_derive(
&self,
_: &DeviceGpu<U>,
_: &VecArr<U, Arr<U, N>>,
loss: &VecArr<U, Arr<U, N>>,
u: &VecArr<U, Arr<U, N>>
) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

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

fn batch_derive(
&self,
_: &DeviceGpu<U>,
_: &VecArr<U, Arr<U, N>>,
loss: &VecArr<U, Arr<U, N>>,
u: &VecArr<U, Arr<U, N>>
) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

impl<U, const N: usize> BatchActivation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for Swish<U, DeviceGpu<U>>where
U: UnitValue<U> + DataTypeInfo,
DeviceGpu<U>: Device<U>,
SwishForward<U>: Kernel<Args = ActivationForwardArgs<U>>,
SwishBackward<U>: Kernel<Args = ActivationBackwardArgs<U>>,

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

fn batch_derive(
&self,
_: &DeviceGpu<U>,
_: &VecArr<U, Arr<U, N>>,
loss: &VecArr<U, Arr<U, N>>,
u: &VecArr<U, Arr<U, N>>
) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

impl<U, const N: usize> BatchActivation<U, Arr<U, N>, Arr<U, N>, DeviceGpu<U>> for Tanh<U, DeviceGpu<U>>where
U: UnitValue<U> + DataTypeInfo,
DeviceGpu<U>: Device<U>,
TanhForward<U>: Kernel<Args = ActivationForwardArgs<U>>,
TanhBackward<U>: Kernel<Args = ActivationBackwardArgs<U>>,

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

fn batch_derive(
&self,
_: &DeviceGpu<U>,
_: &VecArr<U, Arr<U, N>>,
loss: &VecArr<U, Arr<U, N>>,
u: &VecArr<U, Arr<U, N>>
) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

impl<U> BatchLossFunction<U, DeviceGpu<U>> for CrossEntropy<U>where
U: Clone + Copy + UnitValue<U> + DataTypeInfo,
DeviceGpu<U>: Device<U>,
CudaPtr<U>: TryFrom<U, Error = CudaError>,
LinearBatchCrossEntropy<U>: Kernel<Args = LinearBatchCrossEntropyArgs<U>>,

fn batch_linear_derive<const N: usize>(
&self,
_: &DeviceGpu<U>,
expected: &VecArr<U, Arr<U, N>>,
actual: &VecArr<U, Arr<U, N>>
) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

impl<U> BatchLossFunction<U, DeviceGpu<U>> for CrossEntropyMulticlass<U>where
U: Clone + Copy + UnitValue<U> + DataTypeInfo,
DeviceGpu<U>: Device<U>,
CudaPtr<U>: TryFrom<U, Error = CudaError>,
LinearBatchCrossEntropyMulticlass<U>: Kernel<Args = LinearBatchCrossEntropyMulticlassArgs<U>>,

fn batch_linear_derive<const N: usize>(
&self,
_: &DeviceGpu<U>,
expected: &VecArr<U, Arr<U, N>>,
actual: &VecArr<U, Arr<U, N>>
) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

impl<U> BatchLossFunction<U, DeviceGpu<U>> for Mse<U>where
U: Clone + Copy + UnitValue<U> + DataTypeInfo,
DeviceGpu<U>: Device<U>,
CudaPtr<U>: TryFrom<U, Error = CudaError>,
LinearBatchMse<U>: Kernel<Args = LinearBatchMseArgs<U>>,

fn batch_linear_derive<const N: usize>(
&self,
_: &DeviceGpu<U>,
expected: &VecArr<U, Arr<U, N>>,
actual: &VecArr<U, Arr<U, N>>
) -> Result<VecArr<U, Arr<U, N>>, TrainingError>

impl<U> Clone for DeviceGpu<U>where
U: UnitValue<U>,

fn loss_linear<L, const N: usize>(
&self,
expected: &Arr<f32, N>,
actual: &Arr<f32, N>,
lossf: &L
) -> Arr<f32, N>where
L: LossFunction<f32>,

fn loss_linear_by_canonical_link<const N: usize>(
&self,
expected: &Arr<f32, N>,
actual: &Arr<f32, N>
) -> Arr<f32, N>

fn loss_linear_total<L: LossFunction<f32>, const N: usize>(
&self,
exptected: &Arr<f32, N>,
actual: &Arr<f32, N>,
lossf: &L
) -> f32

fn loss_linear_batch_by_canonical_link<const N: usize>(
&self,
expected: &VecArr<f32, Arr<f32, N>>,
actual: &VecArr<f32, Arr<f32, N>>
) -> Result<VecArr<f32, Arr<f32, N>>, TrainingError>

fn batch_linear_reduce<const N: usize>(
&self,
loss: &VecArr<f32, Arr<f32, N>>
) -> Result<Arr<f32, N>, TrainingError>

fn batch_loss_linear_total<L: LossFunction<U>, const N: usize>(
&self,
exptected: &VecArr<U, Arr<U, N>>,
actual: &VecArr<U, Arr<U, N>>,
lossf: &L
) -> U

fn loss_linear<L, const N: usize>(
&self,
expected: &Arr<f64, N>,
actual: &Arr<f64, N>,
lossf: &L
) -> Arr<f64, N>where
L: LossFunction<f64>,

fn loss_linear_by_canonical_link<const N: usize>(
&self,
expected: &Arr<f64, N>,
actual: &Arr<f64, N>
) -> Arr<f64, N>

fn loss_linear_total<L: LossFunction<f64>, const N: usize>(
&self,
exptected: &Arr<f64, N>,
actual: &Arr<f64, N>,
lossf: &L
) -> f64

fn loss_linear_batch_by_canonical_link<const N: usize>(
&self,
expected: &VecArr<f64, Arr<f64, N>>,
actual: &VecArr<f64, Arr<f64, N>>
) -> Result<VecArr<f64, Arr<f64, N>>, TrainingError>

fn batch_linear_reduce<const N: usize>(
&self,
loss: &VecArr<f64, Arr<f64, N>>
) -> Result<Arr<f64, N>, TrainingError>

fn batch_loss_linear_total<L: LossFunction<U>, const N: usize>(
&self,
exptected: &VecArr<U, Arr<U, N>>,
actual: &VecArr<U, Arr<U, N>>,
lossf: &L
) -> U

fn forward_linear(
&self,
bias: &Arr<f32, NO>,
units: &CachedTensor<f32, Arr2<f32, NI, NO>>,
input: &Arr<f32, NI>
) -> Result<Arr<f32, NO>, EvaluateError>

fn backward_linear(
&self,
units: &CachedTensor<f32, Arr2<f32, NI, NO>>,
input: &Arr<f32, NO>
) -> Result<Arr<f32, NI>, TrainingError>

fn backward_weight_gradient(
&self,
o: &Arr<f32, NI>,
loss: &Arr<f32, NO>
) -> Result<Arr2<f32, NI, NO>, TrainingError>

fn batch_forward_linear(
&self,
bias: &Arr<f32, NO>,
units: &CachedTensor<f32, Arr2<f32, NI, NO>>,
input: &VecArr<f32, Arr<f32, NI>>
) -> Result<VecArr<f32, Arr<f32, NO>>, TrainingError>

fn batch_backward_linear(
&self,
units: &CachedTensor<f32, Arr2<f32, NI, NO>>,
input: &VecArr<f32, Arr<f32, NO>>
) -> Result<VecArr<f32, Arr<f32, NI>>, TrainingError>

fn batch_backward_weight_gradient(
&self,
o: &VecArr<f32, Arr<f32, NI>>,
loss: &VecArr<f32, Arr<f32, NO>>
) -> Result<Arr2<f32, NI, NO>, TrainingError>

fn forward_linear(
&self,
bias: &Arr<f64, NO>,
units: &CachedTensor<f64, Arr2<f64, NI, NO>>,
input: &Arr<f64, NI>
) -> Result<Arr<f64, NO>, EvaluateError>

fn backward_linear(
&self,
units: &CachedTensor<f64, Arr2<f64, NI, NO>>,
input: &Arr<f64, NO>
) -> Result<Arr<f64, NI>, TrainingError>

fn backward_weight_gradient(
&self,
o: &Arr<f64, NI>,
loss: &Arr<f64, NO>
) -> Result<Arr2<f64, NI, NO>, TrainingError>

fn batch_forward_linear(
&self,
bias: &Arr<f64, NO>,
units: &CachedTensor<f64, Arr2<f64, NI, NO>>,
input: &VecArr<f64, Arr<f64, NI>>
) -> Result<VecArr<f64, Arr<f64, NO>>, TrainingError>

fn batch_backward_linear(
&self,
units: &CachedTensor<f64, Arr2<f64, NI, NO>>,
input: &VecArr<f64, Arr<f64, NO>>
) -> Result<VecArr<f64, Arr<f64, NI>>, TrainingError>

fn batch_backward_weight_gradient(
&self,
o: &VecArr<f64, Arr<f64, NI>>,
loss: &VecArr<f64, Arr<f64, NO>>
) -> Result<Arr2<f64, NI, NO>, TrainingError>

impl<U> RefUnwindSafe for DeviceGpu<U>where
U: RefUnwindSafe,

impl<U> Unpin for DeviceGpu<U>where
U: Unpin,

impl<U> UnwindSafe for DeviceGpu<U>where
U: UnwindSafe,

impl<T> Any for Twhere
T: 'static + ?Sized,

impl<T> Borrow<T> for Twhere
T: ?Sized,

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

impl<T, U> Into<U> for Twhere
U: From<T>,

impl<T> ToOwned for Twhere
T: Clone,

impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,