站浏览量次 站访问人数

深度学习
笔记

By

目录
  1. 1. 回归
  2. 2. 线性回归
  3. 3. 回归预测-1
  4. 4. 回归预测-2

tensorflow学习笔记系列原始内容，可从CS 20SI: Tensorflow for Deep Learning Research。另还有几本关于tensorflow的书籍，比如tensorflow实战，tensorflow解析等。感谢把知识分享出来的各位大牛。

回归

在机器学习或者人工智能下，回归即是拟合（浅显的讲），最简单的例子是在二维空间里对散点进行直线（曲线）拟合。拓展开讲，回归解决的问题是目标是连续值的预测，不是离散的标签值预测。回归下可分线性回归和非线性回归，就是是否可以线性可分。在数学讲，能够满足wx+b形式是线性回归（该公式在神经网络中会提及，为啥么需要激活函数）。非线性回归是非线性可分的，二维下是曲线的情况。

在tensorflow下，使用简单的线性回归来做预测，因此，接下来都是讲线性回归，非线性回归后续再添加内容。

线性回归

即wx+b形式，w是各个x变量的权重，b是偏置。线性回归的预测函数就是f(x)=wx+b，喂给模型（预测函数）样本x，不断迭代优化得到好的w和b；优化需要两个重要点：成本函数和优化方法。

成本函数（也叫损失函数），预测值与真实值之间的差值，衡量预测函数的好坏，比如预测函数Y_predict=X*w+b,那么成本函数L(w,x,b)=square(Y-Y_predict),差的平方。

优化方法，即根据成本函数，找出最优的w和b，一般是求最小或最大，优化的方法本质是梯度下降法，即沿着梯度方向走，找到最佳点，细节方面会做调整，比如加快训练速度，会用随机梯度，批梯度等。

tensorflow下有很多优化方法，GradientDescentOptimizer、AdagradOptimizer、MomentumOptimizer、AdamOptimizer 等。

当成本函数和优化方法选定，接下来就是喂数据进行训练了。

回归预测-1

在二维空间中，根据x，y值进行拟合，得到一条直线。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
import os
from tensorflow.contrib.factorization.examples.mnist import fill_feed_dict
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'

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

DATA_FILE = 'E:/workspace/DeepLearnings/tensorflow-learning/data/fire_theft.xls'

#读取数据
book = xlrd.open_workbook(DATA_FILE, encoding_override='utf-8')
sheet = book.sheet_by_index(0)
data = np.asarray([sheet.row_values(i) for i in range(1, sheet.nrows)])
n_samples = sheet.nrows - 1

#创建输入和输出，即x，y
X = tf.placeholder(dtype=tf.float32, name='X')
Y = tf.placeholder(dtype=tf.float32, name='Y')
# 初始化w和b，都是0阶，即单个值，因为是线性回归，最终得到一条直线。wx+b，
w = tf.Variable(0.0,name='weights')
b = tf.Variable(0.0,name='bias')

# 预测函数
Y_predicted = X*w+b

# 成本函数
loss = tf.square(Y-Y_predicted, name='loss')

# 梯度下降，最小化成本函数
#tf有多种优化方法，
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001).minimize(loss)

with tf.Session() as sess:
    # 初始化w和b，变量需要在会话中执行初始化
    sess.run(tf.global_variables_initializer())
    writer = tf.summary.FileWriter('./graphs/linear_reg',sess.graph)
    # S训练模型，把样本挨个喂给预测函数，一般采取批，即分批喂数据，
    for i in range(50): # 100个批次
        total_loss = 0
        for x, y in data:
            # 会话里执行优化，获得成本函数值，
            _,l = sess.run([optimizer,loss],feed_dict={X:x,Y:y})
            total_loss += l
        print("Epoch {0}: {1}".format(i, total_loss/n_samples))
    writer.close()
    w,b = sess.run([w,b])

# 绘制出样本点和训练好的模型
X, Y = data.T[0], data.T[1]
plt.plot(X, Y, 'bo', label='Real data')
plt.plot(X, X * w + b, 'r', label='Predicted data')
plt.legend()
plt.show()

总结下几个步骤：
0，样本读取，方式或者预处理等不同，最终得到的是训练样本和真实值（真实标签）
1，设置placeholder，输入的是样本，输出的是目标值。
2，设置变量Variable，需要优化的参数，
3，设置预测函数，评判将要的结果值，预测值，
4，设置成本函数，即评判预测的好坏，预测与真实的差距，
5，挑选优化的方法，即怎么得到参数，使得成本函数最佳，
6，喂数据，把样本分成多个批次，每个批次含很多个样本，在每个批次下，优化，
7，得到结果，即得到参数值。

回归预测-2

从手写数字的图片，把图片拉成一个向量最为x，然后同回归预测来识别数字；这需要在最后进行处理，回归得到的连续值，需要映射成0-9的数字，这里使用softmax，将大的概率那个指定为数字。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
from tensorflow.python.training import learning_rate_decay
from tensorflow.contrib.factorization.examples.mnist import fill_feed_dict
import time

#读取数据源，
MNIST = input_data.read_data_sets('E:/workspace/DeepLearnings/tensorflow-learning/data/mnist',one_hot=True)
#MNIST.train.num_examples 查样本数量，

#设置参数
learning_rate = 0.01
batch_size = 128
n_epochs = 25

#设置placholder，存储样本和标签
#28*28像素，拉成向量即784维，标签是0-9，即10个值，向量10维
#batch_size即每个批次的大小，一个批次含多少个样本
X = tf.placeholder(tf.float32,[batch_size,784])
Y = tf.placeholder(tf.float32,[batch_size,10])

#设置训练参数，权重w和偏置bias
#并且初始值，使用概率分布
#w对应784维的输入，每维有个权重，
w = tf.Variable(tf.random_normal(shape=[784,10],stddev=0.01), name='weights')
b = tf.Variable(tf.zeros(shape=[1,10]), name='bias')

#预测
logits = tf.matmul(X,w) + b

#定义损失函数
#多类别输出，softmax，采取交叉熵，
entropy = tf.nn.softmax_cross_entropy_with_logits(logits=logits,labels=Y)
loss = tf.reduce_mean(entropy)

#设置即优化方法，批处理，
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(loss)

#变量参数初始化
init = tf.global_variables_initializer()

with tf.Session() as sess:
    writer = tf.summary.FileWriter('./graphs/logistic_reg', sess.graph)
    sess.run(init) #执行变量初始化，
    start_time = time.time()    

    n_batches = int (MNIST.train.num_examples/batch_size)#训练样本含多少个批次，
    for i in range(n_epochs):
        total_loss = 0
        for _ in range(n_batches):
            X_batch,Y_batch = MNIST.train.next_batch(batch_size)#取批次
            #执行优化方法，获得loss值，
            _,loss_batch = sess.run([optimizer,loss],feed_dict={X:X_batch,Y:Y_batch})
            total_loss += loss_batch
        print('Average loss epoch {0}: {1}'.format(i, total_loss/n_batches))
    print('Total time: {0} seconds'.format(time.time() - start_time))            
    print('Optimization Finished!')         

    #测试模型

    n_batches = int(MNIST.test.num_examples/batch_size)

    total_correct_preds = 0

    for i in range(n_batches):
        X_batch, Y_batch = MNIST.test.next_batch(batch_size)
        _,loss_batch,logits_batch = sess.run([optimizer,loss,logits], feed_dict={X: X_batch, Y:Y_batch})
        preds = tf.nn.softmax(logits_batch)
        correct_preds = tf.equal(tf.argmax(preds, 1), tf.argmax(Y_batch, 1))
        accuracy = tf.reduce_sum(tf.cast(correct_preds, tf.float32))
        total_correct_preds += sess.run(accuracy)

    print('Accuracy {0}'.format(total_correct_preds/MNIST.test.num_examples))
    writer.close()