Struct juice::layers::common::convolution::Convolution

pub struct Convolution<B: Convolution<f32>> { /* private fields */ }

Convolution Layer

Implementations

impl<B: Convolution<f32>> Convolution<B>

pub fn from_config(config: &ConvolutionConfig) -> Convolution<B>

Create a Convolution layer from a ConvolutionConfig.

Trait Implementations

impl<B: Clone + Convolution<f32>> Clone for Convolution<B>

where B::CC: Clone,

fn clone(&self) -> Convolution<B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B: IBackend + Convolution<f32>> ComputeInputGradient<f32, B> for Convolution<B>

fn compute_input_gradient( &self, backend: &B, weights_data: &[&SharedTensor<f32>], _output_data: &[&SharedTensor<f32>], output_gradients: &[&SharedTensor<f32>], input_data: &[&SharedTensor<f32>], input_gradients: &mut [&mut SharedTensor<f32>] )

Compute gradients with respect to the inputs and write them into input_gradients.

impl<B: IBackend + Convolution<f32>> ComputeOutput<f32, B> for Convolution<B>

fn compute_output( &self, backend: &B, weights: &[&SharedTensor<f32>], input_data: &[&SharedTensor<f32>], output_data: &mut [&mut SharedTensor<f32>] )

Compute output for given input and write them into output_data.

impl<B: IBackend + Convolution<f32>> ComputeParametersGradient<f32, B> for Convolution<B>

fn compute_parameters_gradient( &self, backend: &B, _output_data: &[&SharedTensor<f32>], output_gradients: &[&SharedTensor<f32>], input_data: &[&SharedTensor<f32>], parameters_gradients: &mut [&mut SharedTensor<f32>] )

Compute gradients with respect to the parameters and write them into parameters_gradients.

impl<B: Debug + Convolution<f32>> Debug for Convolution<B>

where B::CC: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B: Convolution<f32>> FilterLayer for Convolution<B>

fn num_spatial_dims(&self, input_shape: &[usize]) -> usize

Calculates the number of spatial dimensions for the convolution operation.

fn calculate_output_shape(&self, input_shape: &[usize]) -> Vec<usize>

Calculate output shape based on the shape of filter, padding, stride and input.

fn filter_shape(&self) -> &[usize]

The filter_shape that will be used by spatial_filter_dims.

fn stride(&self) -> &[usize]

The stride that will be used by stride_dims.

fn padding(&self) -> &[usize]

The padding that will be used by padding_dims.

fn calculate_spatial_output_dims( input_dims: &[usize], filter_dims: &[usize], padding: &[usize], stride: &[usize] ) -> Vec<usize>

Computes the shape of the spatial dimensions.

fn spatial_filter_dims(&self, num_spatial_dims: usize) -> Vec<usize>

Retrievs the spatial dimensions for the filter based on self.filter_shape() and the number of spatial dimensions.

fn stride_dims(&self, num_spatial_dims: usize) -> Vec<usize>

Retrievs the stride for the convolution based on self.stride and the number of spatial dimensions.

fn padding_dims(&self, num_spatial_dims: usize) -> Vec<usize>

Retrievs the padding for the convolution based on self.padding and the number of spatial dimensions.

impl<B: IBackend + Convolution<f32>> ILayer<B> for Convolution<B>

fn exact_num_output_blobs(&self) -> Option<usize>

Returns the exact number of output blobs required by the layer, or None if no exact number is required.

fn exact_num_input_blobs(&self) -> Option<usize>

Returns the exact number of input blobs required by the layer, or None if no exact number is required.

fn auto_weight_blobs(&self) -> bool

Return whether weight blobs are created automatically for the layer.

fn reshape( &mut self, backend: Rc<B>, input_data: &mut Vec<ArcLock<SharedTensor<f32>>>, input_gradient: &mut Vec<ArcLock<SharedTensor<f32>>>, weights_data: &mut Vec<ArcLock<SharedTensor<f32>>>, weights_gradient: &mut Vec<ArcLock<SharedTensor<f32>>>, output_data: &mut Vec<ArcLock<SharedTensor<f32>>>, output_gradient: &mut Vec<ArcLock<SharedTensor<f32>>> )

Adjust to shapes of the output blobs to fit the shapes of the input blobs.

fn resize_shared_workspace( &mut self, backend: Rc<B>, workspace: Option<ArcLock<SharedTensor<u8>>> ) -> Option<ArcLock<SharedTensor<u8>>>

Adjust size of shared workspace.

fn init(&mut self, backend: Rc<B>)

Initialize the layer for computation.

fn forward( &self, backend: &B, input_data: &[ArcLock<SharedTensor<f32>>], weights_data: &[ArcLock<SharedTensor<f32>>], output_data: &mut [ArcLock<SharedTensor<f32>>] )

Compute the [feedforward][1] layer output using the provided Backend. [1]: https://en.wikipedia.org/wiki/Feedforward_neural_network

fn backward_input( &self, backend: &B, weights_data: &[ArcLock<SharedTensor<f32>>], output_data: &[ArcLock<SharedTensor<f32>>], output_gradients: &[ArcLock<SharedTensor<f32>>], input_data: &[ArcLock<SharedTensor<f32>>], input_gradients: &mut [ArcLock<SharedTensor<f32>>] )

Compute the [backpropagation][1] input gradient using the provided backend. [1]: https://en.wikipedia.org/wiki/Backpropagation

fn backward_parameters( &self, backend: &B, output_data: &[ArcLock<SharedTensor<f32>>], output_gradients: &[ArcLock<SharedTensor<f32>>], input_data: &[ArcLock<SharedTensor<f32>>], weights_gradients: &mut [ArcLock<SharedTensor<f32>>] )

Compute the [backpropagation][1] parameters gradient using the provided backend. [1]: https://en.wikipedia.org/wiki/Backpropagation

fn auto_output_blobs(&self) -> bool

Return whether “anonymous” output blobs are created automatically for the layer.

fn min_output_blobs(&self) -> usize

Returns the minimum number of output blobs required by the layer, or 0 if no minimum number is required.

fn allow_force_backward(&self, input_id: usize) -> bool

Return whether to allow force_backward for a given input blob index.

fn sync_native(&self) -> bool

Return wether a simple native backend should be used to [sync][1] instead of the default backend. [1]: #method.sync

fn compute_in_place(&self) -> bool

Return wether the computations of a layer should be done in-place (the output will be written where the input was read from).

fn is_container(&self) -> bool

Return wether the layer is a container.

fn loss_weight(&self, output_id: usize) -> Option<f32>

Return the associated loss weight for a given output blob index.

fn inputs_data(&self) -> Option<Vec<ArcLock<SharedTensor<f32>>>>

Return the input tensors of the layer.

fn inputs_gradients(&self) -> Option<Vec<ArcLock<SharedTensor<f32>>>>

Return the gradients of the input tensors of the layer.

fn outputs_data(&self) -> Option<Vec<ArcLock<SharedTensor<f32>>>>

Return the output tensors of the layer.

fn outputs_gradients(&self) -> Option<Vec<ArcLock<SharedTensor<f32>>>>

Return the gradients of the output tensors of the layer.

fn learnable_weights(&self) -> Option<Vec<ArcLock<SharedTensor<f32>>>>

Return the learnable weights inside the layer.

fn learnable_weights_gradients(&self) -> Option<Vec<ArcLock<SharedTensor<f32>>>>

Return the gradients for the learnable weights inside the layer.

fn learnable_weights_names(&self) -> Option<Vec<String>>

Return the names of the learnable weights inside the layer.

fn learnable_weights_lr(&self) -> Option<Vec<Option<f32>>>

Return the learning rates for the learnable weights inside the layer.