minor things;

Author: Oleksii Moiseenko

NNToolkitCore.podspec

@@ -25,8 +25,7 @@ Pod::Spec.new do |s|
   s.source_files =
       'nntoolkitcore/core/*.h',
       'nntoolkitcore/core/debug.c',
-#       'nntoolkitcore/core/apple_ops.c',
-      'nntoolkitcore/core/default_ops.cc',
+      'nntoolkitcore/core/apple_ops.c',
       'nntoolkitcore/core/memory.c',
       'nntoolkitcore/layers/**/*',
       'nntoolkitcore/train/*.{h,c}',

nntoolkitcore/layers/conv_1d.c

@@ -183,11 +183,6 @@ 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);
-//    }
     int k_size = filter->config.kernel_size;
     int batch = filter->training_data->config.mini_batch_size;
     int in_ftrs = filter->config.input_feature_channels;

nntoolkitcore/layers/dense.c

@@ -103,6 +103,14 @@ DenseGradient *DenseGradientCreate(DenseConfig config, DenseTrainingConfig train
     );
 }
 
+DenseGradient *DenseGradientCreateFromFilter(Dense dense) {
+    if (dense->training_data == NULL){
+        return NULL;
+    }
+    return DenseGradientCreate(dense->config, dense->training_data->config);
+}
+
+
 void DenseGradientDestroy(DenseGradient *gradient) {
     default_gradient_destroy(gradient);
 }
@@ -176,3 +184,4 @@ void DenseCalculateGradient(Dense filter, DenseGradient *gradient, float *d_out)
     default_gradient_sum(filter->training_data->batch_gradients, gradient, dense_weight_size_from_config(filter->config), batch);
 }
 
+

nntoolkitcore/layers/dense.h

@@ -36,6 +36,8 @@ void DenseGradientDestroy(DenseGradient *gradient);
 
 typedef struct DenseStruct* Dense;
 
+DenseGradient* DenseGradientCreateFromFilter(Dense dense);
+
 DenseWeights* DenseGetWeights(Dense filter);
 
 DenseConfig DenseConfigCreate(int input_size, int output_size, ActivationFunction activation);

nntoolkitcore/layers/time_distributed_dense.c

@@ -5,21 +5,13 @@
 //  Created by Alex on 21.10.2020.
 //
 
-#include <nntoolkitcore/core/memory.h>
 #include "nntoolkitcore/layers/time_distributed_dense.h"
-#include "nntoolkitcore/core/ops.h"
 #include "nntoolkitcore/core/loop.h"
 #include "stdlib.h"
 
 
-typedef struct  {
-    TimeDistributedDenseTrainingConfig config;
-    DenseTrainingConfig dense_config;
-} TimeDistributedDenseTrainingData;
-
 struct TimeDistributedDenseStruct {
     TimeDistributedDenseConfig config;
-    TimeDistributedDenseTrainingData *training_data;
     Dense dense;
 };
 
@@ -39,18 +31,13 @@ TimeDistributedDense TimeDistributedDenseCreate(TimeDistributedDenseConfig confi
 TimeDistributedDense TimeDistributedDenseCreateForInference(TimeDistributedDenseConfig config){
     TimeDistributedDense ts_filter = TimeDistributedDenseCreate(config);
     ts_filter->dense = DenseCreateForInference(config.dense);
-    ts_filter->training_data = NULL;
     return ts_filter;
 }
 
-
 TimeDistributedDense TimeDistributedDenseCreateForTraining(TimeDistributedDenseConfig config, TimeDistributedDenseTrainingConfig training_config) {
     TimeDistributedDense ts_filter = TimeDistributedDenseCreate(config);
     DenseTrainingConfig dense_training_config = DefaultTrainingConfigCreate(training_config.mini_batch_size * config.ts);
     ts_filter->dense = DenseCreateForTraining(config.dense, dense_training_config);
-    ts_filter->training_data = malloc(sizeof(TimeDistributedDenseTrainingData));
-    ts_filter->training_data->config = training_config;
-    ts_filter->training_data->dense_config = dense_training_config;
     return ts_filter;
 }
 
@@ -59,18 +46,10 @@ DenseWeights* TimeDistributedDenseGetWeights(TimeDistributedDense filter) {
 }
 
 DenseGradient* TimeDistributedDenseGradientCreate(TimeDistributedDense filter){
-    return DenseGradientCreate(
-            filter->config.dense,
-            DefaultTrainingConfigCreate(filter->config.ts *
-            filter->training_data->config.mini_batch_size
-            ));
+    return DenseGradientCreateFromFilter(filter->dense);
 }
 
-
 int TimeDistributedDenseApplyInference(TimeDistributedDense filter, const float *input, float* output){
-    if(filter->training_data != NULL){
-        return -1;
-    }
     P_LOOP_START(filter->config.ts, ts)
         DenseApplyInference(filter->dense, input + ts * filter->config.dense.input_size,
                                             output + ts * filter->config.dense.output_size);
@@ -79,11 +58,7 @@ int TimeDistributedDenseApplyInference(TimeDistributedDense filter, const float
 }
 
 int TimeDistributedDenseApplyTrainingBatch(TimeDistributedDense filter, const float *input, float* output){
-    if (filter->training_data == NULL){
-        return -1;
-    }
-    DenseApplyTrainingBatch(filter->dense, input, output);
-    return 0;
+    return DenseApplyTrainingBatch(filter->dense, input, output);
 }
 
 void TimeDistributedDenseCalculateGradient(TimeDistributedDense filter, DenseGradient *gradient, float *d_out){
@@ -93,4 +68,4 @@ void TimeDistributedDenseCalculateGradient(TimeDistributedDense filter, DenseGra
 void TimeDistributedDenseDestroy(TimeDistributedDense filter){
     DenseDestroy(filter->dense);
     free(filter);
-}
+}