TensorFlow初识(MNIST数据集识别手写体)

github博客传送门
csdn博客传送门
TensorFlow初识(MNIST数据集识别手写体)

第一步 导包

import tensorflow as tf
import numpy as np
# 这里使用tensorflow框架自带的识别手写体的数据集
import tensorflow.examples.tutorials.mnist.input_data as input_data  # 导入下载数据集手写体
mnist = input_data.read_data_sets('MNIST_data/', one_hot=True)       # 下载数据集

第二步 搭建神经网络框架

# 创建神经网络类 定义一个全链接
class MLPNet:
    # 初始化参数
    def __init__(self):
        pass
    
    # 正向传播
    def forward(self):
        pass
    
    # 反向传播
    def backward(self):
        pass

# 创建主函数入口
if __name__ == '__main__':
    net = MLPNet()  # 实例化对象
    net.forward()   # 调用forward(正向传播)方法
    net.backward()  # 调用backward(反向传播)方法
    init = tf.global_Variables_initializert()  # 初始化所有tensorflow变量的命令
    with tf.Session() as sess:  # 创建一个会话
        sess.run(init)  # 调用执行图 init里的命令

第三步 补全初始化参数 正向传播 反向传播

def __init__(self):
    # 定义一个占位 数据类型 tf.float32 数据形状是 [None, 3] 列是784,行不确定 使用时传参
    self.x = tf.placeholder(dtype=tf.float32, shape=[None, 784])  # 输入样本 x (图片)
    # 定义一个占位 数据类型 tf.float32 数据形状是 [None, 3] 列是10,行不确定 使用时传参
    self.y = tf.placeholder(dtype=tf.float32, shape=[None, 10])  # 输入标签 y (人为标注的one_hot标签)
    # 定义一个伪随机的输入层变量 服从正态分布 数据形状是 784, 100为神经元个数视情况而定 stddev是标准偏差 一般设置为 神经元个数的 sqrt(1/神经元个数) 
    self.in_w = tf.Variable(tf.truncated_normal(shape=[784, 100], stddev=tf.sqrt(1/100)))  # 输入 w
    # 定义一个输入层变量 偏值 b 里面的值为 zeros 个数为 神经元个数
    self.in_b = tf.Variable(tf.zeros([100]))
    # 定义一个输出层的变量 w  变量的值设置为 正态分布的随机值 数据的形状是 100行 ,10列 stddev是标准偏差 一般设置为 神经元个数的 sqrt(1/神经元个数)
    self.out_w = tf.Variable(tf.truncated_normal(shape=[100, 10], stddev=0.1))
    # 定义一个输出层的变量 b  变量的值设置为 神经元个数的 zeros值
    self.out_b = tf.Variable(tf.zeros([10]))

def forward(self):
    # tf.nn.relu(表示relu激活函数) tf.layers.batch_normalization(对数据进行归一化) tf.matmul(乘法表示 self.x * self.in_w)
    self.fc1 = tf.nn.relu(tf.layers.batch_normalization(tf.matmul(self.x, self.in_w)+self.in_b))  # 求 h=wx+b 中 h的值 然后归一化 使用 tf.nn.relu 激活函数 求出 σ(h) 得出 y冒 的 期望值
    # tf.nn.softmax(表示softmax分类器) tf.matmul(表示将self.fc1 * self.out_w相乘)
    self.output = tf.nn.softmax(tf.matmul(self.fc1, self.out_w)+self.out_b)  # 将求出的

def backward(self):
    # 求出 损失  预测值 和 标签值的误差的平方的均值
    self.loss = tf.reduce_mean((self.output-self.y)**2)
    # 优化器  设置训练速率 0.1 tf.train.GradientDescentOptimizer(0.1)(梯度下降优化器, 学习速率0.1) .minimize将损失反向传回去 做权重调整  opt返回很多参数 例:loss 
    self.opt = tf.train.GradientDescentOptimizer(0.1).minimize(self.loss)

第四步 补全主函数的训练

# 创建主函数入口
if __name__ == '__main__':
    net = MLPNet()  # 实例化对象
    net.forward()   # 调用forward(正向传播)方法
    net.backward()  # 调用backward(反向传播)方法
    init = tf.global_Variables_initializert()  # 初始化所有tensorflow变量的命令
    with tf.Session() as sess:  # 创建一个会话
        sess.run(init)  # 调用执行图 init里的命令 初始化所有tensorflow变量
        for epoch in range(100000):  # 设置训练的次数
            xs, ys = mnist.train.next_batch(100)  # 从mnist数据集中取样本train的方法 netx_batch(100)每个批次取100张 这是minist数据集中的取图片的内置方法
            # sess.run() tensorflow执行语句  net.output(返回的结果)多个用[列表装起来 逗号隔开] feed_dict={net.x (实例化对象的self.x) : xs, net.y (实例化对象的self.y) : ys)}
            _loss, _ = sess.run([net.loss, net.opt], feed_dict = {net.x:xs, net.y:ys})  # 必须传 net.opt 因为 self.opt里面 调用了 tensorflow里面的 梯度下降法的优化器 所以必须用 sess.run()方法运行一遍

第五步 写测试集

# 创建主函数入口
if __name__ == '__main__':
    net = MLPNet()  # 实例化对象
    net.forward()   # 调用forward(正向传播)方法
    net.backward()  # 调用backward(反向传播)方法
    init = tf.global_Variables_initializert()  # 初始化所有tensorflow变量的命令
    with tf.Session() as sess:  # 创建一个会话
        sess.run(init)  # 调用执行图 init里的命令
        for epoch in range(100000):  # 设置训练次数 循环次数
            xs, ys = mnist.train.next_batch(100)  # 从mnist数据集中取样本train的方法 netx_batch(100)每个批次取100张 这是minist数据集中的取图片的内置方法
            _loss, _ = sess.run([net.loss, net.opt], feed_dict = {net.x: xs, net.y: ys})
            if epoch % 100 = 0:  # 判断循环 100次的时候 将测试集放入训练后的模型 进行测试 看识别准确率
                test_xs, test_ys = mnist.test.next_batch(10000)  # 将测试集的10000张图的数据 和 标签取出来
                test_output = sess.run(net.output, feed_dict = {net.x: test_xs})  # 将 测试集的 数据 传给 实例化的 net.x / self.x  然后获取 输出net.output
                
                test_y = np.argmax(test_ys, axis=1)  # 求 标签集 每行的 最大值的下标 (one_hot码) 相当于 返回 0,1,2,3,4,5,6,7,8,9 中的其中一个下标
                test_out = np.argmax(test_output, axis=1)  # 将 返回的 output 进行求 每行最大值的下标 
                print(np.mean(np.array(test_y == test_out, dtype=np.float32)))  # 将 标签的下标 和 输出的下标 进行对比 然后求平均值 算出准确率

全部代码综合

import tensorflow as tf
import numpy as np
# 这里使用tensorflow框架自带的识别手写体的数据集
import tensorflow.examples.tutorials.mnist.input_data as input_data  # 导入下载数据集手写体
mnist = input_data.read_data_sets('MNIST_data/', one_hot=True)       # 下载数据集

# 创建神经网络类 定义一个全链接
class MLPNet:
    def __init__(self):
        # 定义一个占位 数据类型 tf.float32 数据形状是 [None, 3] 列是784,行不确定 使用时传参
        self.x = tf.placeholder(dtype=tf.float32, shape=[None, 784])  # 输入样本 x (图片)
        # 定义一个占位 数据类型 tf.float32 数据形状是 [None, 3] 列是10,行不确定 使用时传参
        self.y = tf.placeholder(dtype=tf.float32, shape=[None, 10])  # 输入标签 y (人为标注的one_hot标签)
        # 定义一个伪随机的输入层变量 服从正态分布 数据形状是 784, 100为神经元个数视情况而定 stddev是标准偏差 一般设置为 神经元个数的 sqrt(1/神经元个数) 
        self.in_w = tf.Variable(tf.truncated_normal(shape=[784, 100], stddev=tf.sqrt(1/100)))  # 输入 w
        # 定义一个输入层变量 偏值 b 里面的值为 zeros 个数为 神经元个数
        self.in_b = tf.Variable(tf.zeros([100]))
        # 定义一个输出层的变量 w  变量的值设置为 正态分布的随机值 数据的形状是 100行 ,10列 stddev是标准偏差 一般设置为 神经元个数的 sqrt(1/神经元个数)
        self.out_w = tf.Variable(tf.truncated_normal(shape=[100, 10], stddev=0.1))
        # 定义一个输出层的变量 b  变量的值设置为 神经元个数的 zeros值
        self.out_b = tf.Variable(tf.zeros([10]))

    def forward(self):
        # tf.nn.relu(表示relu激活函数) tf.layers.batch_normalization(对数据进行归一化) tf.matmul(乘法表示 self.x * self.in_w)
        self.fc1 = tf.nn.relu(tf.layers.batch_normalization(tf.matmul(self.x, self.in_w)+self.in_b))  # 求 h=wx+b 中 h的值 然后归一化 使用 tf.nn.relu 激活函数 求出 σ(h) 得出 y冒 的 期望值
        # tf.nn.softmax(表示softmax分类器) tf.matmul(表示将self.fc1 * self.out_w相乘)
        self.output = tf.nn.softmax(tf.matmul(self.fc1, self.out_w)+self.out_b)  # 将求出的

    def backward(self):
        # 求出 损失  预测值 和 标签值的误差的平方的均值
        self.loss = tf.reduce_mean((self.output-self.y)**2)
        # 优化器  设置训练速率 0.1 tf.train.GradientDescentOptimizer(0.1)(梯度下降优化器, 学习速率0.1) .minimize将损失反向传回去 做权重调整  opt返回很多参数 例:loss 
        self.opt = tf.train.GradientDescentOptimizer(0.1).minimize(self.loss)


# 创建主函数入口
if __name__ == '__main__':
    net = MLPNet()  # 实例化对象
    net.forward()   # 调用forward(正向传播)方法
    net.backward()  # 调用backward(反向传播)方法
    init = tf.global_Variables_initializert()  # 初始化所有tensorflow变量的命令
    with tf.Session() as sess:  # 创建一个会话
        sess.run(init)  # 调用执行图 init里的命令
        for epoch in range(100000):  # 设置训练次数 循环次数
            xs, ys = mnist.train.next_batch(100)  # 从mnist数据集中取样本train的方法 netx_batch(100)每个批次取100张 这是minist数据集中的取图片的内置方法
            _loss, _ = sess.run([net.loss, net.opt], feed_dict = {net.x: xs, net.y: ys})
            if epoch % 100 = 0:  # 判断循环 100次的时候 将测试集放入训练后的模型 进行测试 看识别准确率
                test_xs, test_ys = mnist.test.next_batch(10000)  # 将测试集的10000张图的数据 和 标签取出来
                test_output = sess.run(net.output, feed_dict = {net.x: test_xs})  # 将 测试集的 数据 传给 实例化的 net.x / self.x  然后获取 输出net.output
                
                test_y = np.argmax(test_ys, axis=1)  # 求 标签集 每行的 最大值的下标 (one_hot码) 相当于 返回 0,1,2,3,4,5,6,7,8,9 中的其中一个下标
                test_out = np.argmax(test_output, axis=1)  # 将 返回的 output 进行求 每行最大值的下标 
                print(np.mean(np.array(test_y == test_out, dtype=np.float32)))  # 将 标签的下标 和 输出的下标 进行对比 然后求平均值 算出准确率