Struct Conv 

pub struct Conv<const IW: usize, const IH: usize, const IC: usize, const FH: usize, const FW: usize, const OC: usize, const S: usize, const P: usize> { /* private fields */ }

A convolutional layer

FH - filter/kernel height FW - filter/kernel width IC - number of input channels OC - number of output channels (equivalently, number of kernels/filters) S - stride P - padding

Implementations

impl<const IW: usize, const IH: usize, const IC: usize, const FH: usize, const FW: usize, const OC: usize, const S: usize, const P: usize> Conv<IW, IH, IC, FH, FW, OC, S, P>

where [(); { _ }]:, (): ConvGeometryIsValid<IH, IW, FH, FW, S, P>,

pub fn init() -> Self

pub fn seeded(seed: u64) -> Self

pub fn with_initializer<I: Initializer>(initializer: I) -> Self

pub fn with_initializer_and_seed<I: Initializer>( initializer: I, seed: u64, ) -> Self

pub fn with_initializer_and_rng<I: Initializer, R: Rng + ?Sized>( initializer: I, rng: &mut R, ) -> Self

pub fn create_output_space(&self) -> <Self as ConvIO>::Output

pub fn input_from_data(&self, data: [Float; { _ }]) -> <Self as ConvIO>::Input

pub fn forward( &self, input: &Tensor<Dim<IC, Dim<IH, Dim<IW, Nil>>>>, output: &mut Tensor<Dim<OC, Dim<{ _ }, Dim<{ _ }, Nil>>>>, )

pub fn forward_flat(&self, input: &[Float; { _ }], output: &mut [Float; { _ }])

pub fn backward_flat( &mut self, input: &[Float; { _ }], output_grad: &[Float; { _ }], input_grad: &mut [Float; { _ }], )

Trait Implementations

impl<const IW: usize, const IH: usize, const IC: usize, const FH: usize, const FW: usize, const OC: usize, const S: usize, const P: usize> ConvIO for Conv<IW, IH, IC, FH, FW, OC, S, P>

where [(); { _ }]:,

const N: usize

type Input = Tensor<Dim<IC, Dim<IH, Dim<IW, Nil>>>>

type Output = Tensor<<Conv<IW, IH, IC, FH, FW, OC, S, P> as ConvIO>::OutputShape>

type InputShape = Dim<IC, Dim<IH, Dim<IW, Nil>>>

type OutputShape = Dim<OC, Dim<{ $first }, Dim<{ $dim }, Nil>>>

type FilterShape = Dim<FH, Dim<FW, Dim<IC, Nil>>>

impl<const IW: usize, const IH: usize, const IC: usize, const FH: usize, const FW: usize, const OC: usize, const S: usize, const P: usize> ConvOps for Conv<IW, IH, IC, FH, FW, OC, S, P>

where [(); { _ }]:, (): ConvGeometryIsValid<IH, IW, FH, FW, S, P>,

const INPUT_SIZE: usize

const OUTPUT_SIZE: usize

const FILTER_SIZE: usize

type InputArray = [f64; { _ }]

type OutputArray = [f64; { _ }]

type FilterArray = [f64; { _ }]

fn init() -> Self

fn forward_flat(&self, input: &Self::InputArray, output: &mut Self::OutputArray)

fn input_from_fn<F: FnMut(usize) -> Float>(f: F) -> Self::InputArray

fn output_zeroed() -> Self::OutputArray

impl<const IW: usize, const IH: usize, const IC: usize, const FH: usize, const FW: usize, const OC: usize, const S: usize, const P: usize> Debug for Conv<IW, IH, IC, FH, FW, OC, S, P>

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

Formats the value using the given formatter.

impl<const IW: usize, const IH: usize, const IC: usize, const FH: usize, const FW: usize, const OC: usize, const S: usize, const P: usize> Layer<{ IC * IH * IW }, { OC * conv_out_dim(IH, P, FH, S) * conv_out_dim(IW, P, FW, S) }> for Conv<IW, IH, IC, FH, FW, OC, S, P>

where [(); { _ }]:, (): ConvGeometryIsValid<IH, IW, FH, FW, S, P>,

fn forward(&self, input: &[Float; { _ }], output: &mut [Float; { _ }])

fn backward( &mut self, input: &[Float; { _ }], _output: &[Float; { _ }], output_grad: &[Float; { _ }], input_grad: &mut [Float; { _ }], )

fn zero_grad(&mut self)

fn apply_gradients( &mut self, optimizer: &mut dyn Optimizer, slot: &mut usize, scale: Float, )

impl<const IW: usize, const IH: usize, const IC: usize, const FH: usize, const FW: usize, const OC: usize, const S: usize, const P: usize> LayerDims for Conv<IW, IH, IC, FH, FW, OC, S, P>

where [(); { _ }]:, (): ConvGeometryIsValid<IH, IW, FH, FW, S, P>,

const INPUT: usize

const OUTPUT: usize