added conv3d, pad3d, crop3d, upsample3d

f0uriest · f0uriest · commit dd5abd1659f9 · 2019-07-07T01:12:59.000-04:00
diff --git a/README.rst b/README.rst
@@ -14,7 +14,7 @@ It is designed to be as simple as possible for real time applications.
 Supported Layers
 ****************
 - **Core Layers**: Dense, Activation, Dropout, Flatten, Input, Reshape, Permute, RepeatVector,  ActivityRegularization, SpatialDropout1D, SpatialDropout2D, SpatialDropout3D
-- **Convolution Layers**: Conv1D, Conv2D, Cropping1D, Cropping2D, UpSampling1D, UpSampling2D, ZeroPadding1D, ZeroPadding2D
+- **Convolution Layers**: Conv1D, Conv2D, Conv3D, Cropping1D, Cropping2D, Cropping3D, UpSampling1D, UpSampling2D, UpSampling3D, ZeroPadding1D, ZeroPadding2D, ZeroPadding3D
 - **Pooling Layers**: MaxPooling1D, MaxPooling2D, AveragePooling1D, AveragePooling2D, GlobalMaxPooling1D, GlobalAveragePooling1D, GlobalMaxPooling2D, GlobalAveragePooling2D, GlobalMaxPooling3D,GlobalAveragePooling3D
 - **Recurrent Layers**: SimpleRNN, GRU, LSTM, SimpleRNNCell, GRUCell, LSTMCell
 - **Embedding Layers**: Embedding
@@ -26,7 +26,7 @@ Supported Layers
 ToDo
 ****
 - **Core Layers**: Lambda, Masking
-- **Convolution Layers**: SeparableConv1D, SeparableConv2D, DepthwiseConv2D, Conv2DTranspose, Conv3D, Conv3DTranspose, Cropping3D, UpSampling3D, ZeroPadding3D
+- **Convolution Layers**: SeparableConv1D, SeparableConv2D, DepthwiseConv2D, Conv2DTranspose, Conv3DTranspose
 - **Pooling Layers**: MaxPooling3D, AveragePooling3D
 - **Locally Connected Layers**: LocallyConnected1D, LocallyConnected2D
 - **Recurrent Layers**: ConvLSTM2D, ConvLSTM2DCell
diff --git a/include/k2c_convolution_layers.h b/include/k2c_convolution_layers.h
@@ -51,14 +51,53 @@ void k2c_pad2d(k2c_tensor* output, k2c_tensor* input, float fill, size_t pad[])
       output->array[i] = fill;}
   }
   // memcpy the old array in the middle
-  size_t offset = in_channels*(pad_left+pad_right+in_width)*pad_top + in_channels*pad_left;
+  size_t offset = in_channels*(pad_left+pad_right+in_width)*pad_top +
+    in_channels*pad_left;
   size_t num = in_channels*in_width;
   for (size_t i=0; i<in_height; i++) {
-    memcpy(&output->array[offset],&input->array[i*num],num*sizeof(input->array[0]));
+    memcpy(&output->array[offset],
+	   &input->array[i*num],
+	   num*sizeof(input->array[0]));
     offset += num+in_channels*(pad_left+pad_right);
   }
 }
 
+void k2c_pad3d(k2c_tensor* output, k2c_tensor* input, float fill, size_t pad[]) {
+
+  size_t dim1 = input->shape[0];
+  size_t dim2 = input->shape[1];
+  size_t dim3 = input->shape[2];
+  size_t outdim1 = dim1 + pad[0] + pad[1];
+  size_t outdim2 = dim2 + pad[2] + pad[3];
+  size_t outdim3 = dim3 + pad[4] + pad[5];
+  size_t in_channels = input->shape[3];
+
+  // set output array to fill value
+  if (fabs(fill) < 1e-6) {
+    // fill is ~zero, use memset
+    memset(output->array,0,output->numel*sizeof(output->array[0]));
+  }
+  else {
+    for(size_t i=0; i<output->numel; i++) {
+      output->array[i] = fill;}
+  }
+  // memcpy the old array in the middle
+  size_t offset1 = in_channels*(outdim2*outdim3)*pad[0] + in_channels*outdim3*pad[2] + in_channels*pad[4];
+  size_t num = in_channels*dim3;
+  size_t outstep2 = num+in_channels*(pad[4]+pad[5]);
+  size_t outstep1 = outdim2*outdim3*in_channels;
+  size_t instep1 = dim2*dim3*in_channels;
+  size_t instep2 = dim3*in_channels;
+
+  for (size_t i=0; i<dim1; i++) {
+    for (size_t j=0; j<dim2; j++) {
+    memcpy(&output->array[offset1+i*outstep1 + j*outstep2],
+	   &input->array[i*instep1+j*instep2],
+	   num*sizeof(input->array[0]));
+    }
+  }
+}
+
 void k2c_conv1d(k2c_tensor* output, k2c_tensor* input, k2c_tensor* kernel,
 		k2c_tensor* bias, size_t stride, size_t dilation,
 		   void (*activation) (float[], size_t)) {
@@ -108,7 +147,8 @@ void k2c_conv2d(k2c_tensor* output, k2c_tensor* input, k2c_tensor* kernel,
 	    for (size_t q=0; q < in_channels; q++) {
 	      size_t outsub[K2C_MAX_NDIM] = {x0,x1,k};
 	      size_t inpsub[K2C_MAX_NDIM] = {x0*stride[0] + dilation[0]*z0,
-					     x1*stride[1] + dilation[1]*z1,q};
+					     x1*stride[1] + dilation[1]*z1,
+					     q};
 	      size_t kersub[K2C_MAX_NDIM] = {z0,z1,q,k};
 	      output->array[k2c_sub2idx(outsub,output->shape,output->ndim)] +=
 		kernel->array[k2c_sub2idx(kersub,kernel->shape,kernel->ndim)]*
@@ -123,6 +163,47 @@ void k2c_conv2d(k2c_tensor* output, k2c_tensor* input, k2c_tensor* kernel,
   activation(output->array,output->numel);
 }
 
+void k2c_conv3d(k2c_tensor* output, k2c_tensor* input, k2c_tensor* kernel,
+		k2c_tensor* bias, size_t stride[], size_t dilation[],
+		   void (*activation) (float[], size_t)) {
+  /* 3D (spatial) convolution. Assumes a "channels last" structure
+   */
+  memset(output->array,0,output->numel*sizeof(output->array[0]));
+  size_t dim1 = output->shape[0];
+  size_t dim2 = output->shape[1];
+  size_t dim3 = output->shape[2];
+  size_t out_channels = output->shape[3];
+  size_t in_channels = input->shape[3];
+
+  for (size_t x0=0; x0 < dim1; x0++){
+    for (size_t x1=0; x1 < dim2; x1++) {
+      for (size_t x2=0; x2<dim3; x2++) {
+	for (size_t k=0; k < out_channels; k++) {
+	  for (size_t z0=0; z0 < kernel->shape[0]; z0++) {
+	    for (size_t z1=0; z1 < kernel->shape[1]; z1++) {
+	      for (size_t z2=0; z2 < kernel->shape[2]; z2++) {	      
+		for (size_t q=0; q < in_channels; q++) {
+		  size_t outsub[K2C_MAX_NDIM] = {x0,x1,x2,k};
+		  size_t inpsub[K2C_MAX_NDIM] = {x0*stride[0] + dilation[0]*z0,
+						 x1*stride[1] + dilation[1]*z1,
+						 x2*stride[2] + dilation[2]*z2,
+						 q};
+		  size_t kersub[K2C_MAX_NDIM] = {z0,z1,z2,q,k};
+		  output->array[k2c_sub2idx(outsub,output->shape,output->ndim)] +=
+		    kernel->array[k2c_sub2idx(kersub,kernel->shape,kernel->ndim)]*
+		    input->array[k2c_sub2idx(inpsub,input->shape,input->ndim)];
+		}
+	      }
+	    }
+	  }
+	}
+      }
+    }
+  }
+  k2c_bias_add(output,bias);
+  activation(output->array,output->numel);
+}
+
 void k2c_crop1d(k2c_tensor* output, k2c_tensor* input, size_t crop[]) {
 
   size_t offset = crop[0]*input->shape[1];
@@ -147,6 +228,33 @@ void k2c_crop2d(k2c_tensor* output, k2c_tensor* input, size_t crop[]) {
   }
 }
 
+void k2c_crop3d(k2c_tensor* output, k2c_tensor* input, size_t crop[]) {
+
+  size_t dim1 = input->shape[0];
+  size_t dim2 = input->shape[1];
+  size_t dim3 = input->shape[2];
+  size_t outdim1 = dim1 - crop[0] - crop[1];
+  size_t outdim2 = dim2 - crop[2] - crop[3];
+  size_t outdim3 = dim3 - crop[4] - crop[5];
+  size_t in_channels = input->shape[3];
+
+  size_t offset1 = in_channels*(dim2*dim3)*crop[0] +
+    in_channels*dim3*crop[2] + in_channels*crop[4];
+  size_t num = in_channels*outdim3;
+  size_t instep2 = num+in_channels*(crop[4]+crop[5]);
+  size_t instep1 = dim2*dim3*in_channels;
+  size_t outstep1 = outdim2*outdim3*in_channels;
+  size_t outstep2 = outdim3*in_channels;
+
+  for (size_t i=0; i<outdim1; i++) {
+    for (size_t j=0; j<outdim2; j++) {
+    memcpy(&output->array[i*outstep1 + j*outstep2],
+	   &input->array[offset1+i*instep1+j*instep2],
+	   num*sizeof(input->array[0]));
+    }
+  }
+}
+
 void k2c_upsampling1d(k2c_tensor* output, k2c_tensor* input, size_t size) {
 
   size_t in_height = input->shape[0];
@@ -178,6 +286,24 @@ void k2c_upsampling2d(k2c_tensor* output, k2c_tensor* input, size_t size[]) {
   }
 }
       
+void k2c_upsampling3d(k2c_tensor* output, k2c_tensor* input, size_t size[]) {
 
+  size_t dim1 = output->shape[0];
+  size_t dim2 = output->shape[1];
+  size_t dim3 = output->shape[2];
+  size_t channels = input->shape[3];
+  
+  for (size_t i=0; i<dim1; i++) {
+    for (size_t j=0; j<dim2; j++) {
+      for (size_t k=0; k<dim3; k++) {
+	size_t insub[K2C_MAX_NDIM] = {i/size[0],j/size[1],k/size[2],0};
+	size_t outsub[K2C_MAX_NDIM] = {i,j,k,0};
+	memcpy(&output->array[k2c_sub2idx(outsub,output->shape,output->ndim)],
+	       &input->array[k2c_sub2idx(insub,input->shape,input->ndim)],
+	       channels*sizeof(input->array[0]));
+      }
+    }
+  }
+}
 
 #endif /* KERAS2C_CONVOLUTION_LAYERS_H */
diff --git a/keras2c/layer2c.py b/keras2c/layer2c.py
@@ -106,6 +106,8 @@ def write_layer_Conv(self, layer, inputs, outputs, i):
             fname = 'k2c_conv1d('
         elif layer_type(layer)[-2:] == '2D':
             fname = 'k2c_conv2d('
+        elif layer_type(layer)[-2:] == '3D':
+            fname = 'k2c_conv3d('
         if layer.get_config()['padding'] == 'valid':
             self.layers += fname + outputs + ',' + inputs + ',' + \
                 pnm + '_kernel, \n\t' + pnm + '_bias,' + nm + \
@@ -124,6 +126,9 @@ def write_layer_Conv1D(self, layer, inputs, outputs, i):
     def write_layer_Conv2D(self, layer, inputs, outputs, i):
         self.write_layer_Conv(layer, inputs, outputs, i)
 
+    def write_layer_Conv3D(self, layer, inputs, outputs, i):
+        self.write_layer_Conv(layer, inputs, outputs, i)
+
     def write_layer_MaxPooling1D(self, layer, inputs, outputs, i):
         self.write_layer_Pooling(layer, inputs, outputs, i)
 
@@ -388,6 +393,9 @@ def write_layer_UpSampling1D(self, layer, inputs, outputs, i):
     def write_layer_UpSampling2D(self, layer, inputs, outputs, i):
         self.write_layer_UpSampling(layer, inputs, outputs, i)
 
+    def write_layer_UpSampling3D(self, layer, inputs, outputs, i):
+        self.write_layer_UpSampling(layer, inputs, outputs, i)
+
     def write_layer_UpSampling(self, layer, inputs, outputs, i):
         nm, _, inputs, outputs = self.format_io_names(
             layer, inputs, outputs)
@@ -405,6 +413,9 @@ def write_layer_Cropping1D(self, layer, inputs, outputs, i):
     def write_layer_Cropping2D(self, layer, inputs, outputs, i):
         self.write_layer_Cropping(layer, inputs, outputs, i)
 
+    def write_layer_Cropping3D(self, layer, inputs, outputs, i):
+        self.write_layer_Cropping(layer, inputs, outputs, i)
+
     def write_layer_Cropping(self, layer, inputs, outputs, i):
         nm, _, inputs, outputs = self.format_io_names(
             layer, inputs, outputs)
@@ -422,6 +433,9 @@ def write_layer_ZeroPadding1D(self, layer, inputs, outputs, i):
     def write_layer_ZeroPadding2D(self, layer, inputs, outputs, i):
         self.write_layer_ZeroPad(layer, inputs, outputs, i)
 
+    def write_layer_ZeroPadding3D(self, layer, inputs, outputs, i):
+        self.write_layer_ZeroPad(layer, inputs, outputs, i)
+
     def write_layer_ZeroPad(self, layer, inputs, outputs, i):
         if 'Zero' in layer_type(layer):
             nm, _, inputs, outputs = self.format_io_names(
diff --git a/keras2c/weights2c.py b/keras2c/weights2c.py
@@ -6,7 +6,7 @@
 # imports
 import numpy as np
 from keras2c.io_parsing import layer_type, get_layer_io_names, get_model_io_names
-maxndim = 4
+maxndim = 5
 
 
 __author__ = "Rory Conlin"
@@ -322,6 +322,50 @@ def write_weights_Conv2D(self, layer):
         self.write_weights_array2c(bias, layer.name + '_bias')
         self.stack_vars += '\n \n'
 
+    def write_weights_Conv3D(self, layer):
+        padding = layer.get_config()['padding']
+        stride = layer.get_config()['strides']
+        dilation = layer.get_config()['dilation_rate']
+        kernel_size = layer.get_config()['kernel_size']
+        self.stack_vars += 'size_t ' + layer.name + \
+            '_stride[3] = {' + ','.join([str(i) for i in stride]) + '}; \n'
+        self.stack_vars += 'size_t ' + layer.name + \
+            '_dilation[3] = {' + ','.join([str(i)
+                                           for i in dilation]) + '}; \n'
+        self.write_outputs(layer)
+        if padding == 'same':
+            inshp = layer.get_input_at(0).shape[1:]
+            pad_along_height = dilation[0]*(kernel_size[0]-1)
+            pad_top = int(pad_along_height // 2)
+            pad_bottom = int(pad_along_height - pad_top)
+            pad_along_width = dilation[1]*(kernel_size[1]-1)
+            pad_left = pad_along_width//2
+            pad_right = pad_along_width - pad_left
+            pad_along_depth = dilation[1]*(kernel_size[1]-1)
+            pad_front = pad_along_depth//2
+            pad_back = pad_along_depth - pad_front
+            padshp = (inshp[0]+pad_along_height,
+                      inshp[1]+pad_along_width,
+                      inshp[2]+pad_along_depth,
+                      inshp[3])
+            pad = [pad_top, pad_bottom, pad_left,
+                   pad_right, pad_front, pad_back]
+            self.write_weights_array2c(np.zeros(padshp), layer.name +
+                                       '_padded_input')
+            self.stack_vars += 'size_t ' + layer.name + \
+                '_pad[6] = {' + ','.join([str(i) for i in pad]) + '}; \n'
+            self.stack_vars += 'float ' + layer.name + '_fill = 0.0f; \n'
+
+        weights = layer.get_weights()
+        kernel = weights[0]
+        if layer.get_config()['use_bias']:
+            bias = weights[1]
+        else:
+            bias = np.zeros(kernel.shape[3])
+        self.write_weights_array2c(kernel, layer.name + '_kernel')
+        self.write_weights_array2c(bias, layer.name + '_bias')
+        self.stack_vars += '\n \n'
+
     def write_weights_MaxPooling1D(self, layer):
         return self.write_weights_Pooling1D(layer)
 
@@ -556,6 +600,14 @@ def write_weights_UpSampling2D(self, layer):
             ',' + str(size[1]) + '}; \n'
         self.stack_vars += '\n\n'
 
+    def write_weights_UpSampling3D(self, layer):
+        nm = layer.name
+        self.write_outputs(layer)
+        size = layer.get_config()['size']
+        self.stack_vars += 'size_t ' + nm + '_size[3] = {' + str(size[0]) + \
+            ',' + str(size[1]) + ',' + str(size[2]) + '}; \n'
+        self.stack_vars += '\n\n'
+
     def write_weights_Cropping1D(self, layer):
         nm = layer.name
         self.write_outputs(layer)
@@ -577,6 +629,20 @@ def write_weights_Cropping2D(self, layer):
             ',' + str(crop_right) + '}; \n'
         self.stack_vars += '\n\n'
 
+    def write_weights_Cropping3D(self, layer):
+        nm = layer.name
+        self.write_outputs(layer)
+        crop0 = layer.get_config()['cropping'][0][0]
+        crop1 = layer.get_config()['cropping'][0][1]
+        crop2 = layer.get_config()['cropping'][1][0]
+        crop3 = layer.get_config()['cropping'][1][1]
+        crop4 = layer.get_config()['cropping'][2][0]
+        crop5 = layer.get_config()['cropping'][2][1]
+        self.stack_vars += 'size_t ' + nm + '_crop[6] = {' + str(crop0) + ','\
+            + str(crop1) + ',' + str(crop2) + ',' + str(crop3) + \
+            ',' + str(crop4) + ',' + str(crop5) + '}; \n'
+        self.stack_vars += '\n\n'
+
     def write_weights_ZeroPadding1D(self, layer):
         nm = layer.name
         self.write_outputs(layer)
@@ -600,6 +666,21 @@ def write_weights_ZeroPadding2D(self, layer):
         self.stack_vars += 'float ' + nm + '_fill = 0.0f; \n'
         self.stack_vars += '\n\n'
 
+    def write_weights_ZeroPadding3D(self, layer):
+        nm = layer.name
+        self.write_outputs(layer)
+        pad0 = layer.get_config()['padding'][0][0]
+        pad1 = layer.get_config()['padding'][0][1]
+        pad2 = layer.get_config()['padding'][1][0]
+        pad3 = layer.get_config()['padding'][1][1]
+        pad4 = layer.get_config()['padding'][2][0]
+        pad5 = layer.get_config()['padding'][2][1]
+        self.stack_vars += 'size_t ' + nm + '_pad[6] = {' + str(pad0) + ','\
+            + str(pad1) + ',' + str(pad2) + ',' + str(pad3) + \
+            ',' + str(pad4) + ',' + str(pad5) + '}; \n'
+        self.stack_vars += 'float ' + nm + '_fill = 0.0f; \n'
+        self.stack_vars += '\n\n'
+
     def write_weights_ActivityRegularization(self, layer):
         # no weights needed
         pass
diff --git a/scratch/scratch.ipynb b/scratch/scratch.ipynb
diff --git a/tests/test_convolution_layers.py b/tests/test_convolution_layers.py
