首先应用TensorFlow完成一个线性回归，了解TensorFlow的数据类型和运行机制。
import tensorflow as tf import numpy as np import matplotlib.pyplot as plt rng = np.random # 参数设定 learning_rate = 0.01 training_epochs = 10000 display_step = 50 #50代display一次 # 训练数据 train_X = np.asarray([3.3, 4.4, 5.5, 6.71, 6.93, 4.168, 9.779, 6.182, 7.59, 2.167, 7.042, 10.791, 5.313, 7.997, 5.654, 9.27, 3.1]) train_Y = np.array([1.7, 2.76, 2.09, 3.19, 1.694, 1.573, 3.366, 2.596, 2.53, 1.221, 2.827, 3.465, 1.65, 2.904, 2.42, 2.94, 1.3]) n_samples = train_X.shape[0] #维度 # 设置placeholder X = tf.placeholder("float") Y = tf.placeholder("float") # 设置模型的权重和偏置 W = tf.Variable(rng.randn(), name="weight") b = tf.Variable(rng.randn(), name="bias") # <tf.Variable 'weight:0' shape=() dtype=float32_ref> # <tf.Variable 'bias:0' shape=() dtype=float32_ref> # 设置线性回归方程 pred = tf.add(tf.multiply(X, W), b) # 设置cost为均方差 cost = tf.reduce_sum(tf.pow(pred-Y, 2)) / (2 * n_samples) # 梯度下降 # 注意，minimize() 可以自动修正W和b，因为默认设置Variables的trainable=True optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) # 初始化所有的variables init = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init) # 开始训练 # 灌入所有训练数据 for epoch in range(training_epochs): for (x, y) in zip(train_X, train_Y): # zip 搞成字典 sess.run(optimizer, feed_dict={X: x, Y: y}) # 打印出每次迭代的log日志 if (epoch+1) % display_step == 0: c = sess.run(cost, feed_dict={X: train_X, Y: train_Y}) print ("Epoch:%04d cost=" %(epoch+1,), '{:.9f}'.format(c), "W=", sess.run(W), "b=", sess.run(b)) print("Optimization Finished!") training_cost = sess.run(cost, feed_dict={X: train_X, Y: train_Y}) print("Training cost=", training_cost, "W=", sess.run(W), "b=", sess.run(b)) # 作图 # figure 1 plt.figure() plt.plot(train_X, train_Y, 'ro', label='Original data') plt.plot(train_X, sess.run(W) * train_X + sess.run(b), label='Fitted line') plt.legend() # 测试样本 test_X = np.asarray([6.83, 4.668, 8.9, 7.91, 5.7, 8.7, 3.1, 2.1]) test_Y = np.asarray([1.84, 2.273, 3.2, 2.831, 2.92, 3.24, 1.35, 1.03]) print("Testing...(Mean square loss Comparison)") testing_cost = sess.run( tf.reduce_sum(tf.pow(pred - Y, 2)) / (2 * test_X.shape[0]), feed_dict={X: test_X, Y: test_Y}) # same function as cost above print("Testing cost=", testing_cost) print("Absolute mean square loss difference:", abs(training_cost - testing_cost)) # figure 2 plt.figure() plt.plot(test_X, test_Y, 'bo', label='Testing data') plt.plot(train_X, sess.run(W) * train_X + sess.run(b), label='Fitted line') plt.legend() plt.show()
在训练完成后，用test数据集进行测试，训练和测试得到的数据结果如下：
Optimization Finished! Training cost= 0.07699074 W= 0.24960834 b= 0.80136055 Testing...(Mean square loss Comparison) Testing cost= 0.07910849 Absolute mean square loss difference: 0.002117753
训练和测试得到的结果图像如下：
接下来，做一个简单的逻辑回归进行手写数字识别例子，来进一步感受一下TensorFlow应用中，计算图的建立和工作机制。希望能在示例的实现中体会其思路，慢慢融会贯通。代码如下：
import tensorflow as tf # 加载mnist数据集 from tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets("/temp/data", one_hot=True) print(mnist) # 设置参数 learning_rate = 0.01 training_epochs = 50 batch_size = 100 # 每次放入一定批量的数据放入模型中去训练 display_step = 5 # tf Graph的输入 x = tf.placeholder(tf.float32, [None, 784]) # mnist data image of shape 28*28 y = tf.placeholder(tf.float32, [None, 10]) # 0-9 digits recognition => 10 # 设置权重和偏置 W = tf.Variable(tf.zeros([784, 10])) b = tf.Variable(tf.zeros([10])) # 设定运行模型 pred = tf.nn.softmax(tf.matmul(x, W) + b) # Softmax # 设定cost function为 cross entropy 交叉熵 cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(pred), reduction_indices=1)) # 梯度下降 optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) # 初始化权重 init = tf.global_variables_initializer() # 开始训练 with tf.Session() as sess: sess.run(init) for epoch in range(training_epochs): avg_cost = 0.0 total_batch = int(mnist.train.num_examples/batch_size) # 遍历每个batch for i in range(total_batch): batch_xs, batch_ys = mnist.train.next_batch(batch_size) # 把每个batch的数据放进去训练 _, c = sess.run([optimizer, cost], feed_dict={x: batch_xs, y: batch_ys}) # 计算平均损失 avg_cost += c / total_batch # 展示每次迭代的日志 if (epoch+1) % display_step == 0: print("Epoch:", (epoch+1), "cost=", "{:.9f}".format(avg_cost)) print("Optimization Finished!") # 测试模型 correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1)) # 计算3000个样本的准确率 accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) print("Accuracy:", accuracy.eval({x:mnist.test.images[:3000], y: mnist.test.labels[:3000]}))
运行后得到结果如下：
Epoch: 5 cost= 0.465533400 Epoch: 10 cost= 0.392410529 Epoch: 15 cost= 0.362706895 Epoch: 20 cost= 0.345443823 Epoch: 25 cost= 0.333700618 Epoch: 30 cost= 0.325048538 Epoch: 35 cost= 0.318335179 Epoch: 40 cost= 0.312850520 Epoch: 45 cost= 0.308320769 Epoch: 50 cost= 0.304484692 Optimization Finished! Accuracy: 0.896
总结：
一、关于梯度下降
1.根据公式直接计算
2.自动求导
由于手动求导方法有两个缺陷：
（1）深度神经网络中公式较长
（2）计算效率较低
可以采用以下命令进行自动求导：
gradient = tf.gradients(mse, [theta])[0]
（1）op,损失函数，这里是mse，即均方误差
（2）variable lists,变量列表即权重，这里是theta的值
3. 更简便的方法：使用Optimizer
optimizer = tf.train.GradientDecentOptimizer(learning_rate = learning_rate)
train_op = optimizer.minimize(mse)
还有很多其他优化器，例如收敛更快的MomentumOptimizer优化器等。
梯度下降中传输数据的方式
（1）mini-batch小批量灌入数据，如手写数字识别中所用的方式
（用batch_size进行分割，可以通过如下函数完成取批量数据）
（2）方法：使用占位符placeholder
def fetch_batch(epoch, batch_index, batch_size): np.random.seed(epoch * n_batches + batch_index) indices = np.random.randint(m, size=batch_size) x_batch = data[indices] y_batch = housing.target.reshape(-1, 1)[indices] return X_batch, y_batch
2. 模型保存和恢复
在训练完成后，我们经常需要保存模型，方便随时进行预测。
有时在训练过程中，我们也希望将训练的中间结果保存下来。
在TensorFlow中实现模型的保存和恢复还是非常简单便捷的：
（1）模型保存:
在创建图阶段创建一个Saver的结点，在执行阶段需要保存模型的地方调用Save()函数即可。
saver = tf.train.Saver()
完成后再启动Session，在中间某一步需要保存，我们就调用saver函数,保存在相对应的路径下。
save_path = saver.save(sess, "/my_model.ckpt")
（2）模型恢复：
在构建图的结尾创建一个Saver结点，在执行阶段的开始用restore函数进行模型恢复
saver.restore(sess, "/tem/my_model_final.ckpt")
更多关于模型保存和恢复的情况和方法请参考下面一篇博客：