tensorflow解决问题的思路

如需转载，请注明出处，欢迎加入深度学习群 255568483

Tensorflow的介绍请各位自行google，就不做多的介绍了。

Tensorflow是一个深度学习框架，他和机器学习一样，有其固定的解决问题的方式。其训练过程有固定的模式，一般如下：

1.初始化模型参数

2.输入训练数据

3.在训练数据上验证模型

4.计算损失

5.调整模型参数

重复第2步操作。

解释：

1.在第一次运行的时候，初始化模型参数。通常我们使用随机数来代替，或者全部设置为0

2.对每个数据样本进行训练，通常会随机的打乱样本数据顺序

3.在训练数据上执行模型，根据当前的模型参数计算每次训练的输出。

4.计算模型损失，这个主要是用于表明我们的模型与实际模型的偏差有多大。对于不同的模型有不同的损失函数。

5.调整模型参数，这是在学习过程中发生的。根据损失函数，调整模型的参数，通常使用梯度下降算法来学习。

训练过程完成以后，就到了评估阶段，我们使用测试的数据来验证输出，并评估损失。通常的方法是把数据按训练/测试 70/30或者80/20来划分数据。

根据以上思路，整理一个解决问题的基本代码框架：

[python]  view plain  copy

 

1. import tensorflow as tf  
2.   
3.   
4. # 定义训练模型  
5. def inference(X):  
6.     return ''  
7.   
8.   
9. # 计算损失函数  
10. def loss(X, Y):  
11.     return ''  
12.   
13.   
14. # 生成训练数据，通过返回x,y  
15. def inputs():  
16.     return ''  
17.   
18.   
19. # 根据损失函数训练模型  
20. def train(total_loss):  
21.     return ''  
22.   
23.   
24. # 评估训练模型  
25. def evaluate(sess, X, Y):  
26.     return ''  
27. # 创建一个saver  
28. saver = tf.train.Saver()  
29. # 使用tensorflow进行训练  
30. with tf.Session() as sess:  
31.     tf.initialize_all_variables().run()  
32.     X, Y = inputs()  
33.     total_loss = loss(X, Y)  
34.     train_op = train(total_loss)  
35.     coord = tf.train.Coordinator()  
36.     threads = tf.train.start_queue_runners(sess=sess, coord=coord)  
37.     training_steps = 1000  
38.     for step in range(training_steps):  
39.         sess.run([train_op])  
40.         if step % 10 == 0:  
41.             print("loss: ", sess.run([total_loss]))  
42.             #保存模型  
43.             saver.save(sess, 'my-model', global_step=step)  
44.   
45.     evaluate(sess, X, Y)  
46.   
47.     saver.save(sess, 'my-model', global_step=training_steps)  
48.   
49.     coord.request_stop()  
50.     coord.join(threads)  
51.     sess.close()  

以上是处理问题的一个基本套路，第一步初始化模型的参数，然后定义一个模型，读取输入数据(method inputs)，训练模型(method inference)，计算损失函数(method loss)，调整模型参数(method train)，评估训练模型(method evaluate)，然后在tensorflow中运行。

下面通过一个例子来解释，我们定义一个函数   y=2x+0.5，根据以上函数随机生成一个含有500个数据的数据集，使用matplotlib显示如下：

使用tensorflow来拟合此函数，根据以上的代码框架来看拟合的函数曲线，如下：

第1次

经过20次的训练基本上可以满足要求，看损失函数如下

完整代码如下：

[python]  view plain  copy

 

1. import numpy as np  
2. import matplotlib.pyplot as plt  
3. import tensorflow as tf  
4.   
5. number_of_points = 300  
6. x_point = []  
7. y_point = []  
8.   
9. a = 2  
10. b = 0.5  
11. #y = 2x + 0.5  
12. for i in range(number_of_points):  
13.     x = np.random.normal(0.0,0.5)  
14.     y = a*x + b +np.random.normal(0.0,0.1)  
15.     x_point.append([x])  
16.     y_point.append([y])  
17.   
18. plt.plot(x_point,y_point, 'o', label='Input Data')  
19. plt.legend()  
20. plt.show()  
21.   
22. ####################################  
23.   
24. A = tf.Variable(tf.random_uniform([1], -1.0, 1.0))  
25. b = tf.Variable(tf.zeros([1]))  
26.   
27. # 定义训练模型  
28. def inference(x):  
29.     return A * x + b  
30.   
31.   
32. # 计算损失函数  
33. def loss(x, y):  
34.     y_predicted = inference(x)  
35.     return tf.reduce_sum(tf.squared_difference(y, y_predicted))  
36.   
37.   
38. # 生成训练数据，通过返回x,y  
39. def inputs():  
40.     return tf.to_float(x_point), tf.to_float(y_point)  
41.   
42.   
43. # 根据损失函数训练模型  
44. def train(total_loss):  
45.     learning_rate = 0.001  
46.     return tf.train.GradientDescentOptimizer(learning_rate).minimize(total_loss)  
47.   
48.   
49. # 评估训练模型  
50. # y = 2x + 0.5  
51. def evaluate(sess):  
52.     print('evaluate>>>>>>>>>',sess.run(inference([[0.3]])))  
53.     print('evaluate>>>>>>>>>',sess.run(inference([[0.4]])))  
54.   
55. # 创建一个saver  
56. saver = tf.train.Saver()  
57. # 使用tensorflow进行训练  
58. with tf.Session() as sess:  
59.     tf.global_variables_initializer().run()  
60.     x, y = inputs()  
61.     total_loss = loss(x, y)  
62.     train_op = train(total_loss)  
63.     coord = tf.train.Coordinator()  
64.     threads = tf.train.start_queue_runners(sess=sess, coord=coord)  
65.     training_steps = 21  
66.     for step in range(training_steps):  
67.         sess.run([train_op])  
68.         if step % 5 == 0:  
69.             print("loss: ", sess.run([total_loss]))  
70.             #保存模型  
71.             saver.save(sess, 'model/my-model', global_step=step)  
72.             plt.plot(x_point, y_point, 'o', label='step = {}'.format(step))  
73.             plt.plot(x_point, sess.run(A) * x_point + sess.run(b))  
74.             plt.legend()  
75.             plt.show()  
76.   
77.     evaluate(sess)  
78.   
79.     saver.save(sess, 'model/my-model', global_step=training_steps)  
80.   
81.     coord.request_stop()  
82.     coord.join(threads)  
83.     sess.close()  

以上代码运行环境为tensorflow1.0

转：http://blog.csdn.net/vs412237401/article/details/61918780