initial commit

Author: hepheir

IEC_extra.py

@@ -0,0 +1,24 @@
+import tensorflow as tf
+
+def edge_cha(x_image):
+    out=tf.image.sobel_edges(x_image)
+    return out
+
+def intensity_cha(x_image):
+    out=tf.image.rgb_to_grayscale(x_image)
+    return out
+
+def color_cha(x_image):
+    R_filter = tf.constant([[[1, 0, 0]]])
+    G_filter = tf.constant([[[0, 1, 0]]])
+    B_filter = tf.constant([[[0, 0, 1]]])
+    R = tf.nn.conv2d(x_image, R_filter, strides=[1, 1, 1, 1], padding='SAME')
+    G = tf.nn.conv2d(x_image, G_filter, strides=[1, 1, 1, 1], padding='SAME')
+    B = tf.nn.conv2d(x_image, R_filter, strides=[1, 1, 1, 1], padding='SAME')
+    Y=((R+G)/2)-B
+    #r-g
+    RG=tf.abs(R-G)
+    BY=tf.abs(B-Y)
+    C_out=tf.add(RG,BY)
+    return C_out
+

csdn.py

@@ -0,0 +1,35 @@
+import tensorflow as tf
+
+def CSDN(x_image,is_training) :
+
+    c_pyramid0 = tf.nn.conv2d(x_image,56, [3,3],stride=(1,1), padding='SAME')  # 28
+    c_pyramid0= tf.nn.relu(tf.layers.batch_normalization(c_pyramid0,training=is_training))
+    c_pyramid0 = tf.nn.conv2d(c_pyramid0, 1, [1, 1], stride=(1, 1), padding='SAME')  # 28
+    c_pyramid0 = tf.nn.relu(tf.layers.batch_normalization(c_pyramid0, training=is_training))
+
+
+    c_pyramid1 = tf.layers.conv2d_transpose(x_image, 56, [2, 2], strides=(2, 2), padding='SAME')  # 56
+    c_pyramid1=tf.nn.relu(tf.layers.batch_normalization(c_pyramid1, training=is_training))
+    c_pyramid1 = tf.nn.conv2d(c_pyramid1, 1, [2, 2], stride=(1, 1), padding='SAME')
+    c_pyramid1 = tf.nn.relu(tf.layers.batch_normalization(c_pyramid1, training=is_training))
+
+    c_pyramid2 = tf.layers.conv2d_transpose(x_image, 56, [3, 3], strides=(3, 3), padding='SAME')  # 84
+    c_pyramid2 = tf.nn.relu(tf.layers.batch_normalization(c_pyramid2, training=is_training))
+    c_pyramid2 = tf.nn.conv2d(c_pyramid2, 1, [3, 3], stride=(1, 1), padding='SAME')
+    c_pyramid2 = tf.nn.relu(tf.layers.batch_normalization(c_pyramid2, training=is_training))
+
+    c_pyramid3 = tf.layers.conv2d_transpose(x_image, 56, [4, 4], strides=(4, 4), padding='SAME')  # 112
+    c_pyramid3 = tf.nn.relu(tf.layers.batch_normalization(c_pyramid3, training=is_training))
+    c_pyramid3 = tf.nn.conv2d(c_pyramid3, 1, [4, 4], stride=(1, 1), padding='SAME')
+    c_pyramid3 = tf.nn.relu(tf.layers.batch_normalization(c_pyramid3, training=is_training))
+
+    # print(c_pyramid2.numpy())
+    c_pool0 = tf.nn.max_pool(c_pyramid3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')  # 56
+    c_pool1 = tf.nn.max_pool(c_pyramid2, ksize=[1, 3, 3, 1], strides=[1, 3, 3, 1], padding='SAME')  # 28
+    print(c_pool0)
+    c_sub0 = tf.abs((tf.subtract(c_pyramid0, c_pool1)))  # |28-28|
+    c_sub1 = tf.abs((tf.subtract(c_pyramid1, c_pool0)))  # |56-56|
+    c_sub1 = tf.nn.max_pool(c_sub1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')  # |28-28|
+    c_0 = tf.add(c_sub0, c_sub1)
+
+    return c_0

data_arg.py

@@ -0,0 +1,24 @@
+from keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img
+import glob,os
+datagen = ImageDataGenerator(
+        rotation_range=40,
+        width_shift_range=0.2,
+        height_shift_range=0.2,
+        shear_range=0.2,
+        zoom_range=0.2,
+        horizontal_flip=True,
+        fill_mode="nearest")
+os.chdir("dir")
+for file in glob.glob("jpg"):
+    img = load_img("./D41.jpg")
+    x = img_to_array(img)
+    x = x.reshape((1,) + x.shape)
+
+
+    i = 0
+    for batch in datagen.flow(x, batch_size=1,
+                              save_to_dir="preview", save_prefix="1", save_format="jpeg"):
+        i += 1
+        if i > 20:
+            break  # generate image
+

end to CNN.py

@@ -0,0 +1,138 @@
+import tensorflow as tf
+from csdn import csdn
+from IEC_extrc import edge_chan,intensive_chan,color_chan
+
+def end_to_CNN(x,batch_prob):
+    with tf.name_scope("convolutional_base"):
+        x_image = x
+        I = intensity_cha(x_image)
+        C = color_cha(ximage)
+        E = edge_cha(image)
+
+        i_C = csdn(I)  # CSDN Block 0#
+        e_C = csdn(E)  # CSDN Blok 1#
+        c_C = csdn(C)  # CSDN Block 2#
+
+        Feature_IE = tf.concat([i_C, e_C], 2)
+        Feature_IEC = tf.concat(Feature_IE, c_C, 2)
+
+        SM = tf.nn.conv2d(Feature_IEC, 1, [1, 1], stride=(1, 1), padding='SAME')
+        SM = tf.nn.relu(tf.layers.batch_normalization(c_pyramid2, training=is_training))  # Saliency Map
+
+       out_channel= tf.concat(x_image, SM)
+    return out_channel
+
+def CNN(x,batch_prob):
+    gamma = 0.01
+   # batch_prob = tf.placeholder(tf.bool)
+
+    x_image = tf.reshape(x, [-1, 32, 32, 1])
+    with tf.name_scope("convolutional_base"):
+
+      #block1
+        W_conv1 = tf.Variable(tf.truncated_normal(shape=[7, 7, 1, 128], stddev=5e-2),name='w1')
+        b_conv1 = tf.Variable(tf.constant(0.1, shape=[128]),name='b1')
+        h_conv1 = tf.nn.conv2d(x_image, W_conv1, strides=[1, 1, 1, 1], padding='SAME') + b_conv1
+        h_conv1 = tf.layers.batch_normalization(h_conv1, center=True, scale=True, training=batch_prob, name='bn1')
+        h_relu1=tf.nn.relu(h_conv1)
+
+        l2_loss_W = gamma * tf.nn.l2_loss(W_conv1)
+
+        W_conv2 = tf.Variable(tf.truncated_normal(shape=[5, 5, 128, 128], stddev=5e-2),name='w2')
+        b_conv2 = tf.Variable(tf.constant(0.1, shape=[128]),name='b2')
+        h_conv2 = tf.nn.conv2d(h_relu1, W_conv2, strides=[1, 1, 1, 1], padding='SAME') + b_conv1
+        h_conv2 = tf.layers.batch_normalization(h_conv2, center=True, scale=True, training=batch_prob,name='bn2')
+        h_relu2 = tf.nn.relu(h_conv2)
+
+        l2_loss_W = + gamma * tf.nn.l2_loss(W_conv2)
+
+        W_conv3 = tf.Variable(tf.truncated_normal(shape=[1, 1, 128, 64], stddev=5e-2),name='w3')
+        b_conv3 = tf.Variable(tf.constant(0.1, shape=[64]),name='b2')
+        h_conv3 = tf.nn.conv2d(h_relu2, W_conv3, strides=[1, 1, 1, 1], padding='SAME') + b_conv1
+        h_conv3 = tf.layers.batch_normalization(h_conv3, center=True, scale=True, training=batch_prob,name='bn2')
+        h_relu3 = tf.nn.relu(h_conv3)
+
+        l2_loss_W = + gamma * tf.nn.l2_loss(W_conv3)
+
+        h_pool1 = tf.nn.max_pool(h_relu3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
+        h_drop1=tf.nn.dropout(h_pool1, rate=0.4)
+
+        #block 2
+        W_conv4 = tf.Variable(tf.truncated_normal(shape=[3, 3, 64, 64], stddev=5e-2),name='w4')
+        b_conv4 = tf.Variable(tf.constant(0.1, shape=[64]),name='b4')
+        h_conv4 = tf.nn.conv2d(h_drop1, W_conv4, strides=[1, 1, 1, 1], padding='SAME') + b_conv1
+        h_conv4 = tf.layers.batch_normalization(h_conv4, center=True, scale=True, training=batch_prob,name='bn4')
+        h_relu4 = tf.nn.relu(h_conv4)
+
+        l2_loss_W = + gamma * tf.nn.l2_loss(W_conv4)
+
+        W_conv5 = tf.Variable(tf.truncated_normal(shape=[3, 3, 64, 64], stddev=5e-2),name='w5')
+        b_conv5 = tf.Variable(tf.constant(0.1, shape=[64]),name='b5')
+        h_conv5 = tf.nn.conv2d(h_relu4, W_conv5, strides=[1, 1, 1, 1], padding='SAME') + b_conv1
+        h_conv5 = tf.layers.batch_normalization(h_conv5, center=True, scale=True, training=batch_prob,name='bn5')
+        h_relu5 = tf.nn.relu(h_conv5)
+        l2_loss_W = + gamma * tf.nn.l2_loss(W_conv5)
+
+        W_conv6 = tf.Variable(tf.truncated_normal(shape=[1, 1, 64, 32], stddev=5e-2),name='w6')
+        b_conv6 = tf.Variable(tf.constant(0.1, shape=[32]),name='b6')
+        h_conv6 = tf.nn.conv2d(h_relu5, W_conv6, strides=[1, 1, 1, 1], padding='SAME') + b_conv1
+        h_conv6 = tf.layers.batch_normalization(h_conv6, center=True, scale=True, training=batch_prob,name='bn6')
+        h_relu6 = tf.nn.relu(h_conv6)
+        l2_loss_W = + gamma * tf.nn.l2_loss(W_conv6)
+
+        h_pool2 = tf.nn.max_pool(h_relu6, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
+        h_drop2=tf.nn.dropout(h_pool2, rate=0.4)
+
+        #block3
+
+        W_conv7 = tf.Variable(tf.truncated_normal(shape=[3, 3, 32, 32], stddev=5e-2),name='w7')
+        b_conv7 = tf.Variable(tf.constant(0.1, shape=[32]),name='b7')
+        h_conv7 = tf.nn.conv2d(h_drop2, W_conv7, strides=[1, 1, 1, 1], padding='SAME') + b_conv1
+        h_conv7 = tf.layers.batch_normalization(h_conv7, center=True, scale=True, training=batch_prob,name='bn7')
+        h_relu7 = tf.nn.relu(h_conv7)
+
+        l2_loss_W = + gamma * tf.nn.l2_loss(W_conv7)
+
+        W_conv8 = tf.Variable(tf.truncated_normal(shape=[3, 3, 32, 32], stddev=5e-2),name='w8')
+        b_conv8 = tf.Variable(tf.constant(0.1, shape=[32]),name='b8')
+        h_conv8 = tf.nn.conv2d(h_relu7, W_conv8, strides=[1, 1, 1, 1], padding='SAME') + b_conv1
+        h_conv8 = tf.layers.batch_normalization(h_conv8, center=True, scale=True, training=batch_prob,name='bn8')
+        h_relu8 = tf.nn.relu(h_conv8)
+
+        l2_loss_W = + gamma * tf.nn.l2_loss(W_conv8)
+
+        W_conv9 = tf.Variable(tf.truncated_normal(shape=[1, 1, 32, 32], stddev=5e-2),name='w9')
+        b_conv9 = tf.Variable(tf.constant(0.1, shape=[32]),name='b9')
+        h_conv9 = tf.nn.conv2d(h_relu8, W_conv9, strides=[1, 1, 1, 1], padding='SAME') + b_conv1
+        h_conv9 = tf.layers.batch_normalization(h_conv9, center=True, scale=True, training=batch_prob,name='bn9')
+        h_relu9 = tf.nn.relu(h_conv8)
+
+        l2_loss_W = + gamma * tf.nn.l2_loss(W_conv9)
+
+        h_pool3 = tf.nn.max_pool(h_relu9, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
+        h_drop3= tf.nn.dropout(h_pool3, rate=0.4)
+    train_vars = {'w1': W_conv1, 'b1': b_conv1, 'bn1':h_conv1, 'w2': W_conv2, 'b2': b_conv2, 'bn1': h_conv2 }
+    for key, var in train_vars.items():
+        tf.add_to_collection(key, var)
+
+    with tf.name_scope("classifier"):
+
+        W_fc1 = tf.Variable(tf.truncated_normal(shape=[4 * 4 * 32, 256], stddev=5e-2))
+        b_fc1 = tf.Variable(tf.constant(0.1, shape=[6096]))
+        h_pool2_flat = tf.reshape(h_drop3, [-1, 28 * 28 * 128])
+        h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
+
+        l2_loss_W = + gamma * tf.nn.l2_loss(W_fc1)
+
+        # Output Layer
+
+        W_output = tf.Variable(tf.truncated_normal(shape=[1024, 100], stddev=5e-2))
+        b_output = tf.Variable(tf.constant(0.1, shape=[2]))
+        logits = tf.matmul(h_fc1, W_output) + b_output
+        y_pred = tf.nn.softmax(logits)
+
+        l2_loss_W = + gamma * tf.nn.l2_loss(W_output)
+
+
+
+    return y_pred, logits, l2_loss_W,h_pool3,train_vars