0、安装tensorflow

• 安装方法并不困难，只需要按照tensorflow官网https://www.tensorflow.org/install/（中文显示）的指导完成就行。有各个操作系统下的安装指导。
• 大致分为以下步骤

1、安装python3（更推荐直接安装包括了python3基本库以及多个科学计算库"numpy、sklearn等"的Anaconda）
2、在Anaconda里面再下载安装tensorflow（34MB左右大小）
3、tensorflow分为普通版和GPU版，若有GPU则应安装GPU版。

1、从名字理解tensorflow

• tensor
  即张量的意思，也可以理解为我们常见的矩阵，但每一个tensor是一个实例对象。矩阵里面有很多由同一个基本数据类型组成的数据元素。所以tensor可以理解为tensorflow这种学习框架最常用的一种数据类型。
• flow
  即流动的意思。
• tensor+flow
  意为矩阵形式的数据在流动，流动就会产生变化。所以tensorflow的目的就是让矩阵形式的数据经过一系列矩阵变换，得到我们想要的矩阵。

2、tensor是怎么flow的？数据在哪里流动？数据流动过程中怎么发生变化？

• graph
  

  图，地图，流程图，计算图。类似现实中的黄河流域图，在图中能看到多个节点和路线。有多个地方有水流入黄河主干也有多个地方有水流出。黄河的水在经过各个节点后颜色有变化，黄河的源头在青藏高原，水很清澈，在流经兰州后变黄，然后在流经银川到陕西、山西、河南洛阳这一带水特别浑浊污染严重，最后流入海洋的水也早已经不是源头的清水。
  黄河流域图.jpg

tensorflow的数据流动过程图.gif

计算图

图中tensor如何发生变化？

• w、x和b就是3个不同的tensor矩阵数据，作为输入节点——input tensor
• MatMul、Add和ReLU，是3个计算节点，分别代表3个对矩阵的不同的操作，就是这些操作使得tensor数据发生变化——operator
• C是由3个输入矩阵经过一系列变化后的输出数据——output tensor

3、我们要怎么运行tensorflow？

tensorflow的运行流程主要有2步，分别是构建模型和运行模型。

3.1、构建模型

• 在构建模型阶段，我们需要通过代码构建一个图来描述我们的模型。所谓图，可以理解为流程图，就是将数据的输入节点->中间处理节点->输出节点整个流程用代码表示出来。并为每个节点命名，以便我们可以通过名字来访问这些节点。
• 例如，要构建下图中的模型，那表达式就是

Y=W*X+b ————W为权重矩阵，b为偏差
C=ReLU(Y) ————激活函数ReLU：yi=max(0,yi)，即矩阵Y中负数全替换为0

计算流程图Graph

• 构建模型的代码如下：

import tensorflow as tf
import numpy as np

# 计算图，不加这一行也会提供一个默认图
myGraph = tf.get_default_graph()

# 多个tensor数据节点
X = tf.placeholder(name="input", shape=[2, 1], dtype=tf.int32)
W = tf.get_variable(name="weight", shape=[2, 2], dtype=tf.int32,
               initializer=tf.constant_initializer([[-1, 1], [-1, -1]]))
b = tf.get_variable(name="bias", shape=[2, 1], dtype=tf.int32,
               initializer=tf.constant_initializer([1, 1]))

# 多个operation操作节点
Y = tf.matmul(W, X) + b
C = tf.nn.relu(Y)

上面的模型Y=W*X+b 就是构成神经网络的基础——神经元。函数f(⋅)也被称为是神经元的激活函数。一定是带有激活函数的才是一个神经元。

神经元

上面的一层神经网络模型

一层神经网络

• 一般构建两层就可以认为是一个神经网络，更多层就可以认为是深度神经网络也就是深度学习。

——两层神经网络，隐藏层就是指除输入层和输出层外的所有中间层，中间层的数据一般是不用关心的，所以叫隐藏层（或隐含层，类似黑盒子）。一般输入层数据X都认为是一个神经元，而x1,x2,x3,xn这些只是一个输入X的不同维度的数据，或者不当做神经元。中间隐含层的每层多个圆表示多个神经元。

两层神经网络图.jpg

——普通的多层神经网络又叫多层感知机

多层感知机.jpg

——卷积神经网络，某些神经元的输入信息只和部分前一层输出神经元有关。

卷积神经网络图.jpg

——循环神经网络，某些神经元的输入信息，不仅包括前一层的输出，还包括它自身先前状态。也就是引入了时间上的循环，有记忆功能。

循环神经网络.jpg

3.2运行模型

• 模型也可以理解为模板，是抽象的。只能在给这个模板输入不同的X，得到不同的Y和C时，才能称为一次模板的实现。为了区分不同的模板实现，tensorflow引入了session来控制。
• session即会话的意思，常用在网络通信协议中表示一个会话控制对象，session 对象存储特定用户会话所需的属性及配置等信息。

• 如果不使用session，直接打印tensor只能看到对象信息，看不到具体的数据，如下代码打印结果：
  未使用session
• 在session内run运行这些tensor节点才能看到具体的数据，而且所有的operation操作节点也必须在session内run才能执行。

import tensorflow as tf
import numpy as np

# 计算图，不加这一行也会提供一个默认图
myGraph = tf.get_default_graph()

# 多个tensor
hello = tf.constant("hello world !")
X = tf.placeholder(name="input", shape=[2, 1], dtype=tf.int32)
W = tf.get_variable(name="weight", shape=[2, 2], dtype=tf.int32,
                  initializer=tf.constant_initializer([[-1, 1], [-1, -1]]))
b = tf.get_variable(name="bias", shape=[2, 1], dtype=tf.int32,
                  initializer=tf.constant_initializer([1, 1]))

# 操作operation
Y = tf.matmul(W, X) + b
C = tf.nn.relu(Y)

print("打印tensor：")
print(hello)
print(X)
print(W)

# 开始运行计算图
sess = tf.Session()
# 必须先初始化所有变量，并分配内存
sess.run(tf.global_variables_initializer())
print(sess.run(hello))
print("W=", sess.run(W))
# 注意，用tensorflow产生的tensor只是一个类实例对象，
# 必须在执行run之后才能变成实际的矩阵
# x_matrix = tf.ones(shape=[2, 1], dtype=tf.int32)
x_matrix = np.reshape([1, 1], (2, 1))
print("X=\n",x_matrix)
print("b=\n", sess.run(b))
# 给定输入值
x_input = myGraph.get_tensor_by_name("input:0")
print("Y=W*X+b=\n", sess.run(Y, feed_dict={x_input: x_matrix}))
print("C=ReLU(Y)=\n", sess.run(C, feed_dict={X: x_matrix}))

sess.close()

• 输出结果如下：
  使用session

矩阵运算

4、怎么用tensorflow来做一个机器学习模型？

主要分为以下四个步骤：

• 前向传播：模型训练，得到输出结果与实际结果的误差（损失）值loss

1、构建模型
2、设计损失函数loss

• 反向传播：目的是通过优化函数，如梯度下降法去反向调整模型的变量——权重矩阵W和偏置b，使得loss函数取得最小值

设计优化函数

• 训练模型：用更新的W和b再次进行训练，得到新的loss。设计循环重复进行训练，希望得到满意的loss，当然也可能模型设计的有问题得不到loss最小值。
• 保存和使用模型：也就是保存变量W和b的值。在用于预测时加载这个模型，就可以得到分类结果。

代码如下：

import tensorflow as tf
import numpy as np

# 计算图，不加这一行也会提供一个默认图
myGraph = tf.get_default_graph()

# 训练得到的模型保存的地址
model_path = "D:/src/ML_DL/models/model.ckpt"

# 多个tensor
hello = tf.constant("hello world !")
X = tf.placeholder(name="input", shape=[2, 1], dtype=tf.float32)
W = tf.get_variable(name="weight", shape=[2, 2], dtype=tf.float32,
                initializer=tf.constant_initializer([[1, 1], [1, 1]]))
b = tf.get_variable(name="bias", shape=[2, 1], dtype=tf.float32,
                initializer=tf.constant_initializer([0, 0]))
target = tf.placeholder(name="lables", shape=[2, 1], dtype=tf.float32)


# 1、构建模型
Y = tf.matmul(W, X) + b
# 2、损失函数，简单设计为均方误差的求和
err = 0.5*(Y - target)**2
loss = tf.reduce_sum(err)
# 3、优化函数，梯度下降法去求使得loss函数有最小值的最优的W和b
# 参数0.1是学习率，可以控制每次下降的速度
back_transfer = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

# 提供输入值x和对应的目标值
x_matrix = np.reshape([0.9, 1.1], (2, 1))
target_matrix = np.reshape([1, 1], (2, 1))
accuracy = (1-loss)*100.0
# 查看系统自动分配的tensor名字，如果自己不设定name的话
print(Y)

# 开始运行计算图
sess = tf.Session()
# 必须先初始化所有变量，并分配内存
sess.run(tf.global_variables_initializer())
print(sess.run(hello))
for i in range(20):
    print("=======第%d次训练====================" % (i+1))
    print("W=\n", sess.run(W))
    print("X=\n", x_matrix)
    print("b=\n", sess.run(b))
    x_input = myGraph.get_tensor_by_name("input:0")
    print("Y=W*X+b=\n", sess.run(Y, feed_dict={x_input: x_matrix}))
    print("target=\n", target_matrix)
    print("err = 0.5*(Y - target)**2=\n", sess.run(err, 
                    feed_dict={X: x_matrix, target: target_matrix}))
    print("loss=\n", sess.run(loss, 
                    feed_dict={X: x_matrix, target: target_matrix}))
    acc = sess.run(accuracy, 
                    feed_dict={X: x_matrix, target: target_matrix})
    print("预测准确度= %", acc)
    # 可以在适当的时候保存模型，并结束训练
    if acc > 99.5:
        saver = tf.train.Saver()
        saver.save(sess, model_path)
        break

    # 执行反向传递，根据梯度下降法来更新变量——权重W和偏差b
    sess.run(back_transfer, feed_dict={X: x_matrix, target: target_matrix})

sess.close()

程序运行结果：

Tensor("add:0", shape=(2, 1), dtype=float32)
b'hello world !'
=======第1次训练====================
W=
 [[1. 1.]
 [1. 1.]]
X=
 [[0.9]
 [1.1]]
b=
 [[0.]
 [0.]]
Y=W*X+b=
 [[2.]
 [2.]]
target=
 [[1]
 [1]]
err = 0.5*(Y - target)**2=
 [[0.5]
 [0.5]]
loss=
 1.0
预测准确度= % 0.0
=======第2次训练====================
W=
 [[0.91 0.89]
 [0.91 0.89]]
X=
 [[0.9]
 [1.1]]
b=
 [[-0.1]
 [-0.1]]
Y=W*X+b=
 [[1.6980001]
 [1.6980001]]
target=
 [[1]
 [1]]
err = 0.5*(Y - target)**2=
 [[0.24360205]
 [0.24360205]]
loss=
 0.4872041
预测准确度= % 51.279594
=======第3次训练====================
W=
 [[0.84718    0.81321996]
 [0.84718    0.81321996]]
X=
 [[0.9]
 [1.1]]
b=
 [[-0.16980001]
 [-0.16980001]]
Y=W*X+b=
 [[1.4872038]
 [1.4872038]]
target=
 [[1]
 [1]]
err = 0.5*(Y - target)**2=
 [[0.11868379]
 [0.11868379]]
loss=
 0.23736759
预测准确度= % 76.263245
=======第4次训练====================
W=
 [[0.8033317 0.7596275]
 [0.8033317 0.7596275]]
X=
 [[0.9]
 [1.1]]
b=
 [[-0.2185204]
 [-0.2185204]]
Y=W*X+b=
 [[1.3400683]
 [1.3400683]]
target=
 [[1]
 [1]]
err = 0.5*(Y - target)**2=
 [[0.05782324]
 [0.05782324]]
loss=
 0.115646474
预测准确度= % 88.43535
=======第5次训练====================
W=
 [[0.7727255 0.72222  ]
 [0.7727255 0.72222  ]]
X=
 [[0.9]
 [1.1]]
b=
 [[-0.25252724]
 [-0.25252724]]
Y=W*X+b=
 [[1.2373676]
 [1.2373676]]
target=
 [[1]
 [1]]
err = 0.5*(Y - target)**2=
 [[0.0281717]
 [0.0281717]]
loss=
 0.05634339
预测准确度= % 94.36566
=======第6次训练====================
W=
 [[0.75136244 0.69610953]
 [0.75136244 0.69610953]]
X=
 [[0.9]
 [1.1]]
b=
 [[-0.276264]
 [-0.276264]]
Y=W*X+b=
 [[1.1656828]
 [1.1656828]]
target=
 [[1]
 [1]]
err = 0.5*(Y - target)**2=
 [[0.01372539]
 [0.01372539]]
loss=
 0.027450787
预测准确度= % 97.25492
=======第7次训练====================
W=
 [[0.73645097 0.6778844 ]
 [0.73645097 0.6778844 ]]
X=
 [[0.9]
 [1.1]]
b=
 [[-0.2928323]
 [-0.2928323]]
Y=W*X+b=
 [[1.1156465]
 [1.1156465]]
target=
 [[1]
 [1]]
err = 0.5*(Y - target)**2=
 [[0.00668705]
 [0.00668705]]
loss=
 0.013374109
预测准确度= % 98.66259
=======第8次训练====================
W=
 [[0.7260428 0.6651633]
 [0.7260428 0.6651633]]
X=
 [[0.9]
 [1.1]]
b=
 [[-0.30439693]
 [-0.30439693]]
Y=W*X+b=
 [[1.0807211]
 [1.0807211]]
target=
 [[1]
 [1]]
err = 0.5*(Y - target)**2=
 [[0.00325795]
 [0.00325795]]
loss=
 0.0065159025
预测准确度= % 99.34841
=======第9次训练====================
W=
 [[0.7187779 0.656284 ]
 [0.7187779 0.656284 ]]
X=
 [[0.9]
 [1.1]]
b=
 [[-0.31246904]
 [-0.31246904]]
Y=W*X+b=
 [[1.0563436]
 [1.0563436]]
target=
 [[1]
 [1]]
err = 0.5*(Y - target)**2=
 [[0.0015873]
 [0.0015873]]
loss=
 0.0031745962
预测准确度= % 99.68254

Process finished with exit code 0

反向传播，梯度下降法优化函数推导过程

反向传播数学推导1

反向传播数学推导2

上图中η为学习率，控制每次下降的速度

第9次训练就结束了

保存的模型

5、使用训练好的模型做预测

使用保存好的模型

代码如下：

import tensorflow as tf
import numpy as np

# 测试刚才保存的模型的变量是不是我们最后训练得到的
sess = tf.Session()
saver = tf.train.import_meta_graph("D:/src/ML_DL/models/model.ckpt.meta")
saver.restore(sess, tf.train.latest_checkpoint("D:/src/ML_DL/models/"))
graph2 = tf.get_default_graph()
weight = graph2.get_tensor_by_name("weight:0")
bias = graph2.get_tensor_by_name("bias:0")
print("weight=\n", sess.run(weight))
print("bias=\n", sess.run(bias))
# 输入相同的X值，查看输出Y是否与之前的一样
input_x = graph2.get_tensor_by_name("input:0")
x_value = np.reshape([0.9, 1.1], (2, 1))
output_y = graph2.get_tensor_by_name("add:0")
print("Y=\n", sess.run(output_y, feed_dict={input_x: x_value}))
sess.close()

更详细的总结博客：https://blog.csdn.net/ztf312/article/details/72722184