TensorFlow基础概念和编程（第二讲）

心已赠人 2022-04-11 13:10 196阅读 0赞

## 波士顿房价预测问题：利用多元线性回归 ##

波士顿房价数据集包括506个样本，每个样本包含12个特征变量和该地区的平均房价。房价显然和多个特征变量有关，不是单变量回归（一元线性回归）问题，选择多个特征变量来建立线性方程，这就是多变量线性回归（多元线性回归）问题。

### 读取数据 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkzMTU0MA_size_16_color_FFFFFF_t_70][]

%matplotlib notebook
    
    import tensorflow as tf
    import matplotlib.pyplot as plt
    import numpy as np
    import pandas as pd
    #样本的打乱索要用的包
    from sklearn.utils import shuffle
    
    #读取数据文件
    #header表示要不要把表头读进来
    df = pd.read_csv("data/boston.csv", header=0)
    #显示数据摘要信息
    print(df.describe())
    
    #获取df的值
    df = df.values
    print(df)
    
    #要把df转换为np的数组格式
    df = np.array(df)
    
    #x_data为前12列特征数据
    x_data = df[:,:12]
    
    #y_data为最后一列的标签数据
    y_data = df[:,12]
    
    #对特征数据进行归一化,y_data保持不变
    for i in range(12):
        df[:,i] = df[:,i]/df[:,i].max() - df[:,i].min()
    x_data = df[:,:12]

pandas介绍：用来快速读取常规大小的数据文件时，通过创建读缓存区和其他的机制可能会造成额外的开销。此时建议采用pandas库来处理。

pandas可以用来读取CSV文件、文本文件、MS Excel文件、SQL数据库，甚至是用于科学用途的HDP5格式。CSV文件加载能够自动识别列头，支持列的直接寻址。数据结构自动转换为Numpy的多维数组。

### 准备建模 ###

利用简单的线性模型进行处理。

### 模型的定义 ###

定义训练数据占位符：

x = tf.placeholder(tf.float32, [None,12], name='X')  #12个特征数据（12列）
    y = tf.placeholder(tf.float32, [None,1], name='Y')  #一个标签数据（1列）

shape中None表示行的数量未知，在实际训练时决定一次代入多少行样本，从一个样本的随机SGD到批量的SGD都可以。

定义模型结构：

#定义命名空间，把模型中比较相关的节点打包在一起，这样在计算图中显示就会更加方便有条理
    with tf.name_scope("Model")
        #w初始化值为shape(12, 1)的随机数,标准差为0.01
        w = tf.Variable(tf.random_normal([12,1], stddev=0.01), name='W')
    
        #初始化为1.0
        b = tf.Variable(1.0, name='b')
        
        #w和x是矩阵相乘，用matmul，不能用multiply或者*
        def model(x, w, b):
            return tf.matmul(x, w) + b
    
        #预测计算操作，前向计算节点
        pred = model(x, w, b)

模型训练：

#迭代轮次
    train_epochs = 50
    
    #学习率
    learning_rate = 0.01
    
    #定义损失函数的命名空间
    with tf.name_scope("LossFunction")：
        loss_function = tf.reduce_mean(tf.pow(y-pred, 2))  #均方误差
    
    #选择和创建优化器
    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss_function)
    
    sess = tf.Session()
    init = tf.global_variable_initializer()
    sess.run(init)
    
    #模型训练
    #数据需要进行归一化，前面已经做好了
    for epoch in range(train_epochs):
        loss_sum = 0.0
        for xs,ys in zip(x_data, y_data):
            xs = xs.reshape(1,12)
            ys = ys.reshape(1,1)
            _, loss = sess.run([optimizer,loss_function], feed_dict={x:xs, y:ys})
            loss_sum = loss_sum + loss
    
        #打乱数据
        xvalues,yvalues = shuffle(x_data, y_data)
        b0temp = b.eval(session=sess)
        w0temp = w.eval(session=sess)
    
        print("epoch=", epoch+1, "loss=", loss_average, "b=", b0temp, "w=", w0temp)

## MNIST手写数字识别问题 ##

MNIST数据集来自于美国国家标准与技术研究所，National Institute of Standards and Technology(NIST)。

数据集由来自250个不同人手写的数字构成。其中50%是高中学生，50%来自人口普查局的工作人员。其中包括55000条训练集，5000条验证集，10000条测试集。

TensorFlow提供了数据集的读取方法:

import tensorflow.examples.tutorials.mnist.input_data as input_data
    mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
    import matplotlib.pyplot as plt
    
    print('训练集train数量：', mnist.train.num_examples, '验证集validation数量：', mnist.validation.num_examples, '测试集test数量：', mnist.test.num_examples)
    
    #查看train Data
    print('train images shape:', mnist.train.images.shape, 'label shape:', mnist.train.labels.shape)
    
    #输出为（55000， 784）和（55000， 10），前面之所以是784是因为每张图片大小都是28*28的，后面标签是10是因为采用独热编码，这样的话从0到9一共有十个数字。
    
    #输出为784
    print(len(mnist.train.images[0]))
    
    #输出为(784,)
    print(mnist.train.images[0].shape)
    
    
    #显示图像,图像的额可视化
    mnist.train.images[0].reshape(28, 28)
    def plot_image():
        plt.imshow(image.reshape(28, 28), cmap='binary')
        plt.show()
    
    plot_image(mnist.train.images[1])

独热编码介绍：独热编码是一种稀疏向量，其中一个元素为1，其余元素都为0。独热编码常用于表示拥有有限个可能值得字符串或者标识符。

为什么要采用one hot编码：

*  将离散特征的取值扩展到了欧式空间，离散特征的某个取值就对应欧式空间的某个点
 *  机器学习算法中，特征之间距离的计算或者相似度的常用计算方法都是基于欧式空间的
 *  将离散型特征使用one-hot编码，会使特征之间的距离计算更加合理

#如果数据采用的是one-hot编码，可以通过以下方式输出对应的值
    #argmax返回的是最大值的索引
    import numpy as np
    np.argmax(mnist.train.labels[1])

数据集的划分：

一般分为训练集，测试集和验证集。之所以要加上一个验证集是因为在多次训练模型验证超参数的时候模型会学习到测试集数据上的一些特性，导致我们虽然没有进行别的操作，多次训练测试之后就会形成整个模型的优化。验证集的加入可以有效的解决这个问题，只有模型在验证集上有很好的表现的时候我们才把数据放到测试集上对其进行测试。当然这只是适用在数据集很大的情况下，如果数据集比较小，我们需要通过交叉验证来解决这一问题。

### 分类模型构建与训练 ###

#mnist中每张图片共有28*28个像素点
    x = tf.placeholder(tf.float32, [None, 784], name='X')
    
    #0-9一共有10个数字，也就是说有十个类别
    y = tf.placeholser(tf.float32, [None, 10], name='Y')
    
    #在本例中，以正态分布的随机数初始化权重W，以常数0初始化偏置b
    w = tf.Variable(tf.random_normal([784, 10]), name='W')
    b = tf.Variable(tf.zeros([10]), name='b')
    
    #定义前向计算
    forward = tf.matnul(x, w) + b
    pred = tf.nn.softmax(forward)  #softmax分类
    
    #设置训练参数
    train_epochs = 50  #训练轮数
    batch_size = 100  #单次训练样本数
    total_batch = int(mnist.train.num_examples/batch_size)  #一轮训练有多少批次
    display_step = 1  #显示粒度，就是在后面会显示损失是多少，精确度是多少
    learning_rate = 0.01   # 学习率
    
    #定义交叉熵损失函数
    loss_function = tf.reduce_mean(-tf.reduce_sum(y*tf.log(pred), reduction_indices=1))
    
    #梯度下降优化器
    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss_function)
    
    #定义精确率，检查预测类别tf.argmax(pred,1)与实际类别tf.argmax(y,1)的情况
    correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
    #准确率，将布尔值转换为浮点数，并计算平均值
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    
    sess = tf.Session()
    init = tf.global_variables_initializer()  #变量初始化
    sess.run(init)
    
    for epoch in range(train_epochs):
        for bay=tch in range(total_batch):
            xs,ys = mnist.train.next_batch(batch_size)  #读取批次数据
            sess.run(optimizer, feed_dict={x:xs, y:ys}) #执行批次训练
        #total_batch个批次训练完成之后，使用验证数据计算误差与准确率；保证数据集没有分批
        loss,acc = sess.run([loss_function], feed_dict={x:mnist.validation.images,                      
        y:mnist.validation.labels})
        #打印训练过程中的详细信息
        if (epoch+1) % display_step == 0:
            print("Train Epoch:", '%02d' %(epoch+1), "Loss=", "{:.9f}".format(loss),'Accuracy', "{:.4f}".format(acc))
    
    print("Train  Finished!")
    
    #完成训练后，在测试集上评估模型的准确率
    acc_test = sess.run(accuracy, feed_dict={x:mnist.test.images, y:mnist.test.labels})
    print("Test Accuracy", accu_test)
    
    #完成训练后在验证集上评估模型的准确率
    acc_validation = sess.run(accuracy, feed_dict={x:mnist.validation.images, y:mnist.validation.labels})
    print("Test Accuracy", acc_validation)

argmax补充：

import numpy as np
    import tensorflow as tf
    arr1 = np.array([1, 5, 3, 7])
    arr2 = np.array([[1,0,2,3],,[3,2,1], [4,7,2], [8,3,2]])
    print(arr1)
    print(arr2)
    
    #因为arr1是一个一维数据，所一直接返回最大值的索引，输出为4
    argmax_1 = tf.argmax(arr1)
    
    #指定第二个参数为0，按第一维（行）的元素取值，即同列的每一个元素取出来最大值的索引放在一个数组中
    #输出为[3, 2, 0]
    argmax_2 = tf.argmax(arr2,0)
    
    #指定第二个参数为1,则第二维（列）的元素取值，即同行的每一个元素取出最大的的索引放在一个数组中
    #输出为[2,0,2,1]
    argmax_3 = tf.argmax(arr2,1)
    
    #指定第二个参数为-1，则最后维的元素取值返回最大值的索引，这里是一个二维数组，所以和上面的答案是一样的
    argmax_4 = tf.argmax(arr2,-1)

小贴士：逻辑回归损失函数的小问题：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkzMTU0MA_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkzMTU0MA_size_16_color_FFFFFF_t_70 2][]

### 模型的应用和可视化 ###

#由于pred预测结果是one-hot编码形式，所以需要转换为0~9的数字
    prediction_result = sess.run(tf.argmax(pred, 1), feed_dict={x:mnist.test.images})
    
    #查看预测中的前10项
    prediction_result[0:10]
    
    #定义可视化函数
    import

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkzMTU0MA_size_16_color_FFFFFF_t_70]: /images/20220411/aace374629fc47edba7d360f9c8a8494.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkzMTU0MA_size_16_color_FFFFFF_t_70 1]: /images/20220411/3518ed90843c468993c3445bbee2fa6f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkzMTU0MA_size_16_color_FFFFFF_t_70 2]: /images/20220411/13184fe35ce544c6ac50adeb494a7eb8.png