TensorFlow教程（一）

yum install -y python-pip python-devel # for Python 2.7
yum install -y python34-pip.noarch python34-devel.x86_64 # for Python 2.7

pip -V
pip3 -V

pip install tensorflow      # Python 2.7; CPU support (no GPU support)
pip3 install tensorflow     # Python 3.n; CPU support (no GPU support)
pip install tensorflow-gpu  # Python 2.7;  GPU support
pip3 install tensorflow-gpu # Python 3.n; GPU suppor

sudo pip  install --upgrade tfBinaryURL   # Python 2.7
sudo pip3 install --upgrade tfBinaryURL   # Python 3.n

import tensorflow as tf
hello = tf.constant('Hello, TensorFlow!')
sess = tf.Session()
print(sess.run(hello))

pip uninstall tensorflow  # for Python 2.7
pip3 uninstall tensorflow # for Python 3.n

pip3 install --upgrade tensorflow #CPU版
pip3 install --upgrade tensorflow-gpu #GPU版

python
import tensorflow as tf
hello = tf.constant('Hello, TensorFlow!')
sess = tf.Session()
print(sess.run(hello))

3 # 等级0张量;这是一个具有尺寸[]的标量
[1. ,2., 3.] # 等级1张量;这是一个尺寸为[3]的矢量
[[1., 2., 3.], [4., 5., 6.]] # 等级2张量;具有尺寸为[2，3]的矩阵
[[[1., 2., 3.]], [[7., 8., 9.]]] # 3级张量，尺寸为[2,1,3]

import tensorflow as tf

node1 = tf.constant(3.0, dtype=tf.float32) #创建常量张量值为3.0，类型为tf.float32
node2 = tf.constant(4.0) #隐含的类型也为tf.float32
print(node1, node2)

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

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

[3.0, 4.0]

ode3 = 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) #定义一个占位符，元素类型为32位浮点数
b = tf.placeholder(tf.float32)
adder_node = a + b  # + 等价于 tf.add(a, b)

7.5
[ 3.  7.]

add_and_triple = adder_node * 3.0 #再附加乘的操作
print(sess.run(add_and_triple, {a: 3, b:4.5})) #执行计算

22.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 #创建一个线性模型

init = tf.global_variables_initializer()
sess.run(init)

print(sess.run(linear_model, {x:[1,2,3,4]}))

[ 0.          0.30000001  0.60000002  0.90000004]

y = tf.placeholder(tf.float32) #创建占位符
squared_deltas = tf.square(linear_model - y) #求delta^2
loss = tf.reduce_sum(squared_deltas) #求和，计算出最终误差
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]})) #执行求出损失

23.66

fixW = tf.assign(W, [-1.]) #修改W的值为-1
fixb = tf.assign(b, [1.]) #修改b的值为1
sess.run([fixW, fixb]) #执行更改
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]})) ##重新计算损失函数

0.0

optimizer = tf.train.GradientDescentOptimizer(0.01) #创建梯度下降优化器，学习率为0.01
train = optimizer.minimize(loss) #该优化器为最小化损失函数
sess.run(init) # 将值重置为不正确的默认值
for i in range(1000): #训练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)]

import numpy as np
import tensorflow as tf

# Model parameters 模型参数
W = tf.Variable([.3], dtype=tf.float32) #待训练的参数
b = tf.Variable([-.3], dtype=tf.float32)
# Model input and 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})

# evaluate training 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))

import tensorflow as tf
# NumPy is often used to load, manipulate and preprocess data.
# NumPy通常用于加载，操纵和预处理数据。
import numpy as np

# Declare list of features. We only have one real-valued feature. There are many
# other types of columns that are more complicated and useful.
# 声明特征列表。我们只有一个实数的特征。
# 当然还有其他的更加复杂和有用的列类型
features = [tf.contrib.layers.real_valued_column("x", dimension=1)]

# An estimator is the front end to invoke training (fitting) and evaluation
# (inference). There are many predefined types like linear regression,
# logistic regression, linear classification, logistic classification, and
# many neural network classifiers and regressors. The following code
# provides an estimator that does linear regression.
# 估计器是一个实现训练和评估的前端。有许多预定义类型，
# 如线性回归， 逻辑回归，线性分类，物流分类和很多神经网络分类器和回归器。
# 以下代码提供一个进行线性回归的估计
estimator = tf.contrib.learn.LinearRegressor(feature_columns=features)

# TensorFlow provides many helper methods to read and set up data sets.
# Here we use two data sets: one for training and one for evaluation
# We have to tell the function how many batches
# of data (num_epochs) we want and how big each batch should be.
# TensorFlow提供了许多帮助方法来读取和设置数据集。
# 这里我们使用两个数据集：一个用于训练，一个用于评估
# 我么还有告诉函数有多少批次数据(num_epochs)，每一批次数据有多大
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 invoke 1000 training steps by invoking the  method and passing the
# training data set.
# 我们可以通过调用方法和传递训练数据集来实现1000此训练。
estimator.fit(input_fn=input_fn, steps=1000)

# Here we evaluate how well our model did.
# 在这里我们评估我们的模型做得如何。
train_loss = estimator.evaluate(input_fn=input_fn)
eval_loss = estimator.evaluate(input_fn=eval_input_fn)
print("train loss: %r"% train_loss)
print("eval loss: %r"% eval_loss)

train loss: {'loss': 2.0180224e-08, 'global_step': 1000}
eval loss: {'loss': 0.0025395651, 'global_step': 1000}

import numpy as np
import tensorflow as tf
# Declare list of 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.
  # ModelFnOps将我们构建的子图连接到适当的功能。
  return tf.contrib.learn.ModelFnOps(
      mode=mode, predictions=y,
      loss=loss,
      train_op=train)

estimator = tf.contrib.learn.Estimator(model_fn=model)
# define our data 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)
eval_input_fn = tf.contrib.learn.io.numpy_input_fn({"x": x_eval}, y_eval, 4, num_epochs=1000)

# train
# 训练
estimator.fit(input_fn=input_fn, steps=1000)
# Here we evaluate how well our model did.
# 这儿我们将评估我们的模型表现如何
train_loss = estimator.evaluate(input_fn=input_fn)
eval_loss = estimator.evaluate(input_fn=eval_input_fn)
print("train loss: %r"% train_loss)
print("eval loss: %r"% eval_loss)

train loss: {'global_step': 1000, 'loss': 6.4150553e-11}
eval loss: {'global_step': 1000, 'loss': 0.010101151}

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
#源码参见：https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/examples/tutorials/mnist/input_data.py

import tensorflow as tf

x = tf.placeholder("float", [None, 784])

W = tf.Variable(tf.zeros([784,10]))
b = tf.Variable(tf.zeros([10]))

y = tf.nn.softmax(tf.matmul(x,W) + b)

y_ = tf.placeholder("float", [None,10])

cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))

train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

init = tf.initialize_all_variables()

sess = tf.Session()
sess.run(init)

for i in range(1000):
  batch_xs, batch_ys = mnist.train.next_batch(100)
  sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))

accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

print sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels})

### 步骤1：加载数据 ###
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

# 查看数据
# mnist.train.images为训练数据
print(mnist.train.images.ndim) #获取数据维度
print(mnist.train.images.shape) #获取数组各个维度的大小
print(mnist.train.labels.shape)

# 引入tf库
import tensorflow as tf
sess = tf.InteractiveSession() #创建交互式会话

### 步骤2：创建输入训练样本数据和标签的占位符 ###

# 创建训练数据所用的占位符，维度为2，第一维为任意在运行时指定，
# 取决于批次batch
x = tf.placeholder("float", shape=[None, 784]) #输入占位符
y_ = tf.placeholder("float", shape=[None, 10]) #数据标签（输出）占位符


### 步骤3：创建模型参数 ###
# 创建训练特征变量（权重W和偏置b）

# 创建权重的函数
def weight_variable(shape):
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)

# 创建偏置的的函数
def bias_variable(shape):
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)

#第一层卷积的参数
W_conv1 = weight_variable([5, 5, 1, 32]) #5*5滤波器，输入通道为1，输出通道为32
b_conv1 = bias_variable([32])
#第二层卷积的参数
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
#密集连接层的参数
W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])
#输出层的参数
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])

### 步骤4：构建假设函数模型y ###
# 卷积和池化函数
def conv2d(x, W):
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

def max_pool_2x2(x):
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                        strides=[1, 2, 2, 1], padding='SAME')

# 构建y的模型
#对输入x重塑成1通道的张量
x_image = tf.reshape(x, [-1,28,28,1])
# 第一层卷积和池化降维
# 公式为：ReLU激活(卷积(x,w) + b)
#输入：1*28*28 输出为32*14*14
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1) #2*2降维，
# 第二层卷积和池化降维
#输入：32*14*14 输出为：64*7*7
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)
#密集连接层
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64]) #展开64*7*7的张量
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
#Dropout层，防止过拟合
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
#输出层
y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

### 步骤5：构造代价函数 ###
cross_entropy = tf.reduce_mean(
    tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))

### 步骤6：训练模型 ###
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

#初始化、训练
with tf.Session() as sess:
  sess.run(tf.global_variables_initializer())
  for i in range(20000):
    batch = mnist.train.next_batch(50)
    if i % 100 == 0:
      train_accuracy = accuracy.eval(feed_dict={
          x: batch[0], y_: batch[1], keep_prob: 1.0})
      print('step %d, training accuracy %g' % (i, train_accuracy))
    train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
### 步骤7：评估模型 ###
  print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

import os
import urllib.request

import numpy as np
import tensorflow as tf

# 数据集
IRIS_TRAINING = "iris_training.csv"
IRIS_TRAINING_URL = "http://download.tensorflow.org/data/iris_training.csv"

IRIS_TEST = "iris_test.csv"
IRIS_TEST_URL = "http://download.tensorflow.org/data/iris_test.csv"

# 主函数
def main():
### 下载训练和测试集 ###
  # 如果训练集和测试集没有不存在，下载它们。
  if not os.path.exists(IRIS_TRAINING):
    raw = urllib.request.urlopen(IRIS_TRAINING_URL).read()
#    print(type(raw))
#    print(len(raw))
#    print(raw)
    with open(IRIS_TRAINING, "wb") as f:
      f.write(raw)

  if not os.path.exists(IRIS_TEST):
    raw = urllib.request.urlopen(IRIS_TEST_URL).read()
    with open(IRIS_TEST, "wb") as f:
      f.write(raw)
### 加载训练和测试集 ###
  # 载入数据集。
  training_set = tf.contrib.learn.datasets.base.load_csv_with_header(
      filename=IRIS_TRAINING, #文件名
      target_dtype=np.int, #标签的数据类型
      features_dtype=np.float32) #输入特征的数据类型

  # print(training_set)

  test_set = tf.contrib.learn.datasets.base.load_csv_with_header(
      filename=IRIS_TEST,
      target_dtype=np.int,
      features_dtype=np.float32)


### 构建深度神经网络分类器 ###
  # 指定训练集特征的数目和数据类型
  feature_columns = [tf.contrib.layers.real_valued_column("", dimension=4)]

  # 构建3层DNN（深度神经网络，全连接），分别为10,20,10个节点。
  classifier = tf.contrib.learn.DNNClassifier(feature_columns=feature_columns,
                                              hidden_units=[10, 20, 10],
                                              n_classes=3,
                                              model_dir="/tmp/iris_model")
### 描述训练输入管道 ###
  def get_train_inputs():
    x = tf.constant(training_set.data)
    y = tf.constant(training_set.target)

    return x, y

### 将模型连接到数据 ###
  classifier.fit(input_fn=get_train_inputs, steps=2000)

  # 定义测试输入数据x和标签y
  def get_test_inputs():
    x = tf.constant(test_set.data)
    y = tf.constant(test_set.target)

    return x, y

### 评估模型精度 ###
  # 评估准确性
  accuracy_score = classifier.evaluate(input_fn=get_test_inputs,
                                       steps=1)["accuracy"]

  print("\nTest Accuracy: {0:f}\n".format(accuracy_score))

### 应用训练好的模型 ###
  # 分类两个新鲜花样本。
  def new_samples():
    return np.array(
      [[6.4, 3.2, 4.5, 1.5],
       [5.8, 3.1, 5.0, 1.7]], dtype=np.float32)

  predictions = list(classifier.predict(input_fn=new_samples))

  print(
      "New Samples, Class Predictions:    {}\n"
      .format(predictions))

if __name__ == "__main__":
    main()

# Define the training inputs
def get_train_inputs():
  x = tf.constant(training_set.data)
  y = tf.constant(training_set.target)

  return x, y

classifier.fit(x=training_set.data, y=training_set.target, steps=1000)
classifier.fit(x=training_set.data, y=training_set.target, steps=1000)