既然要学习tensorflow,查看了下tensorflow系统,感觉还是python 比较方便,而整个tensorflow 系统学习,使用docker 也是比较方便了,因此有必要安装下docker 环境了。
我主要参考下面的三个博客进行docker环境安装测试:
http://blog.csdn.net/fu_shuwu/article/details/75947602
http://blog.csdn.net/fu_shuwu/article/details/75946886
http://blog.csdn.net/dream_an/article/details/51985170
下面是安装了docker后,并pull 了ubuntu14.04,tensorflow/tensorflow,运行了hello-world后的一个images 列表:
sudo docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
<none> <none> 000e5908dd9f About an hour ago 188MB
ubuntu 14.04 54333f1de4ed 5 days ago 188MB
tensorflow/tensorflow latest 02f42dc11beb 3 weeks ago 1.17GB
hello-world latest 1815c82652c0 5 weeks ago 1.84kB
直接运行tensorflow里面的例子:
在http://localhost:8888/notebooks/2_getting_started.ipynb
下面有样例可以直接测试,这样可以通过修改一些源码的方式去熟悉tensorflow 基本原理;
#@test {"output":"ignore"}
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
# Set up the data with a noisy linearrelationship between X and Y.
num_examples = 50
X = np.array([np.linspace(-2, 4,num_examples), np.linspace(-6, 6, num_examples)])
# Add random noise (gaussian, mean 0, stdev1)
X += np.random.randn(2, num_examples)
# Split into x and y
x, y = X
# Add the bias node which always has avalue of 1
x_with_bias = np.array([(1., a) for a inx]).astype(np.float32)
# Keep track of the loss at each iterationso we can chart it later
losses = []
# How many iterations to run our training
training_steps = 50
# The learning rate. Also known has thestep size. This changes how far
# we move down the gradient toward lowererror at each step. Too large
# jumps risk inaccuracy, too small slow thelearning.
learning_rate = 0.002
# In TensorFlow, we need to run everythingin the context of a session.
with tf.Session() as sess:
#Set up all the tensors.
#Our input layer is the x value and the bias node.
input = tf.constant(x_with_bias)
#Our target is the y values. They need to be massaged to the right shape.
target = tf.constant(np.transpose([y]).astype(np.float32))
#Weights are a variable. They change every time through the loop.
#Weights are initialized to random values (gaussian, mean 0, stdev 0.1)
weights = tf.Variable(tf.random_normal([2, 1], 0, 0.1))
#Initialize all the variables defined above.
tf.global_variables_initializer().run()
#Set up all operations that will run in the loop.
#For all x values, generate our estimate on all y given our current
#weights. So, this is computing y = w2 * x + w1 * bias
yhat = tf.matmul(input, weights)
#Compute the error, which is just the difference between our
#estimate of y and what y actually is.
yerror = tf.subtract(yhat, target)
#We are going to minimize the L2 loss. The L2 loss is the sum of the
#squared error for all our estimates of y. This penalizes large errors
#a lot, but small errors only a little.
loss = tf.nn.l2_loss(yerror)
#Perform gradient descent.
#This essentially just updates weights, like weights += grads * learning_rate
#using the partial derivative of the loss with respect to the
#weights. It's the direction we want to go to move toward lower error.
update_weights =tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
#At this point, we've defined all our tensors and run our initialization
#operations. We've also set up the operations that will repeatedly be run
#inside the training loop. All the training loop is going to do is
#repeatedly call run, inducing the gradient descent operation, which has theeffect of
#repeatedly changing weights by a small amount in the direction (the
#partial derivative or gradient) that will reduce the error (the L2 loss).
for _ in range(training_steps):
# Repeatedly run the operations, updating the TensorFlow variable.
sess.run(update_weights)
# Here, we're keeping a history of the losses to plot later
# so we can see the change in loss as training progresses.
losses.append(loss.eval())
#Training is done, get the final values for the charts
betas = weights.eval()
yhat = yhat.eval()
# Show the results.
fig, (ax1, ax2) = plt.subplots(1, 2)
plt.subplots_adjust(wspace=.3)
fig.set_size_inches(10, 4)
ax1.scatter(x, y, alpha=.7)
ax1.scatter(x, np.transpose(yhat)[0],c="g", alpha=.6)
line_x_range = (-4, 6)
ax1.plot(line_x_range, [betas[0] + a *betas[1] for a in line_x_range], "g", alpha=0.6)
ax2.plot(range(0, training_steps), losses)
ax2.set_ylabel("Loss")
ax2.set_xlabel("Training steps")
plt.show()