TensorFlow的小案例

1、利用TensorFlow写出BGD、SGD、MBGD的代码

（1）基于线性回归 TensorFlow BGD

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

if __name__ == '__main__':
    with tf.Graph().as_default():
        # 1. 创建执行图
            # a. 定义占位符, shape中的None表示不做限制的意思
        input_x = tf.placeholder(dtype=tf.float32, shape=[None, 1], name='x')
        input_y = tf.placeholder(dtype=tf.float32, shape=[None, 1], name='y')

        # b. 定义模型参数变量
        w = tf.Variable(initial_value=[[-5]], dtype=tf.float32)
        b = tf.Variable(initial_value=[3], dtype=tf.float32)

        # c. 计算预测值y
        y_ = tf.add(tf.matmul(input_x, w), b)

        # d. 基于预测值和实际值构建损失函数
        loss = tf.reduce_mean(tf.square(input_y - y_), name='loss')

        # e. 让损失函数最小的时候模型就是最优模型
            # 定义一个优化器
        optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
        # 对损失函数进行优化操作
        train_op = optimizer.minimize(loss=loss)

        # 2. 执行图运行
        with tf.Session() as sess:
            # 变量初始化 给定变量值
            sess.run(tf.global_variables_initializer())

            # 1. 随机数据产生、加载
            np.random.seed(28)
            N = 100
            x = np.linspace(0, 6, N) + np.random.normal(0, 2.0, N)
            y = 14 * x + 7 - np.random.normal(0, 5.0, N)
            x.shape = -1, 1
            y.shape = -1, 1
            print((np.shape(x), np.shape(y)))

====================================== BGD ===============================================
            # TODO: 下面为BGD的模型训练( epoch: 所有样本 一次迭代更新 )
            for epoch in range(200):
                # BGD迭代优化更新参数
                sess.run(fetches=[train_op],feed_dict={input_x:x,input_y:y})
                # 获取一个 epoch 更新后损失函数的大小
                loss_ = sess.run(loss,feed_dict={input_x:x,input_y:y})
                print('第{}个epoch后损失函数的大小为{}'.format(epoch+1,loss_))
==========================================================================================

            # 3. 使用训练好的模型对数据做一个预测
            predict = sess.run(y_, feed_dict={input_x: x})

            # 可视化画图
            plt.plot(x, y, 'ro')
            plt.plot(x, predict, 'g-')
            plt.show()

（2）基于线性回归 TensorFlow SGD

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

if __name__ == '__main__':
    with tf.Graph().as_default():
        # 1. 创建执行图
            # a. 定义占位符, shape中的None表示不做限制的意思
        input_x = tf.placeholder(dtype=tf.float32, shape=[None, 1], name='x')
        input_y = tf.placeholder(dtype=tf.float32, shape=[None, 1], name='y')

        # b. 定义模型参数变量
        w = tf.Variable(initial_value=[[-5]], dtype=tf.float32)
        b = tf.Variable(initial_value=[3], dtype=tf.float32)

        # c. 计算预测值y
        y_ = tf.add(tf.matmul(input_x, w), b)

        # d. 基于预测值和实际值构建损失函数
        loss = tf.reduce_mean(tf.square(input_y - y_), name='loss')

        # e. 让损失函数最小的时候模型就是最优模型
            # 定义一个优化器
        optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
        # 对损失函数进行优化操作
        train_op = optimizer.minimize(loss=loss)

        # 2. 执行图运行
        with tf.Session() as sess:
            # 变量初始化 给定变量值
            sess.run(tf.global_variables_initializer())

            # 1. 随机数据产生、加载
            np.random.seed(28)
            N = 100
            x = np.linspace(0, 6, N) + np.random.normal(0, 2.0, N)
            y = 14 * x + 7 - np.random.normal(0, 5.0, N)
            x.shape = -1, 1
            y.shape = -1, 1
            print((np.shape(x), np.shape(y)))

======================================= SGD ==============================================
            # TODO: 下面为SGD的模型训练( epoch: 所有样本 一次迭代更新 )
            for epoch in range(200):
                # SGD迭代优化更新参数
                random_index = np.random.permutation(N)   # # 产生[0,N)的序列，步长为1，并且将这个序列值进行打乱顺序的操作
                for idx in range(N):
                    # 用每一个样本进行更新模型参数，当所有样本更新之后 称为 一个epoch
                    sess.run(fetches=[train_op],feed_dict={input_x:[x[idx]],input_y:[y[idx]]})

                # 获取一个 epoch 更新后损失函数的大小
                loss_ = sess.run(loss,feed_dict={input_x:x,input_y:y})
                print('第{}个epoch后损失函数的大小为{}'.format(epoch+1,loss_))
==========================================================================================

            # 3. 使用训练好的模型对数据做一个预测
            predict = sess.run(y_, feed_dict={input_x: x})

            # 可视化画图
            plt.plot(x, y, 'ro')
            plt.plot(x, predict, 'g-')
            plt.show()

（3）基于线性回归 TensorFlow MBGD

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

if __name__ == '__main__':
    with tf.Graph().as_default():
        # 1. 创建执行图
            # a. 定义占位符, shape中的None表示不做限制的意思
        input_x = tf.placeholder(dtype=tf.float32, shape=[None, 1], name='x')
        input_y = tf.placeholder(dtype=tf.float32, shape=[None, 1], name='y')

        # b. 定义模型参数变量
        w = tf.Variable(initial_value=[[-15]], dtype=tf.float32)
        b = tf.Variable(initial_value=[10], dtype=tf.float32)

        # c. 计算预测值y
        y_ = tf.add(tf.matmul(input_x, w), b)

        # d. 基于预测值和实际值构建损失函数
        loss = tf.reduce_mean(tf.square(input_y - y_), name='loss')

        # e. 让损失函数最小的时候模型就是最优模型
            # 定义一个优化器
        optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
        # 对损失函数进行优化操作
        train_op = optimizer.minimize(loss=loss)

        # 2. 执行图运行
        with tf.Session() as sess:
            # 变量初始化 给定变量值
            sess.run(tf.global_variables_initializer())

            # 1. 随机数据产生、加载
            np.random.seed(28)
            N = 100
            x = np.linspace(0, 6, N) + np.random.normal(0, 2.0, N)
            y = 14 * x + 7 - np.random.normal(0, 5.0, N)
            x.shape = -1, 1
            y.shape = -1, 1
            print((np.shape(x), np.shape(y)))

======================================== MBGD ============================================
            # TODO: 下面为MBGD的模型训练( epoch: 所有样本 一次迭代更新,batch指的是epoch中一次使用多少样本更新参数 )

            batch_size = 10
            total_batch_num = N//batch_size
            for epoch in range(200):
                # SGD迭代优化更新参数
                random_index = np.random.permutation(N)   # # 产生[0,N)的序列，步长为1，并且将这个序列值进行打乱顺序的操作
                for idx in range(total_batch_num):
                    # 构建随机的 batch 索引
                    start = idx * batch_size
                    end = start + batch_size
                    index = random_index[start:end]
                    # 用每一个样本进行更新模型参数，当所有样本更新之后 称为 一个epoch
                    sess.run(fetches=[train_op],feed_dict={input_x:x[index],input_y:y[index]})

                # 获取一个 epoch 更新后损失函数的大小
                loss_ = sess.run(loss,feed_dict={input_x:x,input_y:y})
                print('第{}个epoch后损失函数的大小为{}'.format(epoch+1,loss_))
==========================================================================================

            # 3. 使用训练好的模型对数据做一个预测
            predict = sess.run(y_, feed_dict={input_x: x})

            # 可视化画图
            plt.plot(x, y, 'ro')
            plt.plot(x, predict, 'g-')
            plt.show()

2、利用TensorFlow softmax 手写数字识别（分类） 

（1）基于sklearn库的机器学习（logistic softmax）分类

import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
from sklearn.datasets import load_digits
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, confusion_matrix

if __name__ == '__main__':
    # 1. 加载数据
    digits = load_digits()
    # print(digits)
    # print("key:{}".format(digits.keys()))
    # 总有1797张图像，10个类别，每个图像使用8*8=64个像素值进行图像的描述
    print("训练数据X的形状:{}".format(digits.data.shape))
    print("图像数据的形状:{}".format(digits.images.shape))
    print("目标属性的形状:{}".format(digits.target.shape))
    print("具体的目标属性:{}".format(digits.target_names))

    # # 可视化
    # idx = 136
    # print(digits.images[idx])
    # plt.imshow(digits.images[idx], cmap=plt.cm.gray_r)
    # plt.title(digits.target[idx])
    # plt.show()

    # 2. 数据的清洗

    # 3. 根据需求和原始模型从原始的特征属性中获取特征属性矩阵X和目标属性矩阵Y
    X = digits.data
    Y = digits.target

    # 4. 数据的分割(划分为训练数据和测试数据)
    n_samples = digits.images.shape[0]
    split_index = n_samples * 2 // 3
    x_train, x_test = X[:split_index], X[split_index:]
    y_train, y_test = Y[:split_index], Y[split_index:]
    print("训练数据格式:{}".format(x_train.shape))
    print("测试数据格式:{}".format(x_test.shape))

    # 5. 特征工程

    # 6. 模型对象的构建
    algo = LogisticRegression()

    # 7. 模型对象的训练
    algo.fit(x_train, y_train)

    # 8. 模型效果评估
    train_pred = algo.predict(x_train)
    test_pred = algo.predict(x_test)
    print('机器学习训练集真实值与预测值的维度为：',y_train.shape,train_pred.shape)
    print("训练数据上的准确率:{}".format(accuracy_score(y_train, train_pred)))
    print("测试数据上的准确率:{}".format(accuracy_score(y_test, test_pred)))
    print("训练数据上的混淆矩阵:\n{}".format(confusion_matrix(y_train, train_pred)))
    print("测试数据上的混淆矩阵:\n{}".format(confusion_matrix(y_test, test_pred)))
    print('获取每一个样本softmax每一个类别的概率：\n',algo.predict_proba(x_train))

（2）基于TensorFlow softmax 手写数字分类

1、注意：TensorFlow 分类问题与回归问题不同：
    回归问题：输入数据标签 Y 大多数只有 1列。
    分类问题：输入数据标签 Y 需要进行 哑编码（onehot），因此分类 深度学习 Y标签通常不是 1列。

import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
import numpy as np
import pandas as pd
import tensorflow as tf
from sklearn.datasets import load_digits
from sklearn.preprocessing import OneHotEncoder
from sklearn.metrics import accuracy_score,confusion_matrix

if __name__ == '__main__':
    # 图构建
    with tf.Graph().as_default():
        # 模型构建
            # 定义输入数据占位符
                # 定义为 float32 比 float64 减少迭代次数 
        input_x = tf.placeholder(dtype=tf.float32, shape=(None, 64), name='x')             
        input_y = tf.placeholder(dtype=tf.float32, shape=(None, 10), name='y')
            # 构建网络参数
                # 截距正态可以减少迭代次数，方差一般为 0.001 - 0.05
        w_initial = tf.Variable(initial_value=tf.truncated_normal(shape=[64, 10],stddev=0.009),name='w')       
        b_initial = tf.Variable(initial_value=tf.zeros(shape=[10],dtype=tf.float32),name='b')  
                # 常数项通常置零
            # 计算预测值
        dec_value = tf.add(tf.matmul(input_x, w_initial), b_initial) 
                    # 计算得出softmax决策函数值，二维数组（样本数 * 类数）
        prob = tf.nn.softmax(dec_value)  # softmax根据决策函数值计算映射 0-1 的概率的二维数组 
        y_pre = tf.argmax(prob, axis=1)  # 计算一维数组预测值（eg: [0,1,3,4,5,6....]）
                  # 寻找出二维数组prob 中axis=1维度最大值的索引（正好是预测值，它是一维结构（eg:[1、0、5、0、1 ...]））
        print(dec_value,input_y,y_pre)
        # 构建损失函数
            # 第一种：手写交叉熵损失函数：
        # loss = -tf.reduce_mean(tf.log(tf.reduce_sum(input_y * prob,axis=1)),name='loss')
            # 第二种：直接用 tensorflow 内置的softmax交叉熵损失函数：
        loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=input_y,
                                                         logits=dec_value),name='loss')
        '''
                参数:
                    labels=None,         ---- 是实际的标签对象，是一个二维的数组/Tensor，哑编码之后的
                    logits=None,         ---- 是预测的相当于决策函数值形成的二维的数组/Tensor
                    name=None):          ---- 操作命名
        '''
        # 构建优化器
        optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.006)
        train_op = optimizer.minimize(loss=loss)

        # 图运行
        with tf.Session() as sess:
            sess.run(tf.global_variables_initializer())
            # 加载数据
            digits = load_digits()
            X = digits.data
            Y = digits.target.reshape((-1, 1))
            onehot = OneHotEncoder(sparse=False)
            onehot.fit(Y)

            n_samples = digits.images.shape[0]
            split_index = n_samples * 2 // 3
            x_train, x_test = X[:split_index], X[split_index:]
            y_train, y_test = Y[:split_index], Y[split_index:]
            y_train = onehot.transform(y_train)
            y_test = onehot.transform(y_test)
            print("训练数据格式:{}.{}".format(x_train.shape,y_train.shape))
            print("测试数据格式:{}.{}".format(x_test.shape,y_test.shape))
            print('================================================================== ')
            # 模型训练
                # TODO BGD
            # for epoch in range(800):
            #     # 模型训练优化
            #     sess.run(fetches=[train_op], feed_dict={
            #         input_x: x_train,  # 给定占位符的值
            #         input_y: y_train  # 给定占位符的值
            #     })
            #     loss_ = sess.run(fetches=[loss], feed_dict={
            #         input_x: x_train,  # 给定占位符的值
            #         input_y: y_train  # 给定占位符的值
            #     })
            #     print("第{}次训练后模型的损失函数值为:{}".format(epoch+1, loss_))
                # TODO MBGD
            N = x_train.shape[0]
            batch_size = 100
            total_batch_num = N // batch_size
            for epoch in range(800):
                # 模型训练优化
                random_index = np.random.permutation(N)
                for idx in range(total_batch_num):
                    # 构建随机batch索引
                    start = idx * batch_size
                    end = start + batch_size
                    random_batch = random_index[start:end]
                    # batch 训练
                    sess.run(fetches=[train_op], feed_dict={
                        input_x: x_train[random_batch],  # 给定占位符的值
                        input_y: y_train[random_batch]  # 给定占位符的值
                    })

                loss_ = sess.run(fetches=[loss], feed_dict={
                    input_x: x_train,  # 给定占位符的值
                    input_y: y_train  # 给定占位符的值
                })
                print("第{}次训练后模型的损失函数值为:{}".format(epoch+1, loss_))

            # 模型评估
            train_predict = sess.run(y_pre, feed_dict={input_x: x_train}).reshape((-1, 1))
            test_predict = sess.run(y_pre, feed_dict={input_x: x_test}).reshape((-1, 1))

            # 可视化画图
            y_train = onehot.inverse_transform(y_train)     # 将 onehot 类型的标签 转化为 0,1,2,3,4 ...
            y_test = onehot.inverse_transform(y_test)
            print("训练数据上的准确率:{}".format(accuracy_score(y_train, train_predict)))
            print("测试数据上的准确率:{}".format(accuracy_score(y_test, test_predict)))
            print("训练数据上的混淆矩阵:\n{}".format(confusion_matrix(y_train, train_predict)))
            print("测试数据上的混淆矩阵:\n{}".format(confusion_matrix(y_test, test_predict)))

            # 模型持久化


============================== 使用深度学习 accuracy_score 计算方式 ==========================

import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
import numpy as np
import pandas as pd
import tensorflow as tf
from sklearn.datasets import load_digits
from sklearn.preprocessing import OneHotEncoder
from sklearn.metrics import accuracy_score,confusion_matrix

if __name__ == '__main__':
    # 图构建
    with tf.Graph().as_default():
        # 模型构建
            # 定义输入数据占位符
        input_x = tf.placeholder(dtype=tf.float32, shape=(None, 64), name='x')   
                  # 定义为 float32 比 float64 减少迭代次数
        input_y = tf.placeholder(dtype=tf.float32, shape=(None, 10), name='y')
            # 构建网络参数
        w_initial = tf.Variable(initial_value=tf.truncated_normal(shape=[64, 10],stddev=0.009),name='w') 
                  # 截距正态可以减少迭代次数，方差一般为 0.001 - 0.05
        b_initial = tf.Variable(initial_value=tf.zeros(shape=[10],dtype=tf.float32),name='b')  
                  # 常数项通常置零
            # 计算预测值
        dec_value = tf.add(tf.matmul(input_x, w_initial), b_initial)
        prob = tf.nn.softmax(dec_value)
        y_pre = tf.argmax(prob, axis=1)
        print(dec_value,input_y,y_pre)
        # 构建损失函数
            # 第一种：手写交叉熵损失函数：
        # loss = -tf.reduce_mean(tf.log(tf.reduce_sum(input_y * prob,axis=1)),name='loss')
            # 第二种：直接用 tensorflow 内置的softmax交叉熵损失函数：
        loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=input_y,
                                                      logits=dec_value),name='loss')
        '''
                参数:
                    labels=None,         ---- 是实际的标签对象，是一个二维的数组/Tensor，哑编码之后的
                    logits=None,         ---- 是预测的相当于决策函数值形成的二维的数组/Tensor
                    name=None):          ---- 操作命名
        '''
        # 构建优化器
        optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.006)
        train_op = optimizer.minimize(loss=loss)

--------------------------------- 构建模型评估操作对象 ---------------------------------------
        # 构建模型评估的操作对象
            # 获取真实值（将 onehot 的标签 转化为 0,1,2,3,4,5 .....）
        y_true = tf.argmax(input_y,axis=1)
            # 计算准确率
            # 对实际值和预测值做比较，看一下是否相等, 然后将其转换为准确率
            # TODO: 要求y_pre和y_true的形状格式完全一致,两个都是一维结构
        acc_score = tf.reduce_mean(tf.cast(tf.equal(y_pre,y_true),dtype=tf.float32))

---------------------------------------------------------------------------------------------
        # 图运行
        with tf.Session() as sess:
            sess.run(tf.global_variables_initializer())
            # 加载数据
            digits = load_digits()
            X = digits.data
            Y = digits.target
            X = digits.data
            Y = digits.target.reshape((-1, 1))
            onehot = OneHotEncoder(sparse=False)
            onehot.fit(Y)

            n_samples = digits.images.shape[0]
            split_index = n_samples * 2 // 3
            x_train, x_test = X[:split_index], X[split_index:]
            y_train, y_test = Y[:split_index], Y[split_index:]
            y_train = onehot.transform(y_train)
            y_test = onehot.transform(y_test)
            print("训练数据格式:{}.{}".format(x_train.shape,y_train.shape))
            print("测试数据格式:{}.{}".format(x_test.shape,y_test.shape))
            print('================================================================== ')
            # 模型训练
                # TODO BGD
            # for epoch in range(800):
            #     # 模型训练优化
            #     sess.run(fetches=[train_op], feed_dict={
            #         input_x: x_train,  # 给定占位符的值
            #         input_y: y_train  # 给定占位符的值
            #     })
            #     loss_ = sess.run(fetches=[loss], feed_dict={
            #         input_x: x_train,  # 给定占位符的值
            #         input_y: y_train  # 给定占位符的值
            #     })
            #     print("第{}次训练后模型的损失函数值为:{}".format(epoch+1, loss_))
                # TODO MBGD
            N = x_train.shape[0]
            batch_size = 100
            total_batch_num = N // batch_size
            for epoch in range(800):
                # 模型训练优化
                random_index = np.random.permutation(N)
                for idx in range(total_batch_num):
                    # 构建随机batch索引
                    start = idx * batch_size
                    end = start + batch_size
                    random_batch = random_index[start:end]
                    # batch 训练
                    sess.run(fetches=[train_op], feed_dict={
                        input_x: x_train[random_batch],  # 给定占位符的值
                        input_y: y_train[random_batch]  # 给定占位符的值
                    })

                loss_ = sess.run(fetches=[loss], feed_dict={
                    input_x: x_train,  # 给定占位符的值
                    input_y: y_train  # 给定占位符的值
                })
                print("第{}次训练后模型的损失函数值为:{}".format(epoch+1, loss_))

-------------------------------- 基于模型 评估tensor对象 评估模型 -----------------------------
            # 模型评估
            train_predict,acc_score_train = sess.run([y_pre,acc_score], feed_dict={input_x: x_train,input_y:y_train})
            test_predict,acc_score_test = sess.run([y_pre,acc_score], feed_dict={input_x: x_test,input_y:y_test})

            # 可视化画图
            y_train = onehot.inverse_transform(y_train)   # 将 onehot 类型的标签 转化为 0,1,2,3,4 ...
            y_test = onehot.inverse_transform(y_test)
            print("训练数据上的准确率:{}".format(acc_score_train))
            print("测试数据上的准确率:{}".format(acc_score_test))
            print("sklearn API 训练数据上的准确率:{}".format(accuracy_score(y_train, train_predict)))
            print("sklearn API 测试数据上的准确率:{}".format(accuracy_score(y_test, test_predict)))
            print("训练数据上的混淆矩阵:\n{}".format(confusion_matrix(y_train, train_predict)))
            print("测试数据上的混淆矩阵:\n{}".format(confusion_matrix(y_test, test_predict)))
---------------------------------------------------------------------------------------------
            # 模型持久化