首先应用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")
更多关于模型保存和恢复的情况和方法请参考下面一篇博客：