【tensorflow-DenseNet】使用DenseNet训练MNIST

DneseNet的代码：

import tensorflow as tf
import tflearn

class DenseNet(object):
    def __init__(self,growth_rate_K,is_training,dropout_rate):
        self.growth_rate_K = growth_rate_K
        self.is_training = is_training
        self.dropout_rate = dropout_rate

    def BatchNormalization(self,x,is_training):
        return tf.layers.batch_normalization(x,training=is_training)

    def Conv2d(self,input, out_channel, kernel, stride=1):
        return tf.layers.conv2d(inputs=input, filters=out_channel, kernel_size=kernel, strides=stride, padding='SAME')

    def AvgPooling(self,input, pool_size=2, stride=2, padding='VALID'):
        return tf.layers.average_pooling2d(inputs=input, pool_size=pool_size, strides=stride, padding=padding)

    def MaxPooling(self,input, pool_size=2, stride=2, padding='VALID'):
        return tf.layers.max_pooling2d(inputs=input, pool_size=pool_size, strides=stride, padding=padding)

    def DropOut(self,x,dropout_rate,is_training):
        return tf.layers.dropout(x,rate=dropout_rate,training=is_training)

    def BottleneckLayer(self,input):
        layer1x1_BN = self.BatchNormalization(input,self.is_training)
        layer1x1_relu = tf.nn.relu(layer1x1_BN)
        layer1x1_conv = self.Conv2d(input=layer1x1_relu,out_channel=4 * self.growth_rate_K,kernel=1)
        layer1x1_dropout = self.DropOut(layer1x1_conv,dropout_rate=self.dropout_rate,is_training=self.is_training)

        layer3x3_BN = self.BatchNormalization(layer1x1_dropout,self.is_training)
        layer3x3_relu = tf.nn.relu(layer3x3_BN)
        layer3x3_conv = self.Conv2d(input=layer3x3_relu,out_channel=self.growth_rate_K,kernel=3)
        layer3x3_dropout = self.DropOut(layer3x3_conv,dropout_rate=self.dropout_rate,is_training=self.is_training)
        return layer3x3_dropout

    def CreateBlock(self,input,layers):
        all_features = [input]
        for i in range(layers):
            result = tf.concat(all_features,axis=3)
            result = self.BottleneckLayer(result)
            all_features.append(result)
        result = tf.concat(all_features,axis=3)
        return result

    def DenseNet121(self,inputX):
        input = self.Conv2d(inputX, out_channel=2 * self.growth_rate_K, kernel=7, stride=2)
        MaxPool3x3 = self.MaxPooling(input, pool_size=3, stride=2, padding='SAME')

        """Block_1"""
        block_1 = self.CreateBlock(MaxPool3x3, layers=6)
        block_1_conv = self.Conv2d(block_1, out_channel=2 * self.growth_rate_K, kernel=1, stride=1)
        block_1_avg_pool = self.AvgPooling(block_1_conv, pool_size=2, stride=2)

        """Block_2"""
        block_2 = self.CreateBlock(block_1_avg_pool, 12)
        block_2_conv = self.Conv2d(block_2, out_channel=2 * self.growth_rate_K, kernel=1, stride=1)
        block_2_avg_pool = self.AvgPooling(block_2_conv, pool_size=2, stride=2)

        """block_3"""
        block_3 = self.CreateBlock(block_2_avg_pool, 24)
        block_3_conv = self.Conv2d(block_3, out_channel=2 * self.growth_rate_K, kernel=1, stride=1)
        block_3_avg_pool = self.AvgPooling(block_3_conv, pool_size=2, stride=2, padding='SAME')

        """Block_4"""
        block_4 = self.CreateBlock(block_3_avg_pool, 16)
        block_4_conv = self.Conv2d(block_4, out_channel=2 * self.growth_rate_K, kernel=1, stride=1)
        Global_avg_pool = tflearn.layers.conv.global_avg_pool(block_4_conv)

        return Global_avg_pool

    def DenseNet169(self,inputX):
        input = self.Conv2d(inputX, out_channel=2 * self.growth_rate_K, kernel=7, stride=2)
        MaxPool3x3 = self.MaxPooling(input, pool_size=3, stride=2, padding='SAME')

        """Block_1"""
        block_1 = self.CreateBlock(MaxPool3x3, layers=6)
        block_1_conv = self.Conv2d(block_1, out_channel=2 * self.growth_rate_K, kernel=1, stride=1)
        block_1_avg_pool = self.AvgPooling(block_1_conv, pool_size=2, stride=2)

        """Block_2"""
        block_2 = self.CreateBlock(block_1_avg_pool, 12)
        block_2_conv = self.Conv2d(block_2, out_channel=2 * self.growth_rate_K, kernel=1, stride=1)
        block_2_avg_pool = self.AvgPooling(block_2_conv, pool_size=2, stride=2)

        """block_3"""
        block_3 = self.CreateBlock(block_2_avg_pool, 32)
        block_3_conv = self.Conv2d(block_3, out_channel=2 * self.growth_rate_K, kernel=1, stride=1)
        block_3_avg_pool = self.AvgPooling(block_3_conv, pool_size=2, stride=2, padding='SAME')

        """Block_4"""
        block_4 = self.CreateBlock(block_3_avg_pool, 32)
        block_4_conv = self.Conv2d(block_4, out_channel=2 * self.growth_rate_K, kernel=1, stride=1)
        Global_avg_pool = tflearn.layers.conv.global_avg_pool(block_4_conv)

        return Global_avg_pool

    def DenseNet201(self,inputX):
        input = self.Conv2d(inputX, out_channel=2 * self.growth_rate_K, kernel=7, stride=2)
        MaxPool3x3 = self.MaxPooling(input, pool_size=3, stride=2, padding='SAME')

        """Block_1"""
        block_1 = self.CreateBlock(MaxPool3x3, layers=6)
        block_1_conv = self.Conv2d(block_1, out_channel=2 * self.growth_rate_K, kernel=1, stride=1)
        block_1_avg_pool = self.AvgPooling(block_1_conv, pool_size=2, stride=2)

        """Block_2"""
        block_2 = self.CreateBlock(block_1_avg_pool, 12)
        block_2_conv = self.Conv2d(block_2, out_channel=2 * self.growth_rate_K, kernel=1, stride=1)
        block_2_avg_pool = self.AvgPooling(block_2_conv, pool_size=2, stride=2)

        """block_3"""
        block_3 = self.CreateBlock(block_2_avg_pool, 48)
        block_3_conv = self.Conv2d(block_3, out_channel=2 * self.growth_rate_K, kernel=1, stride=1)
        block_3_avg_pool = self.AvgPooling(block_3_conv, pool_size=2, stride=2, padding='SAME')

        """Block_4"""
        block_4 = self.CreateBlock(block_3_avg_pool, 32)
        block_4_conv = self.Conv2d(block_4, out_channel=2 * self.growth_rate_K, kernel=1, stride=1)
        Global_avg_pool = tflearn.layers.conv.global_avg_pool(block_4_conv)

        return Global_avg_pool

    def DenseNet264(self,inputX):
        input = self.Conv2d(inputX, out_channel=2 * self.growth_rate_K, kernel=7, stride=2)
        MaxPool3x3 = self.MaxPooling(input, pool_size=3, stride=2,padding='SAME')

        """Block_1"""
        block_1 = self.CreateBlock(MaxPool3x3,layers=6)
        block_1_conv = self.Conv2d(block_1, out_channel=2 * self.growth_rate_K, kernel=1, stride=1)
        block_1_avg_pool = self.AvgPooling(block_1_conv, pool_size=2, stride=2)

        """Block_2"""
        block_2 = self.CreateBlock(block_1_avg_pool,12)
        block_2_conv = self.Conv2d(block_2, out_channel=2 * self.growth_rate_K, kernel=1, stride=1)
        block_2_avg_pool = self.AvgPooling(block_2_conv, pool_size=2, stride=2)

        """block_3"""
        block_3 = self.CreateBlock(block_2_avg_pool,64)
        block_3_conv = self.Conv2d(block_3, out_channel=2 * self.growth_rate_K, kernel=1, stride=1)
        block_3_avg_pool = self.AvgPooling(block_3_conv, pool_size=2, stride=2,padding='SAME')

        """Block_4"""
        block_4 = self.CreateBlock(block_3_avg_pool,48)
        block_4_conv = self.Conv2d(block_4, out_channel=2 * self.growth_rate_K, kernel=1, stride=1)
        Global_avg_pool = tflearn.layers.conv.global_avg_pool(block_4_conv)

        return Global_avg_pool

    def CreateNet(self):
        pass

训练代码：

from DenseNet import DenseNet
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

def weights(shape):
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)

def bias(shape):
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)

mnist = input_data.read_data_sets('./MNIST_data',one_hot=True)

input_x = tf.placeholder(tf.float32,[None,28*28])
input_y = tf.placeholder(tf.float32,[None,10])
reshape = tf.reshape(input_x, [-1, 28, 28, 1])
training = tf.placeholder(tf.bool)
drouout = tf.placeholder(tf.float32)
y = DenseNet(growth_rate_K=16,is_training=training,dropout_rate=drouout).DenseNet169(reshape)

w_out = weights([int(y.shape[1]),10])
b_out = bias([10])
output = tf.matmul(y,w_out) + b_out

batch_size = 200
learning_rate = 1e-4
training_epoch = 100
total_batch = int(mnist.train.num_examples / batch_size)

cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=input_y, logits=output))

update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
    train_step = tf.train.AdamOptimizer(learning_rate).minimize(cross_entropy)

correct_prediction = tf.equal(tf.argmax(output, 1), tf.argmax(input_y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

saver = tf.train.Saver()
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())
saver.restore(sess,'./DenseNet_MNIST/model')

for epoch in range(training_epoch):
    test_dic = {
        input_x: mnist.test.images,
        input_y: mnist.test.labels,
        training: False,
        drouout: 0.2
    }
    test_accuracy = accuracy.eval(session=sess,
                                  feed_dict=test_dic)
    print('******\tepoch {}, testing accuracy: {}\t******'.format(epoch, test_accuracy))
    for i in range(total_batch):
        batch = mnist.train.next_batch(batch_size)
        train_dic = {
            input_x:batch[0],
            input_y:batch[1],
            training:True,
            drouout:0.2
        }
        train_step.run(session=sess, feed_dict=train_dic)
        if i % 100 == 0:
            cost = sess.run(cross_entropy,feed_dict=train_dic)
            print('After {} training , cost in train data: {}'.format(i,cost))

100个epoch后的精度：

参考博客：lhttps://blog.csdn.net/langzi453/article/details/84098964