Tensorflow学习系列(一): tensorflow解决问题的思路

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

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

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

1.初始化模型参数

2.输入训练数据

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

4.计算损失

5.调整模型参数

重复第2步操作。

解释：

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

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

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

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

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

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

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

import tensorflow as tf


# 定义训练模型
def inference(X):
    return ''


# 计算损失函数
def loss(X, Y):
    return ''


# 生成训练数据，通过返回x,y
def inputs():
    return ''


# 根据损失函数训练模型
def train(total_loss):
    return ''


# 评估训练模型
def evaluate(sess, X, Y):
    return ''
# 创建一个saver
saver = tf.train.Saver()
# 使用tensorflow进行训练
with tf.Session() as sess:
    tf.initialize_all_variables().run()
    X, Y = inputs()
    total_loss = loss(X, Y)
    train_op = train(total_loss)
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess=sess, coord=coord)
    training_steps = 1000
    for step in range(training_steps):
        sess.run([train_op])
        if step % 10 == 0:
            print("loss: ", sess.run([total_loss]))
            #保存模型
            saver.save(sess, 'my-model', global_step=step)

    evaluate(sess, X, Y)

    saver.save(sess, 'my-model', global_step=training_steps)

    coord.request_stop()
    coord.join(threads)
    sess.close()

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

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

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

第1次

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

完整代码如下：

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

number_of_points = 300
x_point = []
y_point = []

a = 2
b = 0.5
#y = 2x + 0.5
for i in range(number_of_points):
    x = np.random.normal(0.0,0.5)
    y = a*x + b +np.random.normal(0.0,0.1)
    x_point.append([x])
    y_point.append([y])

plt.plot(x_point,y_point, 'o', label='Input Data')
plt.legend()
plt.show()

####################################

A = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
b = tf.Variable(tf.zeros([1]))

# 定义训练模型
def inference(x):
    return A * x + b


# 计算损失函数
def loss(x, y):
    y_predicted = inference(x)
    return tf.reduce_sum(tf.squared_difference(y, y_predicted))


# 生成训练数据，通过返回x,y
def inputs():
    return tf.to_float(x_point), tf.to_float(y_point)


# 根据损失函数训练模型
def train(total_loss):
    learning_rate = 0.001
    return tf.train.GradientDescentOptimizer(learning_rate).minimize(total_loss)


# 评估训练模型
# y = 2x + 0.5
def evaluate(sess):
    print('evaluate>>>>>>>>>',sess.run(inference([[0.3]])))
    print('evaluate>>>>>>>>>',sess.run(inference([[0.4]])))

# 创建一个saver
saver = tf.train.Saver()
# 使用tensorflow进行训练
with tf.Session() as sess:
    tf.global_variables_initializer().run()
    x, y = inputs()
    total_loss = loss(x, y)
    train_op = train(total_loss)
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess=sess, coord=coord)
    training_steps = 21
    for step in range(training_steps):
        sess.run([train_op])
        if step % 5 == 0:
            print("loss: ", sess.run([total_loss]))
            #保存模型
            saver.save(sess, 'model/my-model', global_step=step)
            plt.plot(x_point, y_point, 'o', label='step = {}'.format(step))
            plt.plot(x_point, sess.run(A) * x_point + sess.run(b))
            plt.legend()
            plt.show()

    evaluate(sess)

    saver.save(sess, 'model/my-model', global_step=training_steps)

    coord.request_stop()
    coord.join(threads)
    sess.close()

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

欢迎加入深度学习群 255568483