Tensorflow与keras学习 (2)——卷积神经网络CNN

卷积神经网络CNN

2.1使用函数介绍：

（1）tf.truncated_normal(shape, mean, stddev) :shape表示生成张量的维度，mean是均值，stddev是标准差。这个函数产生正太分布，均值和标准差自己设定。这是一个截断的产生正太分布的函数，就是说产生正太分布的值如果与均值的差值大于两倍的标准差，那就重新生成。和一般的正太分布的产生随机数据比起来，这个函数产生的随机数与均值的差距不会超过两倍的标准差，但是一般的别的函数是可能的。

（2）tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, name=None)：

除去name参数用以指定该操作的name，与方法有关的一共五个参数：

第一个参数input：指需要做卷积的输入图像，它要求是一个Tensor，具有[batch, in_height, in_width, in_channels]这样的shape，具体含义是[训练时一个batch的图片数量, 图片高度, 图片宽度, 图像通道数]，注意这是一个4维的Tensor，要求类型为float32和float64其中之一

第二个参数filter：相当于CNN中的卷积核，它要求是一个Tensor，具有[filter_height, filter_width, in_channels, out_channels]这样的shape，具体含义是[卷积核的高度，卷积核的宽度，图像通道数，卷积核个数]，要求类型与参数input相同，有一个地方需要注意，第三维in_channels，就是参数input的第四维

第三个参数strides：卷积时在图像每一维的步长，这是一个一维的向量，长度4

第四个参数padding：string类型的量，只能是"SAME","VALID"其中之一，这个值决定了不同的卷积方式（后面会介绍）

第五个参数：use_cudnn_on_gpu:bool类型，是否使用cudnn加速，默认为true

结果返回一个Tensor，这个输出，就是我们常说的feature map

参考：http://www.cnblogs.com/welhzh/p/6607581.html

https://blog.csdn.net/mao_xiao_feng/article/details/53444333

（3）tf.nn.max_pool(value, ksize, strides, padding, name=None)：

参数是四个，和卷积很类似：

第一个参数value：需要池化的输入，一般池化层接在卷积层后面，所以输入通常是feature map，依然是[batch, height, width, channels]这样的shape

第二个参数ksize：池化窗口的大小，取一个四维向量，一般是[1, height, width, 1]，因为我们不想在batch和channels上做池化，所以这两个维度设为了1

第三个参数strides：和卷积类似，窗口在每一个维度上滑动的步长，一般也是[1, stride,stride, 1]

第四个参数padding：和卷积类似，可以取'VALID' 或者'SAME'

返回一个Tensor，类型不变，shape仍然是[batch, height, width, channels]这种形式

参考：https://blog.csdn.net/mao_xiao_feng/article/details/53453926

（4）reshape(tensor, shape, name=None)：

第1个参数为被调整维度的张量。

第2个参数为要调整为的形状。

返回一个shape形状的新tensor注意shape里最多有一个维度的值可以填写为-1，表示自动计算此维度。

（5）tf.nn.dropout(x, keep_prob, noise_shape=None, seed=None, name=None)

根据给出的keep_prob参数，将输入tensor x按比例输出。

x : 输入tensor

keep_prob : float类型，每个元素被保留下来的概率

noise_shape : 一个1维的int32张量，代表了随机产生“保留/丢弃”标志的shape。

seed : 整形变量，随机数种子。

name : 名字，没啥用。

2.2 手写体分类实例

在模型训练中的变量初始化需要注意，不适当的话可能造成训练时损失值为：nan, 无法继续，一般权值变量选择随机数分布在均值为0，方差较小的数值。调整训练学习率可以加快训练速度，手写体分类实例如下：

# CNN卷积神经网络
import tensorflow as tf
import numpy as np
import os

train_path = 'J:/study/tensorflow_learnning/data/'
class_list = ['0','1','2','3','4','5','6','7','8','9']

def get_data(file_dir,batch_size,n_classes):
    imge_paths = []
    labels = []
    for n in range(len(class_list)):
        sub_files = os.listdir(file_dir  + class_list[n])
        for m in range(len(sub_files)):
            imge_paths.append(file_dir  + class_list[n]+'/'+sub_files[m])
            labels.append(n)
    print(imge_paths)
    print(labels)

    paths_lt = tf.cast(imge_paths, tf.string)
    labels_lt = tf.cast(labels, tf.int32)
    paths_list,label_list = tf.train.slice_input_producer([paths_lt,labels_lt])

    print(paths_list)
    print(label_list)
    images1 = tf.read_file(paths_list)
    print(images1)
    images_decode = tf.image.decode_png(images1, channels=1)
    #images_decode = tf.image.decode_bmp(images1, channels=3)
    images_resize = tf.image.resize_image_with_crop_or_pad(images_decode, 28, 28)
    images_standardization = tf.image.per_image_standardization(images_resize)
    #print(images_standardization)
    images_batch,labels_batch = tf.train.batch([images_standardization,label_list],batch_size=batch_size,num_threads=64,
                                                       capacity=512)
    images_batch = tf.cast(images_batch, tf.float32)
    labels_batch = tf.one_hot(labels_batch,depth=n_classes)
    labels_batch = tf.reshape(labels_batch, [batch_size, n_classes])
    #print(labels_batch)
    return images_batch,labels_batch



# 模型构建函数
def weights(shape):
    return tf.Variable(tf.truncated_normal(shape,stddev=0.01))

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

def conv2d(x,w):
    out = tf.nn.conv2d(x,w,strides=[1,1,1,1],padding="SAME")
    return out

def max_pool_2x2(x):
    out = tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding="SAME")
    return out
def cnn(x):
    # 2，cnn模型构建，变量定义

    #layer1
    weigh1 = weights([5,5,1,32])
    bas_1 = baise([32])
    conv2_1 = tf.nn.relu(conv2d(x,weigh1)+bas_1)         # 28*28*32
    max_pool_1 = max_pool_2x2(conv2_1) #out 14*14*32


    #layer2
    weight2 = weights([5,5,32,64])
    bas_2 = baise([64])
    conv2_2 = tf.nn.relu(conv2d(max_pool_1,weight2)+bas_2)  #14*14*64
    max_pool_2 = max_pool_2x2(conv2_2)  # 7*7*64


    #layer_f
    w_f = weights([7*7*64,1024])
    b_f = baise([1024])
    f_in = tf.reshape(max_pool_2,[-1,7*7*64])
   # f_drop = tf.nn.dropout(f_in,0.5)
    f_out = tf.nn.relu(tf.matmul(f_in,w_f)+b_f)

    #layer_f_2
    w_f_2 = weights([1024,10])
    b_f_2 = baise([10])
    y_pre = tf.nn.softmax(tf.matmul(f_out,w_f_2)+b_f_2)

    return y_pre


# 1,数据准备

images,labels = get_data(train_path,100,10)
ckpt_path = './ckpt/test-model.ckpt'


# 3，构建损失函数及选择优化器

y_pre = cnn(images)

#cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=y_pre, labels=labels,name='cross-entropy')
#loss = tf.reduce_mean(cross_entropy, name='loss')
#train_op = tf.train.AdamOptimizer(1e-4).minimize(loss)

loss = tf.reduce_mean(-tf.reduce_sum(labels * tf.log(y_pre),reduction_indices=[1]))       # loss
train_op = tf.train.AdamOptimizer(1e-4).minimize(loss)
#train_op = tf.train.GradientDescentOptimizer(1e-4).minimize(loss)

correct = tf.equal(tf.argmax(y_pre, 1), tf.argmax(labels, 1))
correct = tf.cast(correct, tf.float32)
accuracy = tf.reduce_mean(correct) * 100.0

# 4，启动会话，初始化变量，训练
sess = tf.Session()
init = tf.global_variables_initializer()

save = tf.train.Saver()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
sess.run(init)

for step in range(2000):
    sess.run(train_op)
    if step % 50 == 0:
        print(sess.run(loss),":",sess.run(accuracy))
       #print(sess.run(images).shape)
        save.save(sess,ckpt_path)

coord.request_stop()
coord.join(threads)

训练结果：

更多内容关注微信公众号：ML_Study