TensorFlow入门—1

3# a rank 0tensor; this is a scalar with shape []
 [1. ,2., 3.]  # a rank 1tensor; this is a vector with shape [3]
 [[1.,  2., 3.], [4., 5.,  6.]] # a rank 2tensor; a matrix with shape [2, 3]
 [[[1.,  2., 3.]], [[7., 8.,  9.]]] # a rank 3tensor with shape [2, 1, 3]

node1 = tf.constant(3.0, dtype=tf.float32)
 node2 = tf.constant(4.0) # alsotf.float32 implicitly
print(node1, node2)

Tensor("Const:0", shape=(),dtype=float32) Tensor("Const_1:0", shape=(),dtype=float32)

sess = tf.Session()
print(sess.run([node1,node2]))

node3 = tf.add(node1, node2)
print("node3:",node3)
print("sess.run(node3):",sess.run(node3))

node3:  Tensor("Add:0", shape=(),dtype=float32)
 sess.run(node3):  7.0

a = tf.placeholder(tf.float32)
 b = tf.placeholder(tf.float32)
 adder_node = a + b  # + provides a shortcut for tf.add(a, b)

add_and_triple = adder_node * 3.
print(sess.run(add_and_triple,{a: 3, b:4.5}))

W = tf.Variable([.3], dtype=tf.float32)
 b = tf.Variable([-.3], dtype=tf.float32)
 x = tf.placeholder(tf.float32)
 linear_model = W * x + b

y = tf.placeholder(tf.float32)
 squared_deltas = tf.square(linear_model - y)
 loss = tf.reduce_sum(squared_deltas)
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))

fixW = tf.assign(W, [-1.])
 fixb = tf.assign(b, [1.])
 sess.run([fixW, fixb])
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))

optimizer = tf.train.GradientDescentOptimizer(0.01)
 train = optimizer.minimize(loss)sess.run(init) # reset values to incorrect defaults.
for i  in range(1000):
   sess.run(train, {x:[1,2,3,4], y:[0,-1,-2,-3]})

print(sess.run([W, b]))导致最终的模型参数：
[array([-0.9999969], dtype=float32), array([ 0.99999082],
  dtype=float32)]

importnumpy as np
import tensorflow as tf

# Modelparameters
 W = tf.Variable([.3], dtype=tf.float32)
 b = tf.Variable([-.3], dtype=tf.float32)
# Model inputand output
 x = tf.placeholder(tf.float32)
 linear_model = W * x + b
 y = tf.placeholder(tf.float32)
# loss
 loss = tf.reduce_sum(tf.square(linear_model - y)) # sum of the squares
# optimizer
 optimizer = tf.train.GradientDescentOptimizer(0.01)
 train = optimizer.minimize(loss)
# training data
 x_train = [1,2,3,4]
 y_train = [0,-1,-2,-3]
# training loop
 init = tf.global_variables_initializer()
 sess = tf.Session()
 sess.run(init) # reset values to wrong
for i  in range(1000):
   sess.run(train, {x:x_train, y:y_train})

# evaluatetraining accuracy
 curr_W, curr_b, curr_loss = sess.run([W, b, loss], {x:x_train, y:y_train})
print("W: %s b:%s loss: %s"%(curr_W, curr_b, curr_loss))运行时，它会产生
W: [-0.9999969] b: [ 0.99999082] loss: 5.69997e-11

importtensorflow as tf
# NumPy is oftenused to load, manipulate and preprocess data.
import numpy as np

# Declare listof features. We only have one real-valued feature. There are many
# other types ofcolumns that are more complicated and useful.
 features = [tf.contrib.layers.real_valued_column("x", dimension=1)]

# An estimatoris the front end to invoke training (fitting) and evaluation
# (inference).There are many predefined types like linear regression,
# logisticregression, linear classification, logistic classification, and
# many neuralnetwork classifiers and regressors. The following code
# provides anestimator that does linear regression.
 estimator = tf.contrib.learn.LinearRegressor(feature_columns=features)

# TensorFlowprovides many helper methods to read and set up data sets.
# Here we usetwo data sets: one for training and one for evaluation
# We have totell the function how many batches
# of data(num_epochs) we want and how big each batch should be.
 x_train = np.array([1., 2.,  3., 4.])
 y_train = np.array([0., -1., -2., -3.])
 x_eval = np.array([2., 5.,  8., 1.])
 y_eval = np.array([-1.01, -4.1, -7, 0.])
 input_fn = tf.contrib.learn.io.numpy_input_fn({"x":x_train}, y_train,
                                             batch_size=4,
                                             num_epochs=1000)
 eval_input_fn = tf.contrib.learn.io.numpy_input_fn(
     {"x":x_eval}, y_eval, batch_size=4, num_epochs=1000)

# We can invoke1000 training steps by invoking the  method and passing the
# training dataset.
 estimator.fit(input_fn=input_fn, steps=1000)

# Here weevaluate how well our model did.
 train_loss = estimator.evaluate(input_fn=input_fn)
 eval_loss = estimator.evaluate(input_fn=eval_input_fn)
print("trainloss: %r"% train_loss)
print("eval loss:%r"%eval_loss)

importnumpy as np
import tensorflow as tf
# Declare listof features, we only have one real-valued feature
def model(features,labels, mode):
   #Build a linear model and predict values
   W = tf.get_variable("W", [1], dtype=tf.float64)
   b = tf.get_variable("b", [1], dtype=tf.float64)
   y = W*features['x'] +b
   #Loss sub-graph
   loss = tf.reduce_sum(tf.square(y - labels))
   #Training sub-graph
   global_step = tf.train.get_global_step()
   optimizer = tf.train.GradientDescentOptimizer(0.01)
   train = tf.group(optimizer.minimize(loss),
                    tf.assign_add(global_step,1))
   #ModelFnOps connects subgraphs we built to the
   #appropriate functionality.
   return tf.contrib.learn.ModelFnOps(
       mode=mode, predictions=y,
       loss=loss,
       train_op=train)

 estimator = tf.contrib.learn.Estimator(model_fn=model)
# define ourdata sets
 x_train = np.array([1., 2.,  3., 4.])
 y_train = np.array([0., -1., -2., -3.])
 x_eval = np.array([2., 5.,  8., 1.])
 y_eval = np.array([-1.01, -4.1, -7, 0.])
 input_fn = tf.contrib.learn.io.numpy_input_fn({"x": x_train}, y_train, 4, num_epochs=1000)

# train
 estimator.fit(input_fn=input_fn, steps=1000)
# Here weevaluate how well our model did.  
 train_loss = estimator.evaluate(input_fn=input_fn)
 eval_loss = estimator.evaluate(input_fn=eval_input_fn)
print("trainloss: %r"% train_loss)
print("eval loss:%r"%eval_loss)运行时，它会产生
train loss: {'global_step': 1000,  'loss': 4.9380226e-11}
eval loss: {'global_step': 1000,  'loss': 0.01010081}