如需轉載，請註明出處，歡迎加入深度學習群 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