TensorFlow学习笔记

深度学习笔记————TensorFlow环境搭建和mnist数据集的训练

• 需要安装的软件：anaconda就够了

Anaconda指的是一个开源的Python发行版本，其包含了conda、Python等180多个科学包及其依赖项。 [1] 因为包含了大量的科学包，Anaconda 的下载文件比较大（约 531 MB），如果只需要某些包，或者需要节省带宽或存储空间，也可以使用Miniconda这个较小的发行版（仅包含conda和 Python）

• 直接打开官网选择相应的操作系统下载即可（推荐下载最新的）
  
  安装过程一直next即可，最后需要注意勾选添加环境变量
  

---

安装好anaconda之后，可以先配置一个自己的python环境，自己电脑之前已经安装过python也没有关系，这个环境是独立，不会和之前电脑里的冲突。

如图，打开anaconda，安装好之后会自动生成一个root环境，我们可以自己新建一个，点击左下角的create，进行环境的创建。

如图所示，给环境一个命名，选择支持的语言，这里我们就选择python3.6即可。
然后我们可以安装一个python的编辑器，jupyter notebook。在home里安装即可。

Jupyter Notebook（此前被称为 IPython notebook）是一个交互式笔记本，支持运行 40 多种编程语言。
Jupyter Notebook 的本质是一个 Web 应用程序，便于创建和共享文学化程序文档，支持实时代码，数学方程，可视化和 markdown。 用途包括：数据清理和转换，数值模拟，统计建模，机器学习等等

安装TensorFlow

左上角选择Not install 然后在右边的搜索框中输入需要安装的包名，选中需要装的包，点击右下角的apply，anaconda会自动将其相关的依赖一起安装。

import tensorflow as tf

先运行这一段代码，如果过没有报错，说明TensorFlow安装成功，接下来便可以进行开发了。

在TensorFlow的官方入门课程中，多次用到mnist数据集。

mnist数据集是一个数字手写体图片库，但它的存储格式并非常见的图片格式，所有的图片都集中保存在四个扩展名为idx3-ubyte的二进制文件。

如果我们想要知道大名鼎鼎的mnist手写体数字都长什么样子，就需要从mnist数据集中导出手写体数字图片。了解这些手写体的总体形状，也有助于加深我们对TensorFlow入门课程的理解。
1.读入mnist手写体数据；

2.把数据的值从[0,1]浮点范围转化为黑白格式(背景为0-黑色，前景为255-白色)；

3.根据mnist.train.labels的内容，生成数字索引，也就是建立每一张图片和其所代表数字的关联，由此创建对应的保存目录；

4.循环遍历mnist.train.images，把每张图片的像素数据赋值给python图片处理库PIL的Image类实例，再调用Image类的save方法把图片保存在第3步骤中创建的对应目录。

import os
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
from PIL import Image
# 声明图片宽高
rows = 28
cols = 28
 
# 要提取的图片数量
images_to_extract = 8000
 
# 当前路径下的保存目录
save_dir = "./mnist_digits_images"
 
# 读入mnist数据
mnist = input_data.read_data_sets("MNIST_data/", one_hot=False)
 
# 创建会话
sess = tf.Session()
 
# 获取图片总数
shape = sess.run(tf.shape(mnist.train.images))
images_count = shape[0]
pixels_per_image = shape[1]
 
# 获取标签总数
shape = sess.run(tf.shape(mnist.train.labels))
labels_count = shape[0]
 
# mnist.train.labels是一个二维张量，为便于后续生成数字图片目录名，有必要一维化(后来发现只要把数据集的one_hot属性设为False，mnist.train.labels本身就是一维)
#labels = sess.run(tf.argmax(mnist.train.labels, 1))
labels = mnist.train.labels
 
# 检查数据集是否符合预期格式
if (images_count == labels_count) and (shape.size == 1):
    print ("数据集总共包含 %s 张图片，和 %s 个标签" % (images_count, labels_count))
    print ("每张图片包含 %s 个像素" % (pixels_per_image))
    print ("数据类型：%s" % (mnist.train.images.dtype))
 
    # mnist图像数据的数值范围是[0,1]，需要扩展到[0,255]，以便于人眼观看
    if mnist.train.images.dtype == "float32":
        print ("准备将数据类型从[0,1]转为binary[0,255]...")
        for i in range(0,images_to_extract):
            for n in range(pixels_per_image):
                if mnist.train.images[i][n] != 0:
                    mnist.train.images[i][n] = 255
            # 由于数据集图片数量庞大，转换可能要花不少时间，有必要打印转换进度
            if ((i+1)%50) == 0:
                print ("图像浮点数值扩展进度：已转换 %s 张，共需转换 %s 张" % (i+1, images_to_extract))
 
    # 创建数字图片的保存目录
    for i in range(10):
        dir = "%s/%s/" % (save_dir,i)
        if not os.path.exists(dir):
            print ("目录 ""%s"" 不存在！自动创建该目录..." % dir)
            os.makedirs(dir)
 
    # 通过python图片处理库，生成图片
    indices = [0 for x in range(0, 10)]
    for i in range(0,images_to_extract):
        img = Image.new("L",(cols,rows))
        for m in range(rows):
            for n in range(cols):
                img.putpixel((n,m), int(mnist.train.images[i][n+m*cols]))
        # 根据图片所代表的数字label生成对应的保存路径
        digit = labels[i]
        path = "%s/%s/%s.bmp" % (save_dir, labels[i], indices[digit])
        indices[digit] += 1
        img.save(path)
        # 由于数据集图片数量庞大，保存过程可能要花不少时间，有必要打印保存进度
        if ((i+1)%50) == 0:
            print ("图片保存进度：已保存 %s 张，共需保存 %s 张" % (i+1, images_to_extract))
    
else:
    print ("图片数量和标签数量不一致！")

有了数据之后便可以对数据集进行训练，代码要和数据集在同一级目录下面
mnist_digits_images 和trainData.ipynb 在同一级目录，（也可以将.ipynb下载为.py文件）

import os
 
import numpy as np
import tensorflow as tf
 
from PIL import Image
# 第一次遍历图片目录是为了获取图片总数
input_count = 0
for i in range(0,10):
    dir = './mnist_digits_images/%s/' % i                
    # 这里可以改成你自己的图片目录，i为分类标签
    for rt, dirs, files in os.walk(dir):
        for filename in files:
            input_count += 1
 
input_images = np.array([[0]*784 for i in range(input_count)])
input_labels = np.array([[0]*10 for i in range(input_count)])
 
# 第二次遍历图片目录是为了生成图片数据和标签
index = 0
for i in range(0,10):
    dir = './mnist_digits_images/%s/' % i                 # 这里可以改成你自己的图片目录，i为分类标签
    for rt, dirs, files in os.walk(dir):
        for filename in files:
            filename = dir + filename
            img = Image.open(filename)
            width = img.size[0]
            height = img.size[1]
            for h in range(0, height):
                for w in range(0, width):
                    # 通过这样的处理，使数字的线条变细，有利于提高识别准确率
                    if img.getpixel((w, h)) > 230:
                        input_images[index][w+h*width] = 0
                    else:
                        input_images[index][w+h*width] = 1
            input_labels[index][i] = 1
            index += 1
            
 
 
# 定义输入节点，对应于图片像素值矩阵集合和图片标签(即所代表的数字)
x = tf.placeholder(tf.float32, shape=[None, 784])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
 
x_image = tf.reshape(x, [-1, 28, 28, 1])
 
# 定义第一个卷积层的variables和ops
W_conv1 = tf.Variable(tf.truncated_normal([7, 7, 1, 32], stddev=0.1))
b_conv1 = tf.Variable(tf.constant(0.1, shape=[32]))
 
L1_conv = tf.nn.conv2d(x_image, W_conv1, strides=[1, 1, 1, 1], padding='SAME')
L1_relu = tf.nn.relu(L1_conv + b_conv1)
L1_pool = tf.nn.max_pool(L1_relu, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
 
W_conv2 = tf.Variable(tf.truncated_normal([3, 3, 32, 64], stddev=0.1))
b_conv2 = tf.Variable(tf.constant(0.1, shape=[64]))
 
L2_conv = tf.nn.conv2d(L1_pool, W_conv2, strides=[1, 1, 1, 1], padding='SAME')
L2_relu = tf.nn.relu(L2_conv + b_conv2)
L2_pool = tf.nn.max_pool(L2_relu, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
 
 
W_fc1 = tf.Variable(tf.truncated_normal([7 * 7 * 64, 1024], stddev=0.1))
b_fc1 = tf.Variable(tf.constant(0.1, shape=[1024]))
 
h_pool2_flat = tf.reshape(L2_pool, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
 
 
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
 
 
W_fc2 = tf.Variable(tf.truncated_normal([1024, 10], stddev=0.1))
b_fc2 = tf.Variable(tf.constant(0.1, shape=[10]))
 
y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
 
# 定义优化器和训练op
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))
train_step = tf.train.AdamOptimizer((1e-4)).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
 
 
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
 
    print ("一共读取了 %s 个输入图像， %s 个标签" % (input_count, input_count))
 
    # 设置每次训练op的输入个数和迭代次数，这里为了支持任意图片总数，定义了一个余数remainder，譬如，如果每次训练op的输入个数为60，图片总数为150张，则前面两次各输入60张，最后一次输入30张（余数30）
    batch_size = 60
    iterations = 100
    batches_count = int(input_count / batch_size)
    remainder = input_count % batch_size
    print ("数据集分成 %s 批, 前面每批 %s 个数据，最后一批 %s 个数据" % (batches_count+1, batch_size, remainder))
 
    # 执行训练迭代
    for it in range(iterations):
        # 这里的关键是要把输入数组转为np.array
        for n in range(batches_count):
            train_step.run(feed_dict={x: input_images[n*batch_size:(n+1)*batch_size], y_: input_labels[n*batch_size:(n+1)*batch_size], keep_prob: 0.5})
        if remainder > 0:
            start_index = batches_count * batch_size;
            train_step.run(feed_dict={x: input_images[start_index:input_count-1], y_: input_labels[start_index:input_count-1], keep_prob: 0.5})
 
        # 每完成五次迭代，判断准确度是否已达到100%，达到则退出迭代循环
        iterate_accuracy = 0
        if it%5 == 0:
            iterate_accuracy = accuracy.eval(feed_dict={x: input_images, y_: input_labels, keep_prob: 1.0})
            print ('iteration %d: accuracy %s' % (it, iterate_accuracy))
            if iterate_accuracy >= 1:
                break;
 
    print ('完成训练!')

   

然后可以选出一组图片，用训练好的模型进行识别

 license_num = []
    for n in range(2,8):
        path = "result/%s.bmp" % (n)
        img = Image.open(path)
        width = img.size[0]
        height = img.size[1]
 
        img_data = [[0]*784 for i in range(1)]
        for h in range(0, height):
            for w in range(0, width):
                if img.getpixel((w, h)) < 190:
                    img_data[0][w+h*width] = 0
                else:
                    img_data[0][w+h*width] = 1
 
        # 获取softmax结果前三位的index和概率值
        soft_max = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
        result = sess.run(soft_max, feed_dict = {x: np.array(img_data), keep_prob: 1.0})
        max1 = 0
        max2 = 0
        max3 = 0
        max1_index = 0
        max2_index = 0
        max3_index = 0
        for j in range(10):
            if result[0][j] > max1:
                max1 = result[0][j]
                max1_index = j
                continue
            if (result[0][j]>max2) and (result[0][j]<=max1):
                max2 = result[0][j]
                max2_index = j
                continue
            if (result[0][j]>max3) and (result[0][j]<=max2):
                max3 = result[0][j]
                max3_index = j
                continue
        license_num.append(max1_index)
        print ("softmax结果前三位概率：%s: %.2f%%    %s: %.2f%%   %s: %.2f%%" 
            % (max1_index,max1*100, max2_index,max2*100, max3_index,max3*100))
    print ("车牌号为: %s" % license_num)

识别准确率50%，需要后续对参数进行调整，来提升准确率。