Removed Norm and Modified Depth-wise Conv

Author: Anirudh B H

c_reference/include/conv1d.h

@@ -1,3 +1,4 @@
+#include<stdlib.h>
 #ifndef __CONVLAYERS_H__
 #define __CONVLAYERS_H__
 
@@ -14,20 +15,18 @@
  * @var       B            pointer to the bias vector for the convolution
  */
 typedef struct ConvLayers_Params{
-    float* mean;
-    float* stdDev;
     float* W;
     float* B;
 } ConvLayers_Params;
 
 
-int Conv1D(float *output_signal, unsigned out_channels, const float *input_signal, 
+int Conv1D(float *output_signal, unsigned out_T, unsigned out_channels, const float *input_signal, 
     unsigned N, unsigned in_T, unsigned in_channels, int padding, unsigned kernel_size, 
-    const void* params,int normalize, int activations);
+    const void* params, int activations);
 
-int Conv1D_Depth(float *output_signal, const float *input_signal, 
+int Conv1D_Depth(float *output_signal, unsigned out_T, const float *input_signal, 
     unsigned N, unsigned in_T, unsigned in_channels, int padding, unsigned kernel_size, 
-    const void* params,int normalize, int activations);
+    const void* params, int activations);
 
 // Low Rank
 /**
@@ -40,24 +39,22 @@ int Conv1D_Depth(float *output_signal, const float *input_signal,
  * @var       B            pointer to the bias vector for the convolution
  */
 typedef struct ConvLayers_LR_Params{
-    float* mean;
-    float* stdDev;
     float* W1;
     float* W2;
     float* B;
     unsigned rank;
 } ConvLayers_LR_Params;
 
-int Conv1D_LR(float *output_signal, unsigned out_channels, const float *input_signal, 
+int Conv1D_LR(float *output_signal, unsigned out_T, unsigned out_channels, const float *input_signal, 
     unsigned N, unsigned in_T, unsigned in_channels, int padding, unsigned kernel_size, 
-    const void* params,int normalize, int activations);
+    const void* params, int activations);
 
-int Conv1D_Depth_LR(float *output_signal, const float *input_signal, 
+int Conv1D_Depth_LR(float *output_signal, unsigned out_T, const float *input_signal, 
     unsigned N, unsigned in_T, unsigned in_channels, int padding, unsigned kernel_size, 
-    const void* params,int normalize, int activations);
+    const void* params, int activations);
 
 //Pool
-AvgPool1D(float *output_signal, unsigned out_T, const float *input_signal, unsigned N, unsigned in_T, unsigned in_channels, 
+int AvgPool1D(float *output_signal, unsigned out_T, const float *input_signal, unsigned N, unsigned in_T, unsigned in_channels, 
     int padding, unsigned kernel_size, int activations);
 
 #endif

c_reference/src/conv1d.c

@@ -1,32 +1,26 @@
 #include"conv1d.h"
 #include"conv_utils.h"
+#include<stdlib.h>
+#include<math.h>
+#include<stdio.h>
 
-int Conv1D_LR(float *output_signal, unsigned out_channels, const float *input_signal, 
+int Conv1D_LR(float *output_signal, unsigned out_T, unsigned out_channels, const float *input_signal, 
     unsigned N, unsigned in_T, unsigned in_channels, int padding, unsigned kernel_size, 
-    const void* params,int normalize, int activations){
+    const void* params, int activations){
 
     const ConvLayers_LR_Params* tparams= (ConvLayers_LR_Params*) params;
 
     if(padding == -1){
         padding = kernel_size >> 1;
     }
     float* tempW = (float*)malloc(out_channels * in_channels * kernel_size * sizeof(float)) ;
-    prepareLowRankConvMat(tempW, tparams->W1, tparams->W2, tparams->rank, out_channels, in_channels * kernel_size)
+    prepareLowRankConvMat(tempW, tparams->W1, tparams->W2, tparams->rank, out_channels, in_channels * kernel_size);
 
     // Perform the Convolution
-    // input.shape  = [N,  in_T,  in_channels] 
-    // output.shape = [N, out_T, out_channels]
+    // input.shape  = [in_T,  in_channels] 
+    // output.shape = [out_T, out_channels]
     // filter.shape = [out_channels, in_channels, kernel_size]
     for(int t = 0; t < out_T; t++){
-        if (normalize) {
-            for (unsigned d = 0; d < in_channels; d++)
-                input_signal[t * in_channels + d] = ((input_signal[t * in_channels + d] - tparams->mean[d]) / tparams->stdDev[d]);
-            // v_add(1.0f, input_signal + t * in_channels, -1.0f, tparams->mean,
-            //     in_channels, tbuffers->normFeatures);
-            // v_div(tparams->stdDev + t * in_channels, tbuffers->normFeatures, in_channels,
-                // tbuffers->normFeatures);
-        }
-
         for(int co = 0; co < out_channels ; co++){
             float sum = 0;
             for(int tf = 0 ; tf < kernel_size ; tf++ ){
@@ -36,52 +30,45 @@ int Conv1D_LR(float *output_signal, unsigned out_channels, const float *input_si
                 }
             }
             if(activations == 1){
-                output_signal[n * out_channels * out_T + t * out_channels + co] = sigmoid(sum + tparams->B[co]);     
+                output_signal[t * out_channels + co] = sigmoid(sum + tparams->B[co]);     
             }
             else if(activations == 2){
-                output_signal[n * out_channels * out_T + t * out_channels + co] = tanh(sum + tparams->B[co]);
+                output_signal[t * out_channels + co] = tanh(sum + tparams->B[co]);
             }
             else if(activations == 3){
-                output_signal[n * out_channels * out_T + t * out_channels + co] = relu(sum + tparams->B[co]);
+                output_signal[t * out_channels + co] = relu(sum + tparams->B[co]);
             }
             else{
-                output_signal[n * out_channels * out_T + t * out_channels + co] = sum + tparams->B[co];
+                output_signal[t * out_channels + co] = sum + tparams->B[co];
             }
         }
     }
-    free(tempW)
+    free(tempW);
     return 0;
 }
 
-
-int Conv1D_Depth_LR(float *output_signal, const float *input_signal, 
+int Conv1D_Depth_LR(float *output_signal, unsigned out_T, const float *input_signal, 
     unsigned N, unsigned in_T, unsigned in_channels, int padding, unsigned kernel_size, 
-    const void* params,int normalize, int activations){
+    const void* params, int activations){
 
     const ConvLayers_LR_Params* tparams= (ConvLayers_LR_Params*) params;
 
-    if (tempW == 0) return ERR_TEMPW_NOT_INIT;
-
     if(padding == -1){
         padding = kernel_size >> 1;
     }
 
-    float* tempW = (float*)malloc(out_channels * in_channels * kernel_size * sizeof(float)) ;
-    prepareLowRankConvMat(tempW, tparams->W1, tparams->W2, tparams->rank, in_channels, in_channels * kernel_size)
+    float* tempW = (float*)malloc(in_channels * kernel_size * sizeof(float)) ;
+    prepareLowRankConvMat(tempW, tparams->W1, tparams->W2, tparams->rank, in_channels, in_channels * kernel_size);
     // Perform the Convolution
     // input.shape  = [N,  in_T,  in_channels] 
     // output.shape = [N, out_T, in_channels]
     // filter.shape = [(out)in_channels, in_channels, kernel_size]
     for(int t = 0; t < out_T; t++){
-        if (normalize) {
-            for (unsigned d = 0; d < in_channels; d++)
-                input_signal[t * in_channels + d] = ((input_signal[t * in_channels + d] - tparams->mean[d]) / tparams->stdDev[d]);
-        }
         for(int ci = 0; ci < in_channels ; ci++){
             float sum = 0;
             for(int tf = 0 ; tf < kernel_size ; tf++ ){
                 float a = ((((t + tf) < padding) || ((t + tf) >= (in_T + padding))) ? 0 : input_signal[((tf + t) - padding) * in_channels + ci]);
-                sum += (a * tempW[ci * in_channels * kernel_size + ci * kernel_size + tf]);
+                sum += (a * tempW[ci * kernel_size + tf]);
             }
             if(activations == 1){
                 output_signal[t * in_channels + ci] = sigmoid(sum + tparams->B[ci]);     
@@ -97,62 +84,57 @@ int Conv1D_Depth_LR(float *output_signal, const float *input_signal,
             }
         }
     }    
-    free(tempW)
+    free(tempW);
     return 0;
 }
 
 
 
-int Conv1D(float *output_signal, unsigned out_channels, const float *input_signal, 
+int Conv1D(float *output_signal, unsigned out_T, unsigned out_channels, const float *input_signal, 
     unsigned N, unsigned in_T, unsigned in_channels, int padding, unsigned kernel_size, 
-    const void* params,int normalize, int activations){
-    
+    const void* params, int activations){
+
     const ConvLayers_Params* tparams= (ConvLayers_Params*) params;
 
     if(padding == -1){
         padding = kernel_size >> 1;
     }
-
+    float sum;
     // Perform the Convolution
     // input.shape  = [N,  in_T,  in_channels] 
     // output.shape = [N, out_T, out_channels]
     // filter.shape = [out_channels, in_channels, kernel_size]
     for(int t = 0; t < out_T; t++){
-        if (normalize) {
-            for (unsigned d = 0; d < in_channels; d++)
-                input_signal[t * in_channels + d] = ((input_signal[t * in_channels + d] - tparams->mean[d]) / tparams->stdDev[d]);
-        }
-
         for(int co = 0; co < out_channels ; co++){
-            float sum = 0;
+            sum = 0;
             for(int tf = 0 ; tf < kernel_size ; tf++ ){
                 for(int ci = 0 ; ci < in_channels ; ci++){
-                    float a = ((((t + tf) < padding) || ((t + tf) >= (in_T + padding))) ? continue : input_signal[((tf + t) - padding) * in_channels + ci]);
+                    float a = ((((t + tf) < padding) || ((t + tf) >= (in_T + padding))) ? 0 : input_signal[((tf + t) - padding) * in_channels + ci]);
                     sum += (a * tparams->W[co * in_channels * kernel_size + ci * kernel_size + tf]);
                 }
             }
             if(activations == 1){
-                output_signal[n * out_channels * out_T + t * out_channels + co] = sigmoid(sum + tparams->B[co]);     
+                output_signal[t * out_channels + co] = sigmoid(sum + tparams->B[co]);     
             }
             else if(activations == 2){
-                output_signal[n * out_channels * out_T + t * out_channels + co] = tanh(sum + tparams->B[co]);
+                output_signal[t * out_channels + co] = tanh(sum + tparams->B[co]);
             }
             else if(activations == 3){
-                output_signal[n * out_channels * out_T + t * out_channels + co] = relu(sum + tparams->B[co]);
+                output_signal[t * out_channels + co] = relu(sum + tparams->B[co]);
             }
             else{
-                output_signal[n * out_channels * out_T + t * out_channels + co] = sum + tparams->B[co];
+                output_signal[t * out_channels + co] = sum + tparams->B[co];
             }
         }
     }    
     return 0;
 }
 
-int Conv1D_Depth(float *output_signal, const float *input_signal, 
+int Conv1D_Depth(float *output_signal, unsigned out_T, const float *input_signal, 
     unsigned N, unsigned in_T, unsigned in_channels, int padding, unsigned kernel_size, 
-    const void* params,int normalize, int activations){
+    const void* params, int activations){
 
-    const ConvLayers_LR_Params* tparams= (ConvLayers_LR_Params*) params;
+    const ConvLayers_Params* tparams= (ConvLayers_Params*) params;
 
     if(padding == -1){
         padding = kernel_size >> 1;
@@ -163,15 +145,11 @@ int Conv1D_Depth(float *output_signal, const float *input_signal,
     // output.shape = [N, out_T, in_channels]
     // filter.shape = [(out)in_channels, in_channels, kernel_size]
     for(int t = 0; t < out_T; t++){
-        if (normalize) {
-            for (unsigned d = 0; d < in_channels; d++)
-                input_signal[t * in_channels + d] = ((input_signal[t * in_channels + d] - tparams->mean[d]) / tparams->stdDev[d]);
-        }
         for(int ci = 0; ci < in_channels ; ci++){
             float sum = 0;
             for(int tf = 0 ; tf < kernel_size ; tf++ ){
                 float a = ((((t + tf) < padding) || ((t + tf) >= (in_T + padding))) ? 0 : input_signal[((tf + t) - padding) * in_channels + ci]);
-                sum += (a * tparams->W[ci * in_channels * kernel_size + ci * kernel_size + tf]);
+                sum += (a * tparams->W[ci * kernel_size + tf]);
             }
             if(activations == 1){
                 output_signal[t * in_channels + ci] = sigmoid(sum + tparams->B[ci]);     
@@ -198,9 +176,9 @@ int AvgPool1D(float *output_signal, unsigned out_T, const float *input_signal, u
     }
 
     for(int t = 0; t < out_T; t++){
-        for(int ci = 0 ; ci < in_channels){
+        for(int ci = 0 ; ci < in_channels; ci++){
             float sum = 0;
-            for(int tf = ; tf < kernel_size ; tf++){
+            for(int tf = 0; tf < kernel_size ; tf++){
                 sum += ((((t + tf) < padding) || ((t + tf) >= (in_T + padding))) ? 0 : input_signal[((tf + t) - padding) * in_channels + ci]);
             }
             if(activations == 1){