Conv1d, AveragePool1d and Batchnorm1d Layers

Author: AnirudhBHarish

.gitattributes

@@ -63,13 +63,12 @@ c_reference/models/q_scut_head_b_face4_model/detection2.h filter=lfs diff=lfs me
 c_reference/tests/kws/keyword_spotting_io_1.h filter=lfs diff=lfs merge=lfs -text
 c_reference/tests/kws/keyword_spotting_io_2.h filter=lfs diff=lfs merge=lfs -text
 c_reference/tests/kws/keyword_spotting_io_3.h filter=lfs diff=lfs merge=lfs -text
-c_reference/tests/conv1d/avg_pool/avg_io.h filter=lfs diff=lfs merge=lfs -text
 c_reference/tests/conv1d/conv1d_regular/conv_param.h filter=lfs diff=lfs merge=lfs -text
 c_reference/tests/conv1d/conv1d_lr/conv_param_lr.h filter=lfs diff=lfs merge=lfs -text
 c_reference/tests/conv1d/conv1d_lr_depthwise/conv_param_lr_depth.h filter=lfs diff=lfs merge=lfs -text
 c_reference/tests/conv1d/conv1d_depthwise/conv_param_depth.h filter=lfs diff=lfs merge=lfs -text
 c_reference/tests/kws/precnn_params.h filter=lfs diff=lfs merge=lfs -text
 c_reference/tests/kws/postcnn_params.h filter=lfs diff=lfs merge=lfs -text
 c_reference/tests/kws/rnn_params.h filter=lfs diff=lfs merge=lfs -text
-c_reference/tests/dscnn/dscnn_param_lr.h filter=lfs diff=lfs merge=lfs -text
-c_reference/tests/dscnn/dscnn_param_lr_depth_point.h filter=lfs diff=lfs merge=lfs -text
+c_reference/tests/rnn_bricked/rnn_params.h filter=lfs diff=lfs merge=lfs -text
+c_reference/tests/rnn_bricked/rnn_bricked_io.h filter=lfs diff=lfs merge=lfs -text

README.md

@@ -17,7 +17,6 @@ Algorithms that shine in this setting in terms of both model size and compute, n
  - **EMI-RNN**: Training routine to recover the critical signature from time series data for faster and accurate RNN predictions.
  - **Shallow RNN**: A meta-architecture for training RNNs that can be applied to streaming data.
  - **FastRNN & FastGRNN - FastCells**: **F**ast, **A**ccurate, **S**table and **T**iny (**G**ated) RNN cells.
- - **Conv1D**: 1-D regular and low-rank convolution architectures for time-series data.
  - **DROCC**: **D**eep **R**obust **O**ne-**C**lass **C**lassfiication for training robust anomaly detectors.
  - **RNNPool**: An efficient non-linear pooling operator for RAM constrained inference.
 

c_reference/include/conv1d.h

@@ -1,92 +1,102 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
-#ifndef __DSCNN__
-#define __DSCNN__
+#ifndef __DSCNN_H__
+#define __DSCNN_H__
 
-#include"conv1d.h"
-#include"conv_utils.h"
-#include<stdlib.h>
-#include<math.h>
+// Function pointer for the Conv layer to be passed as a parameter. (conv1d or conv1d_lr only)
+typedef int (*conv_layer)(float*, unsigned, unsigned, const float*, 
+                          unsigned, unsigned, unsigned, unsigned, 
+                          const void*, unsigned, unsigned);
 
 /**
- * @brief Model definition for the 1D Convolution sub-block applied before the RNN
- * @brief sub-layers : BatchNorm1d -> Conv1D_LR
- * 
- * @param[out]   output_signal       pointer to the final output signal, minimum size = out_T * in_channels. out_T has to be calculated based on the reduction from all the conv and pool layers
- * @param[in]    input_signal        pointer to the input signal. size = in_T * in_channels
- * @param[in]    in_T                number of time steps in the input
- * @param[in]    in_channels         number of input channels. The output will have the same number of channels
- 
- * @param[in]    mean                pointer to the mean for the batch normalization, size = in_channels
- * @param[in]    var                 pointer to the variance for the batch normalization, size = in_channels
- * @param[in]    affine              whether the affine operations are applied
- * @param[in]    gamma               pointer to the scaling factors for the post-norm affine operation, size = in_channels
- * @param[in]    beta                pointer to the scalar offsets for the post-norm affine operation, size = in_channels
- * @param[in]    in_place            in place computation of the batchnorm. Storage efficient
- * 
- * @param[in]    cnn_hidden          hidden state/out_channels dimensions for the CNN
- * @param[in]    cnn_padding         padding for the CNN layer. Note: applied to both sides of the input 
- * @param[in]    cnn_kernel_size     kernel size of the CNN
- * @param[in]    cnn_params          weights, bias and other essential parameters used to describe the CNN
- * @param[in]    cnn_activations     an integer to choose the type of activation function.
+ * @brief Model definition for the 1D Convolution block applied before the RNN
+ * @brief sub-layers : batchnorm1d -> conv1d_lr
+ * @param[out]   output_signal       pointer to the final output signal, minimum size = out_time * in_channels. out_time has to be calculated based on the reduction from all the conv and pool layers
+ * @param[in]    input_signal        pointer to the input signal. size = in_time * in_channels
+ * @param[in]    in_time             number of time steps in the input_signal
+ * @param[in]    in_channels         number of input channels
+ * @param[in]    mean                pointer to the mean for the batch normalization, size = in_channels. Pass NULL/0 for affine_config = 2
+ * @param[in]    var                 pointer to the variance for the batch normalization, size = in_channels. Pass NULL/0 for affine_config = 2
+ * @param[in]    affine_config       whether the affine operations are applied
+ *                                   if affine_config = 0, then only mean and var are used
+ *                                   if affine_config = 1, then mean, var, gamma and beta are used for the final computation.
+ *                                   if affine_config = 2, then only the gamma and beta are used. gamma = original_gamma/sqrt(var), beta = original_beta - gamma * mean/sqrt(var)
+ *                                   Note: Use affine_config = 2 for faster calculations. The new gamma and beta would need to be pre-computed, stored and passed
+ * @param[in]    gamma               pointer to the scaling factors for the post-norm affine operation, size = in_channels. Pass NULL/0 for affine_config = 0
+ * @param[in]    beta                pointer to the offsets for the post-norm affine operation, size = in_channels. Pass NULL/0 for affine_config = 0
+ * @param[in]    in_place            in-place computation check for the batchnorm. Storage efficient
+ * @param[in]    cnn_hidden          hidden state/out_channels dimensions for the low-rank CNN. The final channel size of this block
+ * @param[in]    cnn_padding         padding for the low-rank CNN layer. Note: applied to both sides of the input 
+ * @param[in]    cnn_kernel_size     kernel size of the low-rank CNN
+ * @param[in]    cnn_params          weights, bias and other essential parameters for the low-rank CNN
+ * @param[in]    cnn_stride          stride factor for the low-rank CNN
+ * @param[in]    cnn_activation      an integer to choose the type of activation function.
  *                                   0: none
  *                                   1: sigmoid
  *                                   2: tanh
  *                                   3: relu
  */
-int DSCNN_LR(float* output_signal, float* input_signal, unsigned in_T, unsigned in_channels, float* mean, float* var,
-    unsigned affine, float* gamma, float* beta, unsigned in_place, unsigned cnn_hidden, int cnn_padding, unsigned cnn_kernel_size,
-    const void* cnn_params, int cnn_activations);
+int phon_pred_lr_cnn(float* output_signal, float* input_signal,
+  unsigned in_time, unsigned in_channels,
+  const float* const mean, const float* const var,
+  unsigned affine_config, const float* const gamma, const float* const beta, unsigned in_place,
+  unsigned cnn_hidden, unsigned cnn_padding, unsigned cnn_kernel_size,
+  const void* cnn_params, unsigned cnn_stride, unsigned cnn_activation);
 
 /**
- * @brief Model definition for the 1D Convolution sub-block applied after the RNN
- * @brief sub-layers : TanhGate(custom) nonlinearity -> BatchNorm1d -> Conv1D_Depth -> Conv1d_LR -> AvgPool
- * 
- * @param[out]   output_signal          pointer to the final output signal, minimum size = out_T * in_channels. out_T has to be calculated based on the reduction from all the conv and pool layers
- * @param[in]    input_signal           pointer to the input signal. size = in_T * in_channels
- * @param[in]    in_T                   number of time steps in the input
- * @param[in]    in_channels            number of input channels. The output will have the same number of channels
- 
- * @param[in]    mean                   pointer to the mean for the batch normalization, size = in_channels
- * @param[in]    var                    pointer to the variance for the batch normalization, size = in_channels
- * @param[in]    affine                 whether the affine operations are applied
- * @param[in]    gamma                  pointer to the scaling factors for the post-norm affine operation, size = in_channels
- * @param[in]    beta                   pointer to the scalar offsets for the post-norm affine operation, size = in_channels
- * @param[in]    in_place               in place computation of the batchnorm. Storage efficient
- * 
- * @param[in]    depth_cnn_hidden       hidden state/out_channels dimensions for the depth CNN
- * @param[in]    depth_cnn_padding      padding for the depth CNN layer. Note: applied to both sides of the input 
+ * @brief Model definition for the 1D Convolution block applied after the RNN
+ * @brief sub-layers : custom nonlinearity(semi_sigmoid_tanh) -> batchnorm1d -> conv1d_depth -> conv1d_lr -> avgpool1d
+ * @param[out]   output_signal          pointer to the final output signal, minimum size = out_time * in_channels. out_time has to be calculated based on the reduction from all the conv and pool layers
+ * @param[in]    input_signal           pointer to the input signal. size = in_time * in_channels
+ * @param[in]    in_time                number of time steps in the input
+ * @param[in]    in_channels            number of input channels
+ * @param[in]    mean                   pointer to the mean for the batch normalization, size = in_channels. Pass NULL/0 for affine_config = 2
+ * @param[in]    var                    pointer to the variance for the batch normalization, size = in_channels. Pass NULL/0 for affine_config = 2
+ * @param[in]    affine_config          whether the affine operations are applied
+ *                                      if affine_config = 0, then only mean and var are used
+ *                                      if affine_config = 1, then mean, var, gamma and beta are used for the final computation.
+ *                                      if affine_config = 2, then only the gamma and beta are used. gamma = original_gamma/sqrt(var), beta = original_beta - gamma * mean/sqrt(var)
+ *                                      Note: Use affine_config = 2 for faster calculations. The new gamma and beta would need to be pre-computed, stored and passed
+ * @param[in]    gamma                  pointer to the scaling factors for the post-norm affine operation, size = in_channels. Pass NULL/0 for affine_config = 0
+ * @param[in]    beta                   pointer to the offsets for the post-norm affine operation, size = in_channels. Pass NULL/0 for affine_config = 0
+ * @param[in]    in_place               in-place computation of the batchnorm. Storage efficient
+ * @param[in]    depth_cnn_padding      padding for the depth CNN layer. Note: applied to both sides of the input to the depth CNN
  * @param[in]    depth_cnn_kernel_size  kernel size of the depth CNN
  * @param[in]    depth_cnn_params       weights, bias and other essential parameters used to describe the depth CNN
- * @param[in]    depth_cnn_activations  an integer to choose the type of activation function.
+ * @param[in]    depth_cnn_stride       stride factor for the depth CNN
+ * @param[in]    depth_cnn_activation   an integer to choose the type of activation function.
  *                                      0: none
  *                                      1: sigmoid
  *                                      2: tanh
  *                                      3: relu
- * 
- * @param[in]    point_cnn_hidden       hidden state/out_channels dimensions for the point CNN
- * @param[in]    point_cnn_padding      padding for the point CNN layer. Note: applied to both sides of the input 
+ * @param[in]    point_cnn_hidden       hidden state/out_channels dimensions for the point CNN. The final channel size of this block
+ * @param[in]    point_cnn_padding      padding for the point CNN layer. Note: applied to both sides of the input to the point CNN
  * @param[in]    point_cnn_kernel_size  kernel size of the point CNN
  * @param[in]    point_cnn_params       weights, bias and other essential parameters used to describe the point CNN
- * @param[in]    point_cnn_activations  an integer to choose the type of activation function.
+ * @param[in]    point_cnn_stride       stride factor for the point CNN
+ * @param[in]    point_cnn_activation   an integer to choose the type of activation function.
  *                                      0: none
  *                                      1: sigmoid
  *                                      2: tanh
  *                                      3: relu
- * 
- * @param[in]    pool_padding           padding for the pool layer. Note: applied to both sides of the input 
+ * @param[in]    pool_padding           padding for the pool layer. Note: applied to both sides of the input to the pool 
  * @param[in]    pool_kernel_size       kernel size of the pool
- * @param[in]    pool_activations       an integer to choose the type of activation function.
+ * @param[in]    pool_stride            stride factor for the pool
+ * @param[in]    pool_activation        an integer to choose the type of activation function.
  *                                      0: none
  *                                      1: sigmoid
  *                                      2: tanh
  *                                      3: relu
  */
-int DSCNN_LR_Point_Depth(float* output_signal, float* input_signal, unsigned in_T, unsigned in_channels, float* mean, float* var,
-    unsigned affine, float* gamma, float* beta, unsigned in_place, unsigned depth_cnn_hidden, int depth_cnn_padding, 
-    unsigned depth_cnn_kernel_size, const void* depth_cnn_params, int depth_cnn_activations, unsigned point_cnn_hidden, 
-    int point_cnn_padding, unsigned point_cnn_kernel_size, const void* point_cnn_params, int point_cnn_activations, 
-    int pool_padding, unsigned pool_kernel_size, int pool_activation);
+int phon_pred_depth_point_lr_cnn(float* output_signal, float* input_signal,
+  conv_layer point_cnn, unsigned in_time, unsigned in_channels,
+  const float* const mean, const float* const var,
+  unsigned affine_config, const float* const gamma, const float* const beta, unsigned in_place,
+  unsigned depth_cnn_padding, unsigned depth_cnn_kernel_size,
+  const void* depth_cnn_params, unsigned depth_cnn_stride, unsigned depth_cnn_activation,
+  unsigned point_cnn_hidden, unsigned point_cnn_padding, unsigned point_cnn_kernel_size,
+  const void* point_cnn_params, unsigned point_cnn_stride, unsigned point_cnn_activation,
+  unsigned pool_padding, unsigned pool_kernel_size, unsigned pool_stride, unsigned pool_activation);
 
-#endif
+#endif