深度学习(三)--简单应用

1.线性回归

(1)简单线性回归(一元)

• 定义输入变量x,输出变量y；
• 初始化线性回归中的参数:w,b；
• 根据公式给出预测结果，计算误差，使用梯度下降优化；
• 不断的训练，直到达到最大的训练次数(或考虑达到最小的误差要求)，结束训练，输出最终的结果；

# coding=utf-8
'''
tensorflow 完成简单的线性回归(隐藏层单神经元)
'''
import tensorflow as tf
import numpy as np

#1.创建数据(输入x_data，输出y_data)
x_data = np.random.rand(100).astype(np.float32)
y_data = x_data*0.1+0.3
#2.创建tensorflow结构
#定义权重参数，一维，范围为-1.0到1.0
Weights = tf.Variable(tf.random_uniform([1],-1.0,1.0))
#偏置初始化为0
biases = tf.Variable(tf.zeros([1]))

#预测值计算公式
y = Weights*x_data+biases
#二次代价函数
loss = tf.reduce_mean(tf.square(y-y_data))
#建立梯度下降优化器，学习率为0.5
optimizer = tf.train.GradientDescentOptimizer(0.5)
#最小化代价函数
train = optimizer.minimize(loss)

#3.进行优化计算
#初始化所有变量
init = tf.initialize_all_variables()

with tf.Session() as sess:
    sess.run(init)
    #200次迭代，并输出每次的w,b值
    for step in range(201):
        sess.run(train)
        if step%20==0:
            print(step,sess.run(Weights),sess.run(biases))
'''
w = 0.1,b = 0.3
预测结果：w =  0.09999931,b = 0.30000037
'''

(2)通用线性回归(多元)

• 初始化输入变量x,噪声数据noise,输出变量y;
• 初始化两个占位符对于输入x和输出y；
• 定义添加网络的函数；
• 调用函数构建：1( 输入)-10(隐层)-1(输出)网络结构；
• 预测输出，计算误差，梯度下降进行优化；
• 开始训练，训练过程中图示显示拟合过程；

# coding=utf-8
'''
#利用神经网络实现线性回归(隐藏层多神经元，权重与偏差为矩阵)
'''
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# 1.编写添加网络函数
'''
inputs:输入值
in_size:输入层的神经元个数
out_size：与输入层相邻的层的神经元个数
activation_function:**函数
'''
def add_layer(inputs,in_size,out_size,activation_function=None):
    # 连接权重，定义为矩阵
    Weights = tf.Variable(tf.random_normal([in_size,out_size]))
    # 偏置项
    biases = tf.Variable(tf.zeros([1,out_size])+0.1)
    # 计算输出
    Wx_plus_b = tf.matmul(inputs,Weights)+biases
    if activation_function is None:
        outputs = Wx_plus_b
    else:
        # 使用**函数**
        outputs = activation_function(Wx_plus_b)
    return outputs

# 2.生成数据
# 矩阵为300行1列(等差数列)
x_data = np.linspace(-1,1,300)[:,np.newaxis]
# 噪声数据：均值为0，方差为0.05
noise = np.random.normal(0,0.05,x_data.shape)
# y = x*x-0.5
y_data = np.square(x_data)-0.5+noise

# 3.定义中间变量(方便进行小批量的训练)
# 输入维度为1，不限定样本大小
xs = tf.placeholder(tf.float32,[None,1])
ys = tf.placeholder(tf.float32,[None,1])

# 4.网络层的训练
# 构造1-10-1的网络结构
# 输入层到隐藏层
l1 = add_layer(xs,1,10,activation_function=tf.nn.relu)
# 隐藏层到输出层
prediction = add_layer(l1,10,1,activation_function=None)
# 代价函数
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys-prediction),reduction_indices=[1]))  # 根据行(样本编号)统计样本误差
# 梯度下降最小化代价
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

# 5.开始训练，并图示化结果
init = tf.global_variables_initializer()
# 绘图
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.scatter(x_data,y_data)  # 散点图
plt.ion()  # 打开交互模式(加入后不会在show之后阻止程序运行)
plt.show()
with tf.Session() as sess:
    sess.run(init)
    for i in range(1000):
        sess.run(train_step, feed_dict={xs: x_data, ys: y_data})
        if i%50==0:
            try:
                ax.lines.remove(lines[0])  # 先擦除原本的折线图
            except Exception:
                pass
            predict_value = sess.run(prediction,feed_dict={xs: x_data})
            # 画曲线，红色，线宽为5
            lines = ax.plot(x_data,predict_value,'r-',lw=5)
            plt.pause(0.1)  # 停0.1
            '''静态图
            plt.figure()
            plt.scatter(x_data,y_data)
            plt.plot(x_data,predict_value,'r-',lw=5)
            plt.show()
            '''

训练结束时的拟合效果图：

2.逻辑回归

(1)手写数字介绍

• 数据集下载网址：http://yann.lecun.com/exdb/mnist/ 
• 数据分为训练集合测试集，数据对应有：特征及标签；
• 为了方便实现分类，本文使用one-hot 编码方式；

(2)手写数字识别

• 加载手写数字集；
• 分批次训练，定义批次大小；
• 定义占位符，用于输入x和结果y；
• 定义网络结构，预测，计算误差，梯度下降优化；
• 开始训练，定义准确率，分批次统计准确率；

# coding=utf-8
'''
手写数字识别：0-9的数字(进行one-hot编码)
数据集：
输入：训练 60000，测试 1000，维度：28*28，维度[60000,784],
输出：[60000,10]
softmax:将结果转化为概率，得出最终的预测分类
'''
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

# 1.加载数据
mnist = input_data.read_data_sets('data/MNIST_data',one_hot=True)
# 2.使用小批量训练，定义批次大小
batch_size = 100
# 计算训练次数
batch_num = mnist.train.num_examples//batch_size
# 3.定义占位符
x = tf.placeholder(tf.float32,[None,784])#输入的占位符
y = tf.placeholder(tf.float32,[None,10])#输出的占位符
# 4.定义网络结构
W = tf.Variable(tf.zeros([784,10]))
b = tf.Variable(tf.zeros([10]))
# 预测
predict = tf.nn.sigmoid(tf.matmul(x,W)+b)
# 代价函数
loss = tf.reduce_mean(tf.square(y-predict))
# 梯度下降
train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)
# 5.开始训练
init = tf.global_variables_initializer()
# 结果存储在布尔列表中(概率最大的位置是否相等)
correct_prediction = tf.equal(tf.arg_max(y,1),tf.arg_max(predict,1))
# 准确率(转为浮点后的均值)
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
with tf.Session() as sess:
    sess.run(init)
    for epoch in range(21):
        for batch in range(batch_size):
            batch_x,batch_y = mnist.train.next_batch(batch_size)
            sess.run(train_step,feed_dict={x:batch_x,y:batch_y})
        acc = sess.run(accuracy,feed_dict={x:mnist.test.images,y:mnist.test.labels})
        print('Iter'+str(epoch)+',Test accuracy'+str(acc))

预测的最终准确率：Iter20,Test accuracy0.87