Trait ConvolutionOps 

pub trait ConvolutionOps: Send + Sync {
    // Required methods
    fn convolution<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'life6, 'async_trait>(
        &'life0 self,
        device: &'life1 Device,
        input: &'life2 Buffer,
        kernel: &'life3 Buffer,
        bias: Option<&'life4 Buffer>,
        output: &'life5 Buffer,
        config: &'life6 ConvolutionConfig,
    ) -> Pin<Box<dyn Future<Output = BackendResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait,
             'life6: 'async_trait;
    fn conv2d<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>(
        &'life0 self,
        device: &'life1 Device,
        input: &'life2 Buffer,
        kernel: &'life3 Buffer,
        bias: Option<&'life4 Buffer>,
        output: &'life5 Buffer,
        stride: (usize, usize),
        padding: (usize, usize),
        dilation: (usize, usize),
    ) -> Pin<Box<dyn Future<Output = BackendResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait;
    fn depthwise_conv2d<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>(
        &'life0 self,
        device: &'life1 Device,
        input: &'life2 Buffer,
        kernel: &'life3 Buffer,
        bias: Option<&'life4 Buffer>,
        output: &'life5 Buffer,
        stride: (usize, usize),
        padding: (usize, usize),
    ) -> Pin<Box<dyn Future<Output = BackendResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait;
    fn conv_transpose2d<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>(
        &'life0 self,
        device: &'life1 Device,
        input: &'life2 Buffer,
        kernel: &'life3 Buffer,
        bias: Option<&'life4 Buffer>,
        output: &'life5 Buffer,
        stride: (usize, usize),
        padding: (usize, usize),
        output_padding: (usize, usize),
    ) -> Pin<Box<dyn Future<Output = BackendResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait;
    fn grouped_conv2d<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>(
        &'life0 self,
        device: &'life1 Device,
        input: &'life2 Buffer,
        kernel: &'life3 Buffer,
        bias: Option<&'life4 Buffer>,
        output: &'life5 Buffer,
        groups: usize,
        stride: (usize, usize),
        padding: (usize, usize),
    ) -> Pin<Box<dyn Future<Output = BackendResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             'life5: 'async_trait;
    fn select_algorithm(
        &self,
        config: &ConvolutionConfig,
    ) -> ConvolutionAlgorithm;
    fn supports_convolution(&self) -> bool;
    fn supported_conv_types(&self) -> Vec<ConvolutionType>;
    fn supported_algorithms(&self) -> Vec<ConvolutionAlgorithm>;
}

Convolution operations trait

Required Methods

fn convolution<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'life6, 'async_trait>( &'life0 self, device: &'life1 Device, input: &'life2 Buffer, kernel: &'life3 Buffer, bias: Option<&'life4 Buffer>, output: &'life5 Buffer, config: &'life6 ConvolutionConfig, ) -> Pin<Box<dyn Future<Output = BackendResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait, 'life6: 'async_trait,

Execute a convolution operation

fn conv2d<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, device: &'life1 Device, input: &'life2 Buffer, kernel: &'life3 Buffer, bias: Option<&'life4 Buffer>, output: &'life5 Buffer, stride: (usize, usize), padding: (usize, usize), dilation: (usize, usize), ) -> Pin<Box<dyn Future<Output = BackendResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

Execute a 2D convolution

fn depthwise_conv2d<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, device: &'life1 Device, input: &'life2 Buffer, kernel: &'life3 Buffer, bias: Option<&'life4 Buffer>, output: &'life5 Buffer, stride: (usize, usize), padding: (usize, usize), ) -> Pin<Box<dyn Future<Output = BackendResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

Execute a depthwise convolution

fn conv_transpose2d<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, device: &'life1 Device, input: &'life2 Buffer, kernel: &'life3 Buffer, bias: Option<&'life4 Buffer>, output: &'life5 Buffer, stride: (usize, usize), padding: (usize, usize), output_padding: (usize, usize), ) -> Pin<Box<dyn Future<Output = BackendResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

Execute a transposed convolution

fn grouped_conv2d<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, device: &'life1 Device, input: &'life2 Buffer, kernel: &'life3 Buffer, bias: Option<&'life4 Buffer>, output: &'life5 Buffer, groups: usize, stride: (usize, usize), padding: (usize, usize), ) -> Pin<Box<dyn Future<Output = BackendResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

Execute a grouped convolution

fn select_algorithm(&self, config: &ConvolutionConfig) -> ConvolutionAlgorithm

Get the best algorithm for given configuration

fn supports_convolution(&self) -> bool

Check if convolution operations are supported

fn supported_conv_types(&self) -> Vec<ConvolutionType>

Get supported convolution types

fn supported_algorithms(&self) -> Vec<ConvolutionAlgorithm>

Get supported algorithms

Implementors

impl ConvolutionOps for CpuConvolutionOps

impl ConvolutionOps for DefaultConvolutionOps