aimath_cnn_f32_default.h

Go to the documentation of this file.

 
#ifndef AIMATH_CNN_F32_DEFAULT_H
#define AIMATH_CNN_F32_DEFAULT_H
 
#include <stdint.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
 
#include "core/aifes_core.h"
#include "basic/base/aimath/aimath_f32.h"
#include "basic/default/aimath/aimath_f32_default.h"
 
 
#define AIFES_PADDING_SAME      0xFFFF  // Not fully implemented yet
#define AIFES_PADDING_VALID     0
 
 
 void aimath_f32_default_conv2d_add(const aitensor_t *input,
                   const uint16_t stride[2],    // [s_h, s_w]
                   const uint16_t dilation[2],  // [d_h, d_w]
                   const int16_t padding[2][2],
                   const aitensor_t *kernel,
                   const void *bias,
                   const uint8_t rotated_kernel, // wether or not the kernel is rotated by 180°; default is TRUE (1)
                   const int16_t *input_use_dims, // Indices of dimensions for h and w
                   const int16_t *output_use_dims, // Indices of dimensions for h and w
                   const int16_t *kernel_use_dims, // Indices of dimensions for h and w
                   aitensor_t *output);
 
void aimath_f32_default_conv_transpose2d_add(const aitensor_t *input,
                   const uint16_t stride[2],    // [s_h, s_w]; dilation of input
                   const uint16_t dilation[2],  // [d_h, d_w]; dilation of kernel
                   const int16_t padding[2][2],
                   const aitensor_t *kernel,
                   const void *bias,
                   const uint8_t rotated_kernel, // wether or not the kernel is rotated by 180°; default is TRUE (1)
                   const int16_t *input_use_dims, // Indices of dimensions for h and w
                   const int16_t *output_use_dims, // Indices of dimensions for h and w
                   const int16_t *kernel_use_dims, // Indices of dimensions for h and w
                   aitensor_t *output);
 
 
 
void aimath_f32_default_conv2d_fwd(
                    const aitensor_t *input,
                    const uint16_t stride[2],    // [s_h, s_w]
                    const uint16_t dilation[2],  // [d_h, d_w]
                    const uint16_t padding[2],
                    const aitensor_t *weights,
                    const aitensor_t *bias,
                    int8_t channel_axis,
                    void *work_space,
                    aitensor_t *output
                    );
 
void aimath_f32_default_conv2d_bwd(
                    const aitensor_t *x_in,
                    const uint16_t stride[2],    // [s_h, s_w]
                    const uint16_t dilation[2],  // [d_h, d_w]
                    const uint16_t padding[2],
                    const aitensor_t *delta_out,
                    int8_t channel_axis,
                    void *work_space,
                    aitensor_t *d_weights
);
 
void aimath_f32_default_conv2d_bwd_full(
                    const aitensor_t *delta_out,
                    const uint16_t stride[2],    // [s_h, s_w]
                    const uint16_t dilation[2],  // [d_h, d_w]
                    const uint16_t padding[2],
                    const aitensor_t *weights,
                    int8_t channel_axis,
                    void *work_space,
                    aitensor_t *delta_in
);
 
void aimath_f32_default_conv_transpose2d_fwd(
                    const aitensor_t *input,
                    const uint16_t stride[2],    // input dilation
                    const uint16_t dilation[2],  // kernel dilation
                    const uint16_t padding[2],
                    const uint16_t output_padding[2],
                    const aitensor_t *weights,
                    const aitensor_t *bias,
                    int8_t channel_axis,
                    void *work_space,
                    aitensor_t *output
                    );
 
void aimath_f32_default_maxpool2d_fwd(
                                      const aitensor_t *input,
                                      const uint16_t pool_size[2],
                                      const uint16_t stride[2],
                                      const uint16_t padding[2],
                                      int8_t channel_axis,
                                      void *work_space,
                                      uint32_t *max_locations,
                                      aitensor_t *output
                                      );
 
void aimath_f32_default_maxpool2d_bwd(
                                      const aitensor_t *delta_out,
                                      const uint16_t pool_size[2],
                                      const uint16_t stride[2],
                                      const uint16_t padding[2],
                                      int8_t channel_axis,
                                      void *work_space,
                                      const uint32_t *max_locations,
                                      aitensor_t *delta_in
                                      );
 
void aimath_f32_default_batch_norm(const aitensor_t *x,
                                            int8_t axis,
                                            const aitensor_t *means,
                                            const aitensor_t *variances,
                                            const aitensor_t *offsets,
                                            const aitensor_t *scales,
                                            const void *eps,
                                            aitensor_t *result);
 
void aimath_f32_default_d_batch_norm(const aitensor_t *x_in,
                                              int8_t axis,
                                              const aitensor_t *means,
                                              const aitensor_t *vars,
                                              const aitensor_t *betas,
                                              const aitensor_t *gammas,
                                              const aitensor_t *delta_out,
                                              const void *eps,
                                              aitensor_t *delta_in,
                                              aitensor_t *d_betas,
                                              aitensor_t *d_gammas);
 
void aimath_f32_default_pad_zeros(const aitensor_t *x, const uint16_t (*padding)[2], aitensor_t *result);
 
 #endif // AIMATH_CNN_F32_DEFAULT_H