tensorflow 就该这么学－－1

深度学习主要有下面几个步骤：

1、获取数据

2、搭建模型

3、模型训练

4、使用模型解决实际问题

tensorflow是现在最火的深度学习框架，值得学习

简单的用tensorflow拟合二维数据

1、获取数据

这里面找一个一次函数y约等于3x

1. import numpy as np  
2. import matplotlib.pyplot as plt  
3.   
4. train_x = np.linspace(-1,1,100)#-1到1 之间生成100个随机数  
5. train_y = 3*train_x+np.random.randn(100)*0.1#np.random.randn(100)表示生成100个符合正态分布的随机数  
6. plt.plot(train_x,train_y,'yo',label='Original data')  
7. plt.legend()  
8. plt.show()  

代码解读：导入两个包,numpy是生成数据相关的包，更多的用于矩阵运算，matplotlib主要用于可视化画图

                                

plt.plot里面‘yo’ 代表黄色yellow形状为o,后面为图形命名，可以自己改动里面参数

                       

上面这个图形是y约等于2*x,'yo' 替换为'ro'

2、搭建模型

思想：构建模型z = w*x+b, 这里面就是用z来逼近拟合上面y,不断逼近的过程中，主要调整的是参数w和b, 这两个变量也是在过程当中不断更新的亮，直到两个模型拟合程度比较好

正向搭建模型

开始用tensorflow 搭建模型

1. x = tf.placeholder('float')  
2. y = tf.placeholder('float')  
3.   
4. w = tf.Variable(tf.random_normal([1]),name='weight')  
5. b = tf.Variable(tf.zeros([1]),name='bias')  
6. z = tf.multiply(x,w)+b  

代码解读：x,y称为占位符，说白了就是先把位置占上，一会就来人把这个位置用上啦，简单的理解图书馆给小伙伴占座～～～

w表示变量，里面两个参数分别为1维的[-1,1]  之间的随机数，后面那个是代表命名，这个随意啦

b也表示变量，初始化是1维的0向量，后面参数也是命名

z代表w*x+b,multiply代表矩阵想乘

反向调整：

刚才说过正向生成的数值z与实际的值(真实值)之间的误差，反向调整参数变量w和b

大体流程：正向生成一个值反向调整一下参数循环下去，直到参数调整到合适值为止

1. cost = tf.reduce_mean(tf.square(y-z))  
2. learning_rate = 0.01  
3. optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)  

代码解读：1、算出误差  2、定义学习率参数 3、优化器利用梯度下降方法使得误差最小(还可以使用其它方法替代梯度下降法)

3、训练模型

1. # 初始化变量  
2. init = tf.global_variables_initializer()  
3. # 训练参数  
4. training_epochs = 20  
5. display_step = 2  
6.   
7. # 启动session  
8. with tf.Session() as sess:  
9.     sess.run(init)  
10.   
11.     # Fit all training data  
12.     for epoch in range(training_epochs):  
13.         for (x, y) in zip(train_X, train_Y):  
14.             sess.run(optimizer, feed_dict={X: x, Y: y})  
15.   
16.         #显示训练中的详细信息  
17.         if epoch % display_step == 0:  
18.             loss = sess.run(cost, feed_dict={X: train_X, Y:train_Y})  
19.             print ("Epoch:", epoch+1, "cost=", loss,"W=", sess.run(W), "b=", sess.run(b))  
20.             if not (loss == "NA" ):  
21.                 plotdata["batchsize"].append(epoch)  
22.                 plotdata["loss"].append(loss)  
23.   
24.     print (" Finished!")  
25.     print ("cost=", sess.run(cost, feed_dict={X: train_X, Y: train_Y}), "W=", sess.run(W), "b=", sess.run(b))  

                          

拟合图形展示：

可视化展示误差随训练步骤的变化

4、使用模型给一个学x值会得到一个 z 值

全部代码：

1. #encoding=utf-8  
2.   
3. import tensorflow as tf  
4. import numpy as np  
5. import matplotlib.pyplot as plt  
6.   
7.   
8. plotdata = { "batchsize":[], "loss":[] }  
9.   
10. #生成模拟数据  
11. train_X = np.linspace(-1, 1, 100)  
12. train_Y = 2 * train_X + np.random.randn(*train_X.shape) * 0.3 # y=2x，但是加入了噪声  
13. #显示模拟数据点  
14. plt.plot(train_X, train_Y, 'ro', label='Original data')  
15. plt.legend()  
16. plt.show()  
17.   
18. # 创建模型  
19. # 占位符  
20. X = tf.placeholder("float")  
21. Y = tf.placeholder("float")  
22. # 模型参数  
23. W = tf.Variable(tf.random_normal([1]), name="weight")  
24. b = tf.Variable(tf.zeros([1]), name="bias")  
25.   
26. # 前向结构  
27. z = tf.multiply(X, W)+ b  
28.   
29. #反向优化  
30. cost =tf.reduce_mean( tf.square(Y - z))  
31. learning_rate = 0.01  
32. optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) #Gradient descent  
33.   
34. # 初始化变量  
35. init = tf.global_variables_initializer()  
36. # 训练参数  
37. training_epochs = 20  
38. display_step = 2  
39.   
40. # 启动session  
41. with tf.Session() as sess:  
42.     sess.run(init)  
43.   
44.     # Fit all training data  
45.     for epoch in range(training_epochs):  
46.         for (x, y) in zip(train_X, train_Y):  
47.             sess.run(optimizer, feed_dict={X: x, Y: y})  
48.   
49.         #显示训练中的详细信息  
50.         if epoch % display_step == 0:  
51.             loss = sess.run(cost, feed_dict={X: train_X, Y:train_Y})  
52.             print ("Epoch:", epoch+1, "cost=", loss,"W=", sess.run(W), "b=", sess.run(b))  
53.             if not (loss == "NA" ):  
54.                 plotdata["batchsize"].append(epoch)  
55.                 plotdata["loss"].append(loss)  
56.   
57.     print (" Finished!")  
58.     print ("cost=", sess.run(cost, feed_dict={X: train_X, Y: train_Y}), "W=", sess.run(W), "b=", sess.run(b))  
59.   
60.   
61.     #图形显示  
62.     plt.plot(train_X, train_Y, 'ro', label='Original data')  
63.     plt.plot(train_X, sess.run(W) * train_X + sess.run(b), label='Fitted line')  
64.     plt.legend()  
65.     plt.show()  
66.   
67.     print(plotdata['loss'])  
68.     print(plotdata['batchsize'])  
69.       
70.   
71.     plt.figure(1)  
72.     plt.subplot(211)  
73.     plt.plot(plotdata["batchsize"], plotdata["loss"], 'b--')  
74.     plt.xlabel('Minibatch number')  
75.     plt.ylabel('Loss')  
76.     plt.title('Minibatch run vs. Training loss')  
77.   
78.     plt.show()  
79.   
80.     print ("x=0.2，z=", sess.run(z, feed_dict={X: 0.2}))