one more step

Author: Oleksii Moiseenko

CMakeLists.txt

@@ -64,7 +64,7 @@ set(SOURCES
     nntoolkitcore/layers/private/recurrent_private.h
     nntoolkitcore/core/memory.c
     nntoolkitcore/layers/bidirectional.c
-        nntoolkitcore/layers/private/weights_private.c nntoolkitcore/layers/private/weights_private.h)
+        nntoolkitcore/layers/private/weights_private.c nntoolkitcore/layers/private/weights_private.h nntoolkitcore/layers/recurrent.c)
 
 if(APPLE)
     list(APPEND SOURCES nntoolkitcore/core/apple_ops.c)

nntoolkitcore/layers/conv_1d.c

@@ -10,10 +10,12 @@
 #include "nntoolkitcore/core/loop.h"
 #include "nntoolkitcore/core/ops.h"
 #include "nntoolkitcore/core/memory.h"
+#include "nntoolkitcore/layers/private/weights_private.h"
 
 typedef struct {
     ConvTrainingConfig config;
     float *input_transposed;
+    DefaultGradient **batch_gradients;
 } Conv1dTrainingData;
 
 typedef struct {
@@ -27,26 +29,43 @@ struct Conv1dStruct {
     Conv1dTrainingData *training_data;
 };
 
+ConvWeightsSize conv1d_weight_size_from_config(Conv1dConfig config) {
+    int w_size = config.kernel_size * config.input_feature_channels * config.output_feature_channels;
+    int sum = w_size + config.output_feature_channels;
+    return (DefaultWeightsSize) {.w = w_size, .b = config.output_feature_channels, .sum = sum};
+}
+
+
+static Conv1dInferenceData *conv1d_inference_data_create(Conv1dConfig config) {
+    Conv1dInferenceData *data = malloc(sizeof(Conv1dInferenceData));
+    data->buffer = malloc(config.input_size * config.input_feature_channels * sizeof(float));
+    return data;
+}
+
 static Conv1dTrainingData *conv1d_training_data_create(Conv1dConfig config, ConvTrainingConfig training_config) {
     Conv1dTrainingData *data = malloc(sizeof(Conv1dTrainingData));
+    int b = training_config.mini_batch_size;
     data->config = training_config;
     data->input_transposed = malloc(config.input_feature_channels * config.input_size
-                                    * training_config.mini_batch_size * sizeof(float));
+                                    * b * sizeof(float));
+    data->batch_gradients = malloc(b * sizeof(DefaultGradient *));
+    for (int i = 0; i < b; ++i) {
+        data->batch_gradients[i] = default_gradient_create(conv1d_weight_size_from_config(config), 0);
+    }
     return data;
 }
 
 static void conv_training_data_destroy(Conv1dTrainingData *training_data) {
+    for (int i = 0; i < training_data->config.mini_batch_size; ++i) {
+        default_gradient_destroy(training_data->batch_gradients[i]);
+    }
+    free(training_data->batch_gradients);
     free(training_data->input_transposed);
     free(training_data);
 }
 
-static Conv1dInferenceData *conv1d_inference_data_create(Conv1dConfig config) {
-    Conv1dInferenceData *data = malloc(sizeof(Conv1dInferenceData));
-    data->buffer = malloc(config.input_size * config.input_feature_channels * sizeof(float));
-    return data;
-}
 
-static void conv1d_inference_data_destroy(Conv1dInferenceData* data) {
+static void conv1d_inference_data_destroy(Conv1dInferenceData *data) {
     free(data->buffer);
     free(data);
 }
@@ -67,20 +86,10 @@ Conv1dConfig Conv1dConfigCreate(int input_feature_channels, int output_feature_c
     return config;
 }
 
-ConvWeightsSize conv1d_weight_size_from_config(Conv1dConfig config){
-    int w_size = config.kernel_size * config.input_feature_channels * config.output_feature_channels;
-    int sum = w_size + config.output_feature_channels;
-    return (DefaultWeightsSize) { .w = w_size, .b = config.output_feature_channels, .sum = sum };
-}
-
 Conv1d conv1d_create(Conv1dConfig config) {
     Conv1d filter = malloc(sizeof(struct Conv1dStruct));
     filter->config = config;
-    filter->weights = malloc(sizeof(ConvWeights));
-    int W_size = config.kernel_size * config.input_feature_channels * config.output_feature_channels;
-    int weights_size = W_size + config.output_feature_channels;
-    filter->weights->W = f_malloc(weights_size);
-    filter->weights->b = filter->weights->W + W_size;
+    filter->weights = default_weights_create(conv1d_weight_size_from_config(config));
     filter->training_data = NULL;
     filter->inference_data = NULL;
     return filter;
@@ -146,19 +155,13 @@ int Conv1dApplyInference(Conv1d filter, const float *input, float *output) {
 }
 
 ConvGradient *Conv1dCreateGradient(Conv1dConfig config, ConvTrainingConfig training_config) {
-    ConvGradient *gradient = malloc(sizeof(ConvGradient));
-    int d_x_size = config.input_size * config.input_feature_channels * training_config.mini_batch_size;
-    int d_w_size = config.input_feature_channels * config.output_feature_channels * config.kernel_size * training_config.mini_batch_size;
-    int grad_size = d_x_size + d_w_size + config.output_feature_channels * training_config.mini_batch_size;
-    gradient->d_W = f_malloc(grad_size);
-    gradient->d_X = gradient->d_W + d_w_size;
-    gradient->d_b = gradient->d_X + d_x_size;
-    return gradient;
+    return default_gradient_create(conv1d_weight_size_from_config(config),
+                                   training_config.mini_batch_size *
+                                   config.input_size * config.input_feature_channels);
 }
 
 void ConvGradientDestroy(ConvGradient *gradient) {
-    free(gradient->d_W);
-    free(gradient);
+    default_gradient_destroy(gradient);
 }
 
 int Conv1dApplyTrainingBatch(Conv1d filter, const float *input, float *output) {
@@ -181,9 +184,9 @@ int Conv1dApplyTrainingBatch(Conv1d filter, const float *input, float *output) {
 
 void Conv1dCalculateGradient(Conv1d filter, ConvGradient *gradient, const float *d_out) {
     int db_size = filter->config.output_feature_channels *
-    filter->training_data->config.mini_batch_size;
-    for (int o = 0; o < filter->config.output_size; ++o){
-        op_vec_add(gradient->d_b, d_out + o * db_size, gradient->d_b, db_size);
+                  filter->training_data->config.mini_batch_size;
+    for (int o = 0; o < filter->config.output_size; ++o) {
+        op_vec_add(gradient->d_b,d_out + o * db_size, gradient->d_b, db_size);
     }
 
 
@@ -225,7 +228,7 @@ void Conv1dCalculateGradient(Conv1d filter, ConvGradient *gradient, const float
 
                     float d_kernel[k_size];
                     op_vec_mul_sc(row_ptr, d_o, d_kernel, k_size);
-                    float *d_W = gradient->d_W + W_size * b + weights_offset;
+                    float *d_W = filter->training_data->batch_gradients[b]->d_W + weights_offset;
                     op_vec_add(d_W, d_kernel, d_W, k_size);
 
                     // d_X;
@@ -239,6 +242,7 @@ void Conv1dCalculateGradient(Conv1d filter, ConvGradient *gradient, const float
         }
         op_mat_transp(d_x_transposed + b * inp_size, gradient->d_X + b * inp_size, filter->config.input_size, in_ftrs);
     }
+
 }
 
 

nntoolkitcore/layers/recurrent.c

@@ -0,0 +1,23 @@
+//
+// Created by Alex on 28.11.2020.
+//
+#include "recurrent.h"
+#include "nntoolkitcore/layers/private/recurrent_private.h"
+
+RecurrentConfig RecurrentConfigCreate(
+        int input_feature_channels,
+        int output_feature_channels,
+        bool return_sequences,
+        int timesteps
+) {
+    return (RecurrentConfig) {
+            .input_feature_channels = input_feature_channels,
+            .timesteps = timesteps,
+            .return_sequences = return_sequences,
+            .output_feature_channels = output_feature_channels
+    };
+}
+
+void RecurrentGradientDestroy(RecurrentGradient *gradient) {
+    recurrent_gradient_destroy(gradient);
+}

nntoolkitcore/layers/recurrent.h

@@ -46,21 +46,14 @@ typedef struct {
     float *d_X;
 } RecurrentGradient;
 
-
-
-inline static RecurrentConfig RecurrentConfigCreate(
-        int input_feature_channels,
-        int output_feature_channels,
-        bool return_sequences,
-        int timesteps
-) {
-    return (RecurrentConfig) {
-            .input_feature_channels = input_feature_channels,
-            .timesteps = timesteps,
-            .return_sequences = return_sequences,
-            .output_feature_channels = output_feature_channels
-    };
-}
+void RecurrentGradientDestroy(RecurrentGradient *gradient);
+
+RecurrentConfig RecurrentConfigCreate(
+    int input_feature_channels,
+    int output_feature_channels,
+    bool return_sequences,
+    int timesteps
+);
 
 #if defined __cplusplus
 }