Conv1d layer and test-bench formatting changes

Author: AnirudhBHarish

c_reference/include/conv1d.h

@@ -6,7 +6,7 @@
 
 /**
  * @brief Model parameters for the 1D Convolution Layer
- * @var   W    pointer to convolution weights W, size for regular = out_channels*in_channels*kernel_size, size for depth based = out_channels*kernel_size
+ * @var   W    pointer to convolution 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, size = out_channels
  */
 typedef struct ConvLayers_Params {
@@ -25,7 +25,6 @@ typedef struct ConvLayers_Params {
  * @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(time 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.
@@ -34,7 +33,7 @@ typedef struct ConvLayers_Params {
  *                                2: tanh
  *                                3: relu
  */
-int conv1d(float *output_signal, unsigned out_time, unsigned out_channels, const float *input_signal, 
+int conv1d(float* output_signal, unsigned out_time, unsigned out_channels, const float* input_signal, 
   unsigned in_time, unsigned in_channels, unsigned padding, unsigned kernel_size, 
   const void* params, int activations);
 
@@ -48,7 +47,6 @@ int conv1d(float *output_signal, unsigned out_time, unsigned out_channels, const
  * @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(time 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.
@@ -57,11 +55,10 @@ int conv1d(float *output_signal, unsigned out_time, unsigned out_channels, const
  *                                2: tanh
  *                                3: relu
  */
-int conv1d_depth(float *output_signal, unsigned out_time, const float *input_signal, 
+int conv1d_depth(float* output_signal, unsigned out_time, const float* input_signal, 
   unsigned in_time, unsigned in_channels, unsigned padding, unsigned kernel_size, 
   const void* params, int activations);
 
-
 /**
  * @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
@@ -88,7 +85,6 @@ typedef struct ConvLayers_LR_Params {
  * @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(time 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.
@@ -97,7 +93,7 @@ typedef struct ConvLayers_LR_Params {
  *                                2: tanh
  *                                3: relu
  */
-int conv1d_lr(float *output_signal, unsigned out_time, unsigned out_channels, const float *input_signal, 
+int conv1d_lr(float* output_signal, unsigned out_time, unsigned out_channels, const float* input_signal, 
   unsigned in_time, unsigned in_channels, unsigned padding, unsigned kernel_size, 
   const void* params, int activations);
 
@@ -112,7 +108,6 @@ int conv1d_lr(float *output_signal, unsigned out_time, unsigned out_channels, co
  * @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(time 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.
@@ -121,7 +116,7 @@ int conv1d_lr(float *output_signal, unsigned out_time, unsigned out_channels, co
  *                                2: tanh
  *                                3: relu
  */
-int conv1d_depth_lr(float *output_signal, unsigned out_time, const float *input_signal, 
+int conv1d_depth_lr(float* output_signal, unsigned out_time, const float* input_signal, 
   unsigned in_time, unsigned in_channels, unsigned padding, unsigned kernel_size, 
   const void* params, int activations);
 
@@ -136,15 +131,15 @@ int conv1d_depth_lr(float *output_signal, unsigned out_time, const float *input_
  * @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(time 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_time, const float *input_signal, unsigned in_time, unsigned in_channels, 
+int avgpool1d(float* output_signal, unsigned out_time, const float* input_signal,
+  unsigned in_time, unsigned in_channels,
   unsigned padding, unsigned kernel_size, int activations);
 
 /**
@@ -156,14 +151,14 @@ int avgpool1d(float *output_signal, unsigned out_time, const float *input_signal
  * @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]    gamma            pointer to the scaling factors for the post-norm affine operation, size = in_channels. Provide Null/0 if affine is False(non-zero)
+ * @param[in]    beta             pointer to the offsets for the post-norm affine operation, size = in_channels. Provide Null/0 if affine is False(non-zero)
  * @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
- * 
- * NOTE: if affine is equated to False(0), then null-pointers(or 0) can be passed for the gamma and beta arguments
  */
-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);
+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/dscnn.h

@@ -7,19 +7,16 @@
 /**
  * @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
  * @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 offsets for the post-norm affine operation, size = in_channels
  * @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
@@ -30,27 +27,25 @@
  *                                   2: tanh
  *                                   3: relu
  */
-int phon_pred_lr_cnn(float* output_signal, float* input_signal, unsigned in_time, unsigned in_channels,
+int phon_pred_lr_cnn(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,
   unsigned cnn_hidden, unsigned cnn_padding, unsigned cnn_kernel_size,
   const void* cnn_params, int cnn_activations);
 
 /**
  * @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
  * @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 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 to the depth CNN
  * @param[in]    depth_cnn_kernel_size  kernel size of the depth CNN
@@ -60,7 +55,6 @@ int phon_pred_lr_cnn(float* output_signal, float* input_signal, unsigned in_time
  *                                      1: sigmoid
  *                                      2: tanh
  *                                      3: relu
- * 
  * @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
@@ -70,7 +64,6 @@ int phon_pred_lr_cnn(float* output_signal, float* input_signal, unsigned in_time
  *                                      1: sigmoid
  *                                      2: tanh
  *                                      3: relu
- * 
  * @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.
@@ -79,7 +72,8 @@ int phon_pred_lr_cnn(float* output_signal, float* input_signal, unsigned in_time
  *                                      2: tanh
  *                                      3: relu
  */
-int phon_pred_depth_point_lr_cnn(float* output_signal, float* input_signal, unsigned in_time, unsigned in_channels,
+int phon_pred_depth_point_lr_cnn(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,
   unsigned depth_cnn_hidden, unsigned depth_cnn_padding, unsigned depth_cnn_kernel_size,
   const void* depth_cnn_params, int depth_cnn_activations,

c_reference/include/rnn_bricked.h

@@ -5,7 +5,8 @@
 #define __RNN_BRICKED_H__
 
 // Function Pointer for the RNN to be passed as a parameter
-typedef int (*rnn_t)(float* const, unsigned, const float* const, unsigned, unsigned, const void*, void*, int, int);
+typedef int (*rnn_t)(float* const, unsigned, const float* const, unsigned, 
+                      unsigned, const void*, void*, int, int);
 
 // NOTES for bi-direction
 // If bi_direction = 1, then actual rnn_output_dims is twice the rnn_hidden(rnn_hidden is output dims for each cell). 
@@ -33,42 +34,42 @@ typedef int (*rnn_t)(float* const, unsigned, const float* const, unsigned, unsig
 // These constraints can be ignored while performing uni-directional passes. However, it is favorable to follow constraints 1 and 2
 
 
-/** Forward Bricking and application of the forward rnn for an input signal
+/** Forward Bricking and application of the forward RNN for an input signal
  * @param[out]       output_signal        pointer to output signal. size = out_time * rnn_hidden
  * @param[in]        rnn_hidden           output dimension for the current cell
  * @param[in]        input_signal         pointer to input signal. size = in_time * in_dims
  * @param[in]        in_time              number of input time steps.
  * @param[in]        in_dims              input dimensions
  * @param[in]        window               window length for each brick. For the final brick, the left over time steps are used(need not be window in length for the last brick) 
  * @param[in]        hop                  hop distance for between bricks
- * @param[in]        rnn                  function pointer to the rnn
- * @param[in]        params               pointer to the parameters for the rnn
- * @param[in,out]    buffers              pointer to buffer for the rnn
- * @param[in]        bi_direction         determine if the ouput if for a bi-directional rnn. 
+ * @param[in]        rnn                  function pointer to the RNN
+ * @param[in]        params               pointer to the parameters for the RNN
+ * @param[in,out]    buffers              pointer to buffer for the RNN
+ * @param[in]        bi_direction         determine if the ouput if for a bi-directional RNN. 
  * @param[in]        sample_first_brick   determine if the 1st brick should also be sampled
- *                   -> if = 0, only the last hidden state of each brick is sampled. out_time = (in_time-window)/hop + 1
- *                   -> if = 1, for the 1st brick, we sample every hop index(similar to ::hop). For all the bricks(including the 1st) we sample the final hiddens state. out_time = in_time/hop + 1
+ *                                        -> if = 0, only the last hidden state of each brick is sampled. out_time = (in_time-window)/hop + 1
+ *                                        -> if = 1, for the 1st brick, we sample every hop index(similar to ::hop). For all the bricks(including the 1st) we sample the final hiddens state. out_time = in_time/hop + 1
  */
 int forward_bricked_rnn(float* output_signal, unsigned rnn_hidden, float* input_signal,
   unsigned in_time, unsigned in_dims, unsigned window, unsigned hop,
   rnn_t rnn, const void* params, void* buffers,
   int bi_direction, int sample_first_brick, int normalize);
 
-/** Backward Bricking and application of the backward rnn for an input signal
+/** Backward Bricking and application of the backward RNN for an input signal
  * @param[out]       output_signal        pointer to output signal. size = out_time * rnn_hidden
  * @param[in]        rnn_hidden           output dimension for the current cell
  * @param[in]        input_signal         pointer to input signal. size = in_time * in_dims
  * @param[in]        in_time              number of input time steps.
  * @param[in]        in_dims              input dimensions
  * @param[in]        window               window length for each brick. For the final brick, the left over time steps are used(need not be window in length for the last brick)
  * @param[in]        hop                  hop distance for between bricks
- * @param[in]        rnn                  function pointer to the rnn
- * @param[in]        params               pointer to the parameters for the rnn
- * @param[in,out]    buffers              pointer to buffer for the rnn
- * @param[in]        bi_direction         determine if the ouput if for a bi-directional rnn. 
- * @param[in]        sample_last_brick   determine if the last brick should also be sampled
- *                   -> if = 0, only the first(last in reverse) hidden state of each brick is sampled. out_time = (in_time-window)/hop + 1
- *                   -> if = 1, for the last brick, we sample every hop index in reverse(similar to ::hop in reverse). For all the bricks(including the last) we sample the first hiddens state(last in reverse). out_time = in_time/hop + 1
+ * @param[in]        rnn                  function pointer to the RNN
+ * @param[in]        params               pointer to the parameters for the RNN
+ * @param[in,out]    buffers              pointer to buffer for the RNN
+ * @param[in]        bi_direction         determine if the ouput if for a bi-directional RNN. 
+ * @param[in]        sample_last_brick    determine if the last brick should also be sampled
+ *                                        -> if = 0, only the first(last in reverse) hidden state of each brick is sampled. out_time = (in_time-window)/hop + 1
+ *                                        -> if = 1, for the last brick, we sample every hop index in reverse(similar to ::hop in reverse). For all the bricks(including the last) we sample the first hiddens state(last in reverse). out_time = in_time/hop + 1
  */
 int backward_bricked_rnn(float* output_signal, unsigned rnn_hidden, float* input_signal,
   unsigned in_time, unsigned in_dims, unsigned window, unsigned hop,