Seperated rnn bricking and made minor modifications

Author: AnirudhBHarish

.gitattributes

@@ -63,7 +63,6 @@ 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
@@ -73,3 +72,5 @@ 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,11 +1,11 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
-#ifndef __CONVLAYERS_H__
-#define __CONVLAYERS_H__
+#ifndef __CONV1D_H__
+#define __CONV1D_H__
 
 /**
- * @brief Model paramters for the 1D Convolution Layer
+ * @brief Model parameters for the 1D Convolution Layer
  * @var   W    pointer to convolutional weights W, size for regular = out_channels*in_channels*kernel_size, size for depth based = out_channels*kernel_size
  * @var   B    pointer to the bias vector for the convolution, shape = [out_channels]
  */
@@ -16,13 +16,16 @@ typedef struct ConvLayers_Params {
 
 /**
  * @brief Model definition for the 1D Convolution Layer
- * @param[out]   output_signal    pointer to the output signal, size = out_T * out_channels
- * @param[in]    out_T            number of time steps in the output
- * @param[in]    out_channels     number of output channels for the ouput of the conv layer
- * @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[out]   output_signal    pointer to the output signal, size = out_time * out_channels
+ * @param[in]    out_time            number of time steps in the output
+ * @param[in]    out_channels     number of output channels for the output of the conv layer
+ * @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]    padding          padding applied to the input before the conv is performed. Note: padding is applied to both the start and end
+ * @param[in]    padding          padding applied to the input before the conv is performed.
+ *                                Note: padding is applied to both the starting and ending of the input, along the time axis
+ *                                E.g : padding = 3, the input is padded with zeros(for 3 time steps), both before the input_signal(time step 0) and after the input_signal(teim step in_time).
+ * 
  * @param[in]    kernel_size      kernel size of the conv filter
  * @param[in]    params           weights, bias and other essential parameters used to describe the layer
  * @param[in]    activations      an integer to choose the type of activation function.
@@ -31,18 +34,21 @@ typedef struct ConvLayers_Params {
  *                                2: tanh
  *                                3: relu
  */
-int conv1d(float *output_signal, unsigned out_T, unsigned out_channels, const float *input_signal, 
-  unsigned in_T, unsigned in_channels, int padding, unsigned kernel_size, 
+int conv1d(float *output_signal, unsigned out_time, unsigned out_channels, const float *input_signal, 
+  unsigned in_time, unsigned in_channels, int padding, unsigned kernel_size, 
   const void* params, int activations);
 
 /**
  * @brief Model definition for the 1D Depthwise Convolution Layer
- * @param[out]   output_signal    pointer to the output signal, size = out_T * in_channels
- * @param[in]    out_T            number of time steps in the output
- * @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[out]   output_signal    pointer to the output signal, size = out_time * in_channels
+ * @param[in]    out_time            number of time steps in the output
+ * @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. The output will have the same number of channels
- * @param[in]    padding          padding applied to the input before the conv is performed. Note: padding is applied to both the start and end
+ * @param[in]    padding          padding applied to the input before the conv is performed.
+ *                                Note: padding is applied to both the starting and ending of the input, along the time axis
+ *                                E.g : padding = 3, the input is padded with zeros(for 3 time steps), both before the input_signal(time step 0) and after the input_signal(teim step in_time).
+ * 
  * @param[in]    kernel_size      kernel size of the conv filter
  * @param[in]    params           weights, bias and other essential parameters used to describe the layer
  * @param[in]    activations      an integer to choose the type of activation function.
@@ -51,14 +57,13 @@ int conv1d(float *output_signal, unsigned out_T, unsigned out_channels, const fl
  *                                2: tanh
  *                                3: relu
  */
-int conv1d_depth(float *output_signal, unsigned out_T, const float *input_signal, 
-  unsigned in_T, unsigned in_channels, int padding, unsigned kernel_size, 
+int conv1d_depth(float *output_signal, unsigned out_time, const float *input_signal, 
+  unsigned in_time, unsigned in_channels, int padding, unsigned kernel_size, 
   const void* params, int activations);
 
 
-// Low Rank Convolution
 /**
- * @brief Model paramters for the 1D Convolution Layer
+ * @brief Model parameters for the 1D Low Rank Convolution Layer
  * @var    W1      pointer to the 1st low-rank component of the weights, size = out_channels * rank
  * @var    W2      pointer to the 2nd low-rank component of the weights, size for regular = rank * in_channels * kernel_size, size for depthwise = rank * kernel_size
  * @var    B       pointer to the bias vector for the convolution, shape = [out_channels]
@@ -73,14 +78,17 @@ typedef struct ConvLayers_LR_Params {
 
 /**
  * @brief Model definition for the 1D Low Rank Convolution Layer
- * @brief Identical to the non-low-rank form. One modification is the mulitplication of the weights handeled witin the layer
- * @param[out]   output_signal    pointer to the output signal, size = out_T * out_channels
- * @param[in]    out_T            number of time steps in the output
+ * @brief Identical to the non-low-rank form. One modification is the mulitplication of the weights handeled within the layer
+ * @param[out]   output_signal    pointer to the output signal, size = out_time * out_channels
+ * @param[in]    out_time            number of time steps in the output
  * @param[in]    out_channels     number of output channels for the ouput of the conv layer
- * @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]    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]    padding          padding applied to the input before the conv is performed. Note: padding is applied to both the start and end
+ * @param[in]    padding          padding applied to the input before the conv is performed.
+ *                                Note: padding is applied to both the starting and ending of the input, along the time axis
+ *                                E.g : padding = 3, the input is padded with zeros(for 3 time steps), both before the input_signal(time step 0) and after the input_signal(teim step in_time).
+ * 
  * @param[in]    kernel_size      kernel size of the conv filter
  * @param[in]    params           weights, bias and other essential parameters used to describe the layer
  * @param[in]    activations      an integer to choose the type of activation function.
@@ -89,19 +97,22 @@ typedef struct ConvLayers_LR_Params {
  *                                2: tanh
  *                                3: relu
  */
-int conv1d_lr(float *output_signal, unsigned out_T, unsigned out_channels, const float *input_signal, 
-  unsigned in_T, unsigned in_channels, int padding, unsigned kernel_size, 
+int conv1d_lr(float *output_signal, unsigned out_time, unsigned out_channels, const float *input_signal, 
+  unsigned in_time, unsigned in_channels, int padding, unsigned kernel_size, 
   const void* params, int activations);
 
 /**
  * @brief Model definition for the 1D Depthwise Convolution Layer
  * @brief Identical to the non-low-rank form. One modification is the mulitplication of the weights handeled witin the layer
- * @param[out]   output_signal    pointer to the output signal, size = out_T * in_channels
- * @param[in]    out_T            number of time steps in the output
- * @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[out]   output_signal    pointer to the output signal, size = out_time * in_channels
+ * @param[in]    out_time            number of time steps in the output
+ * @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. The output will have the same number of channels
- * @param[in]    padding          padding applied to the input before the conv is performed. Note: padding is applied to both the start and end
+ * @param[in]    padding          padding applied to the input before the conv is performed.
+ *                                Note: padding is applied to both the starting and ending of the input, along the time axis
+ *                                E.g : padding = 3, the input is padded with zeros(for 3 time steps), both before the input_signal(time step 0) and after the input_signal(teim step in_time).
+ * 
  * @param[in]    kernel_size      kernel size of the conv filter
  * @param[in]    params           weights, bias and other essential parameters used to describe the layer
  * @param[in]    activations      an integer to choose the type of activation function.
@@ -110,44 +121,47 @@ int conv1d_lr(float *output_signal, unsigned out_T, unsigned out_channels, const
  *                                2: tanh
  *                                3: relu
  */
-int conv1d_depth_lr(float *output_signal, unsigned out_T, const float *input_signal, 
-  unsigned in_T, unsigned in_channels, int padding, unsigned kernel_size, 
+int conv1d_depth_lr(float *output_signal, unsigned out_time, const float *input_signal, 
+  unsigned in_time, unsigned in_channels, int padding, unsigned kernel_size, 
   const void* params, int activations);
 
 // Auxillary Layers
 /**
  * @brief Model definition for the 1D Average Pooling Layer
- * @param[out]   output_signal    pointer to the output signal, size = out_T * in_channels. Provide Null/0 incase of inplace computation
- * @param[in]    out_T            number of time steps in the output
- * @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[out]   output_signal    pointer to the output signal, size = out_time * in_channels. Provide Null/0 incase of in-place computation
+ * @param[in]    out_time            number of time steps in the output
+ * @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. The output will have the same number of channels
- * @param[in]    padding          padding applied to the input before the pool is performed. Note: padding is applied to both the start and end
+ * @param[in]    padding          padding applied to the input before the conv is performed.
+ *                                Note: padding is applied to both the starting and ending of the input, along the time axis
+ *                                E.g : padding = 3, the input is padded with zeros(for 3 time steps), both before the input_signal(time step 0) and after the input_signal(teim step in_time).
+ * 
  * @param[in]    kernel_size      kernel size of the pool filter
  * @param[in]    activations      an integer to choose the type of activation function.
  *                                0: none
  *                                1: sigmoid
  *                                2: tanh
  *                                3: relu
  */
-int avgpool1d(float *output_signal, unsigned out_T, const float *input_signal, unsigned in_T, unsigned in_channels, 
+int avgpool1d(float *output_signal, unsigned out_time, const float *input_signal, unsigned in_time, unsigned in_channels, 
   int padding, unsigned kernel_size, int activations);
 
 /**
  * @brief Model definition for the 1D batch Normalization Layer
- * @param[out]   output_signal    pointer to the output signal, size = out_T * in_channels. Provide Null/0 incase of inplace computation
- * @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[out]   output_signal    pointer to the output signal, size = out_time * in_channels. Provide Null/0 incase of in-place computation
+ * @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. 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 i.e. the output is stored in place of the input signal. Storage efficient
+ * @param[in]    in_place         in-place computation of the batchnorm i.e. the output is stored in-place of the input signal. Storage efficient
  * @param[in]    eps              a very small +ve value to avoid division by 0. For the default value, assign = 0.00001
  */
-int batchnorm1d(float* output_signal, float* input_signal, unsigned in_T, unsigned in_channels, 
+int batchnorm1d(float* output_signal, float* input_signal, unsigned in_time, unsigned in_channels, 
   float* mean, float* var, unsigned affine, float* gamma , float * beta, unsigned in_place, float eps);
 
 #endif

c_reference/include/conv_utils.h

@@ -4,24 +4,8 @@
 #ifndef __CONVLAYER_UTILS__
 #define __CONVLAYER_UTILS__
 
-/**
- * @brief Definition for the Utility Fucntion for Preparing the Low Rank Conv Weights
- * @param[out]   out     pointer to the output signal, size (regular) = out_T * in_channels * kernel_size, size (depthwise) = out_t * kernel_size
- * @param[in]    W1      1st component of the low rank weight tensor. size = out_channels * rank
- * @param[in]    W2      2nd component of the low rank weight tensor. size (regular) = rank * in_channels * kernel_size, size (depthwise)  = rank * kernel_size
- * @param[in]    rank    rank of the weight tensor. Low Rank
- * @param[in]    I       dim 0 for W1, value = out_channels
- * @param[in]    J       dim 1 for W2, value = in_channels * kernel_size, (or for depthwise) = kernel_size
- */
-int matmul(float* out, float* W1, float* W2, unsigned rank, unsigned I, unsigned J);
 
-/**
- * @brief Definition for the Custom non-linear layer : The TanhGate
- * @param[out]   output_signal    pointer to the output signal, size = out_T * in_channels
- * @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 half the number of channels. Recommended in_channel % 2 == 0
- */
-int TanhGate(float* output_signal, float* input_signal, unsigned in_T, unsigned in_channels);
+
+
 
 #endif