Add files via upload

Author: Pyramiding

alexnet.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Apr  5 20:24:20 2018
+
+@author: wu
+"""
+
+import tensorflow as tf
+import numpy as np
+
+tf.reset_default_graph() 
+
+def maxPoolLayer(x, kHeight, kWidth, strideX, strideY, name, padding = "SAME"):
+    """max-pooling"""
+    return tf.nn.max_pool(x, ksize = [1, kHeight, kWidth, 1],
+                          strides = [1, strideX, strideY, 1], padding = padding, name = name)
+
+def dropout(x, keepPro, name = None):
+    """dropout"""
+    return tf.nn.dropout(x, keepPro, name)
+
+def LRN(x, R, alpha, beta, name = None, bias = 1.0):
+    """LRN"""
+    return tf.nn.local_response_normalization(x, depth_radius = R, alpha = alpha,
+                                              beta = beta, bias = bias, name = name)
+
+def fcLayer(x, inputD, outputD, reluFlag, name):
+    """fully-connect"""
+    with tf.variable_scope(name) as scope:
+        w = tf.get_variable("weights", shape = [inputD, outputD], dtype = "float")
+        b = tf.get_variable("biases", [outputD], dtype = "float")
+        out = tf.nn.xw_plus_b(x, w, b, name = scope.name)
+        if reluFlag:
+            return tf.nn.relu(out)
+        else:
+            return out
+
+def convLayer(x, kHeight, kWidth, strideX, strideY,
+              featureNum, name, padding = "SAME", groups = 1):
+    """convolution"""
+    channel = int(x.get_shape()[-1])
+    conv = lambda a, b: tf.nn.conv2d(a, b, strides = [1, strideY, strideX, 1], padding = padding)
+    with tf.variable_scope(name) as scope:
+        w = tf.get_variable("weights", shape = [kHeight, kWidth, channel/groups, featureNum])
+        b = tf.get_variable("biases", shape = [featureNum])
+
+        xNew = tf.split(value = x, num_or_size_splits = groups, axis = 3)
+        wNew = tf.split(value = w, num_or_size_splits = groups, axis = 3)
+
+        featureMap = [conv(t1, t2) for t1, t2 in zip(xNew, wNew)]
+        mergeFeatureMap = tf.concat(axis = 3, values = featureMap)
+        # print mergeFeatureMap.shape
+        out = tf.nn.bias_add(mergeFeatureMap, b)
+    return tf.nn.relu(tf.reshape(out, mergeFeatureMap.get_shape().as_list()), name = scope.name)
+
+def losses(logits, labels):
+    with tf.variable_scope("loss") as scope:
+        cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits,
+                                                                       labels=labels, name="xentropy_per_example")
+        loss = tf.reduce_mean(cross_entropy, name="loss")
+        tf.summary.scalar(scope.name + "loss", loss)
+    return loss
+
+
+def training(loss, learning_rate):
+    with tf.name_scope("optimizer"):
+        optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
+        global_step = tf.Variable(0, name="global_step", trainable=False)
+        train_op = optimizer.minimize(loss, global_step=global_step)
+    return train_op
+
+
+def evaluation(logits, labels):
+    with tf.variable_scope("accuracy") as scope:
+        correct = tf.nn.in_top_k(logits, labels, 1)
+        correct = tf.cast(correct, tf.float16)
+        accuracy = tf.reduce_mean(correct)
+        tf.summary.scalar(scope.name + "accuracy", accuracy)
+    return accuracy
+
+
+def Batch_Normalization(x):
+    """Batch Normalization layer"""
+    x_mean, x_var = tf.nn.moments(x, axes=[0]) 
+    scale = tf.Variable(tf.ones([4096]))
+    offset = tf.Variable(tf.zeros([4096]))
+    variance_epsilon = 0.001
+    BN_x = tf.nn.batch_normalization(x, x_mean, x_var, offset, scale, variance_epsilon)
+    return BN_x
+
+
+class alexNet(object):
+    """alexNet model"""
+    def __init__(self, x, keepPro=1.0, classNum=6, skip_layer=['conv5','fc6','fc7','fc8'], weights_path = 'DEFAULT'):
+        self.X = x
+        self.KEEPPRO = keepPro
+        self.CLASSNUM = classNum
+        self.SKIP_LAYER = skip_layer
+        self.WEIGHTS_PATH = weights_path
+        self.buildCNN()
+        
+        #fine-tune choice
+        if weights_path == 'DEFAULT':
+            self.WEIGHTS_PATH = '/home/wu/TF_Project/action/bvlc_alexnet.npy'
+            #self.WEIGHTS_PATH = '/home/wu/TF_Project/action/model_tfrecord_sample/model.ckpt-1000'
+        else:
+            self.WEIGHTS_PATH = weights_path
+   
+    def load_initial_weights(self, session):  
+        weights_dict = np.load(self.WEIGHTS_PATH, encoding = 'bytes').item()
+        for op_name in weights_dict:
+            if op_name not in self.SKIP_LAYER:
+                with tf.variable_scope(op_name, reuse = True):  
+                    for data in weights_dict[op_name]:            
+                        if len(data.shape) == 1:
+                            var = tf.get_variable('biases', trainable = False)
+                            session.run(var.assign(data))
+                        else:              
+                            var = tf.get_variable('weights', trainable = False)
+                            session.run(var.assign(data))
+    
+    def buildCNN(self):
+        """
+        input 100*100*3
+        conv1 23*23*96
+        pool1 11*11*96
+        conv2 11*11*256
+        pool2 5*5*256
+        conv3 5*5*384
+        conv4 5*5*384
+        conv5 5*5*256
+        pool5 2*2*256
+        fc1 1024->4096
+        fc2 4096->4096
+        fc3 4096->6
+        """
+        self.conv1 = convLayer(self.X, 11, 11, 4, 4, 96, "conv1", "VALID")
+        """
+        split = tf.split(self.conv1,num_or_size_splits=96,axis=3)
+        tf.summary.image("conv1_features",split[0],10)
+        """
+        lrn1 = LRN(self.conv1, 2, 2e-05, 0.75, "norm1")
+        pool1 = maxPoolLayer(lrn1, 3, 3, 2, 2, "pool1", "VALID")
+
+        conv2 = convLayer(pool1, 5, 5, 1, 1, 256, "conv2", groups = 2)
+        lrn2 = LRN(conv2, 2, 2e-05, 0.75, "lrn2")
+        pool2 = maxPoolLayer(lrn2, 3, 3, 2, 2, "pool2", "VALID")
+
+        conv3 = convLayer(pool2, 3, 3, 1, 1, 384, "conv3")
+
+        conv4 = convLayer(conv3, 3, 3, 1, 1, 384, "conv4", groups = 2)
+
+        conv5 = convLayer(conv4, 3, 3, 1, 1, 256, "conv5", groups = 2)
+        pool5 = maxPoolLayer(conv5, 3, 3, 2, 2, "pool5", "VALID")
+
+        fcIn = tf.reshape(pool5, [-1, 1024])
+        fc1 = fcLayer(fcIn, 1024, 4096, True, "fc6")
+        #dropout1 = dropout(fc1, self.KEEPPRO)
+        dropout1 = Batch_Normalization(fc1)
+
+        fc2 = fcLayer(dropout1, 4096, 4096, True, "fc7")
+        #dropout2 = dropout(fc2, self.KEEPPRO)
+        dropout2 = Batch_Normalization(fc2)
+
+        self.fc3 = fcLayer(dropout2, 4096, self.CLASSNUM, True, "fc8")
+

alexnet_feature_extractor.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sun Apr 15 19:42:31 2018
+
+@author: wu
+"""
+
+import tensorflow as tf
+import numpy as np
+import scipy.io as sio  
+import matplotlib.pyplot as plt
+import tfrecord
+import alexnet
+
+BATCH_SIZE=100
+IMG_W=100
+IMG_H=100
+
+train_filename = '/home/wu/TF_Project/action/sample_TFrecord/train1.tfrecords'
+#dir = '/home/wu/TF_Project/action/feature_tensorboard/'
+dir = '/home/wu/TF_Project/action/features/'
+train_img, train_label = tfrecord.read_and_decode(train_filename)
+train_batch, train_label_batch = tf.train.shuffle_batch([train_img, train_label],
+                                                batch_size = 100, num_threads=64,
+                                                capacity=2000,                                                
+                                                min_after_dequeue=1000)
+x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3])
+
+train_model = alexnet.alexNet(x)
+conv1_feature = train_model.conv1
+"""
+state = tf.Variable(0, name='counter')
+one = tf.constant(1)
+new_value = tf.add(state, one)
+update = tf.assign(state, new_value)
+"""
+with tf.Session() as sess:
+    sess.run(tf.global_variables_initializer())
+    coord = tf.train.Coordinator()
+    threads = tf.train.start_queue_runners(coord=coord,sess=sess)
+    
+    train_model.load_initial_weights(sess)
+    
+    #summary_op = tf.summary.merge_all()        
+    #writer = tf.summary.FileWriter(dir,sess.graph)
+    
+    params=tf.trainable_variables()
+    print("Trainable variables:------------------------")
+    for idx, v in enumerate(params):
+        print("  param {:3}: {:15}   {}".format(idx, str(v.get_shape()), v.name))
+    i = 0
+    try:  
+        while not coord.should_stop():      
+            tra_images,tra_labels = sess.run([train_batch, train_label_batch])
+            feature = sess.run(conv1_feature,feed_dict={x:tra_images})
+            dic1 = {'feature':feature}
+            sio.savemat(dir+str(i)+'_feature.mat',dic1) 
+            dic2 = {'label':tra_labels}
+            sio.savemat(dir+str(i)+'_label.mat',dic2) 
+            i += 1
+            """
+            #show feature map by tensorboard
+            split = tf.split(feature,num_or_size_splits=96,axis=3)
+            featuremap = tf.summary.image('conv1_image',split[0],40)
+            writer.add_summary(sess.run(featuremap))
+            writer.close()        
+            
+            #show feature map by plt
+            """
+            conv1_reshape = sess.run(tf.reshape(feature[0,:,:,:], [96, 1, 23, 23]))
+            fig1,ax1 = plt.subplots(nrows=1, ncols=1, figsize = (1,1))
+            for i in range(1):
+                plt.subplot(3, 4, i + 1)
+                plt.imshow(conv1_reshape[i][0])
+            plt.title('Conv1 featuremap')
+            plt.show()
+            
+        
+            #all_feature = sess.run(np.append(all_feature,feature,axis=0),feed_dict={:feature})
+            #all_label = sess.run(np.append(all_label,tra_labels,axis=0))
+    
+    except tf.errors.OutOfRangeError:  
+        print('Epochs Complete!')  
+    finally:                
+        coord.request_stop()  
+    coord.join(threads)

batch_normalization.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Apr 27 16:17:07 2018
+
+@author: wu
+"""
+
+import tensorflow as tf
+
+# 计算Wx_plus_b 的均值与方差,其中axis = [0] 表示想要标准化的维度
+img_shape = [128, 32, 32, 64]
+Wx_plus_b = tf.Variable(tf.random_normal(img_shape))
+axis = list(range(len(img_shape) - 1))
+wb_mean, wb_var = tf.nn.moments(Wx_plus_b, axis)
+
+scale = tf.Variable(tf.ones([64]))
+offset = tf.Variable(tf.zeros([64]))
+variance_epsilon = 0.001
+Wx_plus_b = tf.nn.batch_normalization(Wx_plus_b, wb_mean, wb_var, offset, scale, variance_epsilon)
+
+Wx_plus_b1 = (Wx_plus_b - wb_mean) / tf.sqrt(wb_var + variance_epsilon)
+Wx_plus_b1 = Wx_plus_b1 * scale + offset
+
+with tf.Session() as sess:
+    sess.run(tf.global_variables_initializer())
+
+    print('*** wb_mean ***')
+    print(sess.run(wb_mean))
+    print('*** wb_var ***')
+    print(sess.run(wb_var))
+    print('*** Wx_plus_b ***')
+    print(sess.run(Wx_plus_b))
+    print('**** Wx_plus_b1 ****')
+    print(sess.run(Wx_plus_b1))