Added good CNN workload and external way to visualize receptive field.

attempted several CNN apporaches. Keras work best.

Author: dyt811

CNN.py

@@ -22,7 +22,7 @@
 validation_size = 0.333333
 
 # Batch size
-batch_size = 16
+batch_size = 8
 
 # Image related properties
 num_channels = 3    # color chanels?
@@ -75,16 +75,28 @@
 """
 
 # Layer Paramemters:
-L1_filter = 32
+L1_filter = 128
 L1_convSize = 3
 
-L2_filter = 32
+L2_filter = 64
 L2_convSize = 3
 
-L3_filter = 64
+L3_filter = 32
 L3_convSize = 3
 
-FC1_size = 128
+L4_filter = 16
+L4_convSize = 3
+
+L5_filter = 8
+L5_convSize = 3
+
+L6_filter = 4
+L6_convSize = 3
+
+L7_filter = 2
+L7_convSize = 3
+
+FC1_size = 64
 
 
 """
@@ -107,8 +119,29 @@
                                              conv_filter_size   = L3_convSize,
                                              num_filters        = L3_filter)
 
+conv_stack4 = tfl.create_convolutional_stack(input              = conv_stack3,
+                                             num_input_channels = L3_filter,
+                                             conv_filter_size   = L4_convSize,
+                                             num_filters        = L4_filter)
+
+conv_stack5 = tfl.create_convolutional_stack(input              = conv_stack4,
+                                             num_input_channels  = L4_filter,
+                                             conv_filter_size   = L5_convSize,
+                                             num_filters        = L5_filter)
+
+conv_stack6 = tfl.create_convolutional_stack(input              = conv_stack5,
+                                             num_input_channels = L5_filter,
+                                             conv_filter_size   = L6_convSize,
+                                             num_filters        = L6_filter)
+
+conv_stack7 = tfl.create_convolutional_stack(input              = conv_stack6,
+                                             num_input_channels  = L6_filter,
+                                             conv_filter_size   = L7_convSize,
+                                             num_filters        = L7_filter)
+
+
 # Building the Flat Layers
-layer_flat = tfl.create_flatten_layer(conv_stack3)
+layer_flat = tfl.create_flatten_layer(conv_stack7)
 
 # Building the Fully Connected Layers
 fc_stack1 = tfl.create_fc_stack(input       = layer_flat,

CNN2.py

@@ -0,0 +1,56 @@
+import keras
+from keras.models import Sequential
+from keras.layers import Dense, Dropout, Flatten
+from keras.layers import Conv2D, MaxPooling2D
+import numpy as np
+
+batch size = 128
+num_classes = 2
+epochs = 12
+
+# input image dimensions
+img_rows, img_cols = 500, 500
+channels = 3
+fashion_mnist = keras.datasets.fashion_mnist
+
+# Data split:
+(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()
+
+x_train = x_train.reshape(300, img_rows, img_cols, 1)
+x_test = x_test.rehapse(300,img_rows, img_cols,1 )
+
+
+# Binary class matrix: y = [0, 1] would be no-marker when the classes are [marker, no-marker]
+y_train = keras.utils.to_categorical(y_train, num_classes)
+y_test = keras.utils.to_categorical(y_test, num_classes)
+
+model = Sequential()
+model.add(Conv2D(filters=32,
+                 kernel_size=(3,3),
+                 activation='relu',
+                 input_shape=(500,500,1)))
+model.add(MaxPooling2D(pool_size=(2,2),
+                       strides=2))
+model.add(Conv2D(filters=32,
+                 kernel_size=(3,3),
+                 activation='relu'))
+model.add(MaxPooling2D(pool_size=(2,2),
+                       strides=2))
+model.add(Dropout(0.25))
+model.add(Flatten())
+model.add(Dense(128, activation='relu'))
+model.add(Dropout(0.5))
+model.add(Dense(num_classes, activation='softmax'))
+
+model.compile(loss=keras.losses.categorical_crossentropy,
+              optimizer=keras.optimizers.adam,
+              metric=['accuracy']
+              )
+model.fit(x_train,y_train,
+          batch_size=batch_size,
+          epochs=epochs,
+          verbose=1,
+          validation_data=(x_test,y_test))
+score=model.evaluat(x_test,y_test,verbose=0)
+print('Test loss:', score[0])
+print('Test accurayc:', score[1])

CNN3.py

@@ -0,0 +1,82 @@
+from keras.models import Sequential
+from keras.layers import Dense, Conv2D, MaxPooling2D, Dropout, Flatten, Activation
+from keras.preprocessing.image import ImageDataGenerator
+from keras.callbacks import TensorBoard
+import keras
+import os
+from PythonUtils.file import unique_name
+def load_data_and_run(model,input_shape, TBCallBack):
+    train_data_loader = ImageDataGenerator()
+    train_data = train_data_loader.flow_from_directory(r"E:\Gitlab\MarkerTrainer\data_train",
+                                                       target_size=(input_shape,input_shape),
+                                                       batch_size=128,
+                                                       class_mode='binary')
+    validation_data_loader = ImageDataGenerator()
+    validation_data = validation_data_loader.flow_from_directory(r"E:\Gitlab\MarkerTrainer\data_validate",
+                                                       target_size=(input_shape, input_shape),
+                                                       batch_size=128,
+                                                       class_mode='binary')
+    model.fit_generator(
+            train_data,
+            steps_per_epoch=2500,
+            epochs=50,
+            validation_data=validation_data,
+            validation_steps=1250,
+            #callbacks=TBCallBack
+    )
+    model.save(os.path.join(r'E:\Gitlab\MarkerTrainer\models\\', unique_name()))
+
+def createModel(input_shape, output_classes):
+    model = Sequential()
+    model.add(Conv2D(16, (3, 3), padding='same', activation='relu', input_shape=(input_shape, input_shape, 3)))
+    model.add(Conv2D(16, (3, 3), activation='relu'))
+    model.add(MaxPooling2D(pool_size=(2, 2)))
+    model.add(Dropout(0.25))
+
+    model.add(Conv2D(32, (3, 3), padding='same', activation='relu'))
+    model.add(Conv2D(32, (3, 3), activation='relu'))
+    model.add(MaxPooling2D(pool_size=(2, 2)))
+    model.add(Dropout(0.25))
+
+    model.add(Conv2D(64, (3, 3), padding='same', activation='relu'))
+    model.add(Conv2D(64, (3, 3), activation='relu'))
+    model.add(MaxPooling2D(pool_size=(2, 2)))
+    model.add(Dropout(0.25))
+
+    model.add(Conv2D(128, (3, 3), padding='same', activation='relu'))
+    model.add(Conv2D(128, (3, 3), activation='relu'))
+    model.add(MaxPooling2D(pool_size=(2, 2)))
+    model.add(Dropout(0.25))
+
+    model.add(Conv2D(256, (3, 3), padding='same', activation='relu'))
+    model.add(Conv2D(256, (3, 3), activation='relu'))
+    model.add(MaxPooling2D(pool_size=(2, 2)))
+    model.add(Dropout(0.25))
+
+    model.add(Flatten())
+    model.add(Dense(512, activation='relu'))
+    model.add(Dropout(0.5))
+    model.add(Dense(output_classes))
+    model.add(Activation('softmax'))
+
+    # Param: 276138
+
+    return model
+
+if __name__ =="__main__":
+    from time import time
+    model1 = createModel(128, 2) # downsize to 128
+    model1.compile(loss="sparse_categorical_crossentropy", optimizer="adam")
+    TBCallBack = TensorBoard(log_dir=r'E:\Gitlab\MarkerTrainer\logs',
+                                             histogram_freq=0,
+                                             batch_size=32,
+                                             write_graph=True,
+                                             write_grads=True,
+                                             write_images=True,
+                                             embeddings_freq=0,
+                                             embeddings_layer_names=None,
+                                             embeddings_metadata=None,
+                                             embeddings_data=None,
+                                             update_freq='epoch')
+
+    load_data_and_run(model1, 128, TBCallBack)

ReceptiveFieldCalculator.py

@@ -0,0 +1,82 @@
+# [filter size, stride, padding]
+# Assume the two dimensions are the same
+# Each kernel requires the following parameters:
+# - k_i: kernel size
+# - s_i: stride
+# - p_i: padding (if padding is uneven, right padding will higher than left padding; "SAME" option in tensorflow)
+#
+# Each layer i requires the following parameters to be fully represented:
+# - n_i: number of feature (data layer has n_1 = imagesize )
+# - j_i: distance (projected to image pixel distance) between center of two adjacent features
+# - r_i: receptive field of a feature in layer i
+# - start_i: position of the first feature's receptive field in layer i (idx start from 0, negative means the center fall into padding)
+
+# Source: https://medium.com/mlreview/a-guide-to-receptive-field-arithmetic-for-convolutional-neural-networks-e0f514068807
+
+import math
+
+convnet = [[10, 4, 0], # [filter size, stride, padding]
+           [3, 2, 0], 
+           [5, 1, 2], 
+           [3, 2, 0], 
+           [3, 1, 1], 
+           [3, 1, 1], 
+           [3, 1, 1], 
+           [3, 2, 0], 
+           [6, 1, 0],
+           [1, 1, 0]]
+layer_names = ['conv1', 'pool1', 'conv2', 'pool2', 'conv3', 'conv4', 'conv5', 'pool5', 'fc6-conv', 'fc7-conv']
+imsize = 500
+
+
+def outFromIn(conv, layerIn):
+    n_in = layerIn[0]
+    j_in = layerIn[1]
+    r_in = layerIn[2]
+    start_in = layerIn[3]
+    k = conv[0]
+    s = conv[1]
+    p = conv[2]
+
+    n_out = math.floor((n_in - k + 2 * p) / s) + 1
+    actualP = (n_out - 1) * s - n_in + k
+    pR = math.ceil(actualP / 2)
+    pL = math.floor(actualP / 2)
+
+    j_out = j_in * s
+    r_out = r_in + (k - 1) * j_in
+    start_out = start_in + ((k - 1) / 2 - pL) * j_in
+    return n_out, j_out, r_out, start_out
+
+
+def printLayer(layer, layer_name):
+    print(layer_name + ":")
+    print("\t n features: %s \n \t jump: %s \n \t receptive size: %s \t start: %s " % (
+    layer[0], layer[1], layer[2], layer[3]))
+
+
+layerInfos = []
+if __name__ == '__main__':
+    # first layer is the data layer (image) with n_0 = image size; j_0 = 1; r_0 = 1; and start_0 = 0.5
+    print("-------Net summary------")
+    currentLayer = [imsize, 1, 1, 0.5]
+    printLayer(currentLayer, "input image")
+    for i in range(len(convnet)):
+        currentLayer = outFromIn(convnet[i], currentLayer)
+        layerInfos.append(currentLayer)
+        printLayer(currentLayer, layer_names[i])
+    print("------------------------")
+    layer_name = "conv1"
+    layer_idx = layer_names.index(layer_name)
+    idx_x = 99 #int(raw_input("index of the feature in x dimension (from 0)"))
+    idx_y = 98 #int(raw_input("index of the feature in y dimension (from 0)"))
+
+    n = layerInfos[layer_idx][0]
+    j = layerInfos[layer_idx][1]
+    r = layerInfos[layer_idx][2]
+    start = layerInfos[layer_idx][3]
+    assert (idx_x < n)
+    assert (idx_y < n)
+
+    print("receptive field: (%s, %s)" % (r, r))
+print("center: (%s, %s)" % (start + idx_x * j, start + idx_y * j))