tf基础

Tensorflow的运行方式

Tensorflow作为谷歌开源的深度学习框架，受到众多的人工智能开发人员欢迎。Tensorflow的数据控制单元，张量Tensor是一个可以定义为任意维度的数据，张量的阶Tensor’s rank就是张量的维度，例如：

零阶张量： 1   一个标量
一阶张量： [1，2，3]    一个向量 shape 3
二阶张量： [[1,2,3],[4,5,6]]   一个矩阵 shape 2x3
三阶张量： [[[1,2,3]],[[4,5,6]]]   shape：2x1x3

Tensorflow的编程主要分为两步，第一步构造计算图（computational Graph），第二步运行计算图。那么计算图是什么呢？
计算图是一系列由计算操作抽象出来的节点构成的结构，张量（Tensor）在这些节点之间流动运行，由此称该框架为Tensorflow。接下来我们就来介绍一下Tensorflow的基本概念

Constant常量

要使用Tensorflow我们首先需要导入该框架

    import tensorflow as tf 

Tensorflow中一个基础的节点类型就是constant，常量节点

    node_A = tf.constant(10,tf.float32)
    node_B = tf.constant(11,tf.int32)

所有的常量类型在定义时，就已经赋予了数值，而且其数值在后面的运行中是无法改变的。

Session会话

如果我们直接输出上面定义的两个节点时，例如

    print(node_A,node_B)

我们会得到下面的结果

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

这里输出的并不是我们想要的10和11，想要输出运行一个节点的结果，必须在一个会话Session中运行计算图，Tensor flow中的session很好的封装了其运行时的状态和控制，接下来我们定义一个会话，输出两个节点的值

    sess = tf.Session()
    a,b = sess.run([node_A,node_B])
    print(a,b)

输出如下：

10.0 11.0

Op计算节点

上面我们定义了两个常量节点和会话，并输出了节点的值，我们可以通过定义一些计算操作（Operation、Op）节点,构建更加复杂的计算
加法：

    node_C = tf.add(node_A,node_B)
    print(sess.run(node_C)) 

输出为

21.0

乘法：

    node_D = tf.multiply(node_A,node_B)
    print(sess.run(node_D)) 

输出为

110.0

Placehoder占位符

上面我们已经熟悉了常量类型以及一些运算符号的操作，Tensorflow的计算图还可以使用占位符placeholder参数化的从外部输入数据，简单来说placehold的作用就是给之后输入的值提前占位，设置这个结构的存在。

    # 这里是构造计算图的部分
    a=tf.placeholder(tf.float32)  
    b=tf.placeholder(tf.float32)  
    adder_node=a+b  
    #运行计算图  
    print("adder_node:",adder_node)  
    print(sess.run(adder_node,{a:3,b:4.5}))  
    print(sess.run(adder_node,{a:[1,3],b:[2,4]}))  

输出结果为：

adder_node: Tensor("add:0", dtype=float32)
7.5
[ 3.  7.]

在我们构建一个神经网络时，通常会为网络的输入输出构建一个placeholder占位符

Variable变量

在网络模型中，我们不光有常量类型，计算操作、输入输出占位符等，更多的是大量的变量类型，模型具有可训练能力，需要在一次次训练中修正计算图，使对于同样的输入得到新的输出。变量variable允许我们为计算图添加可变的训练参数
例如，我们构造一个线性模型

    定义图结构
    W=tf.Variable([.3],tf.float32)  
    b=tf.Variable([-.3],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]

TensorFlow 程序基本框架

1 准备数据

import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(-1,1,100)
y = 2*x+np.random.randn(100)*0.3

plt.plot(x,y)

[<matplotlib.lines.Line2D at 0x7f19750c6780>]

image.png

x_test = np.linspace(-1,1,10)
y_test = 2*x_test

plt.plot(x_test,y_test)

[<matplotlib.lines.Line2D at 0x7f197503c208>]

image.png

认识一个函数 tf.random_normal

import tensorflow as tf

W = tf.Variable(tf.random_normal(shape=[1]),name='weight')
W2 = tf.Variable(tf.random_normal(shape=[2]),name='weight')
W3 = tf.Variable(tf.random_normal(shape=[2,2]),name='weight')
init = tf.global_variables_initializer()
session = tf.Session()
session.run(init)
print(session.run(W))
print(session.run(W2))
print(session.run(W3))

[-1.0780782]
[ 1.7330054 -1.1080178]
[[ 0.5643331   1.7905867 ]
 [-0.03158719 -0.14434654]]

2 搭建模型

X = tf.placeholder(dtype=tf.float32,shape=None)
Y = tf.placeholder(dtype=tf.float32,shape=None)
W = tf.Variable(tf.random_normal(shape=[1]),name='weight')
b = tf.Variable(tf.zeros(shape=[1]),name='bais')
z = tf.multiply(W,X)+b

cost = tf.reduce_mean(tf.square(Y-z))  # 求平均值和平方
learning_rate = 0.01
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cost)

cost = tf.reduce_mean(tf.square(Y-z)) 求计算值z和真实值Y的均方误差

image.png

optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cost)

上面这行代码， 通过梯度下降法，在底层调整权重W和偏置b，使得均方误差cost（也即损失最小）。

train_epochs = 20
display_step = 2
init = tf.global_variables_initializer()

3 迭代模型

with tf.Session() as sess:
    sess.run(init)
    for epoch in range(train_epochs):
        for (x_s,y_s) in zip(x,y):
            sess.run(optimizer,feed_dict={X:x_s,Y:y_s})
        if epoch%display_step==0:
            loss = sess.run(cost,feed_dict={X:x_test,Y:y_test})
            print('epoch: ',epoch,' loss:',loss)
    print("x=0.2, z=",sess.run(z,feed_dict={X:0.2}))

epoch:  0  loss: 0.9508975
epoch:  2  loss: 0.071659505
epoch:  4  loss: 0.0039047264
epoch:  6  loss: 0.00013607423
epoch:  8  loss: 9.526675e-05
epoch:  10  loss: 0.0001471997
epoch:  12  loss: 0.0001647953
epoch:  14  loss: 0.00016962932
epoch:  16  loss: 0.00017089822
epoch:  18  loss: 0.00017122082
x=0.2, z= [0.38921914]

计算sess.run的第一个参数所需要的参数由sess.run的第二个参数给出，一般是一个字典。

从打印结果可以看出，随着训练批次的增加，网络训练出来了y=2x的线性关系（x=0.2, z= [0.38921914]），同时我们看到损失cost在不断减小。

4 定义输入节点的方法

(1) 占位符

X = tf.placeholder(dtype = tf.float32)

(2) 字典

input_dict = {'x': tf.placeholder(dtype=tf.float32),'y':tf.placeholder(dtype=tf.float32)}

5 定义学习参数

(1) 直接定义

W = tf.Variable(tf.random_normal([1]),name='weight')
b = tf.Variable(tf.zeros([1]),name='bias')

(2) 字典定义

para_dict = {'W':tf.Variable(tf.random_normal([1])),'b':tf.Variable(tf.zeros([1]))}
z = tf.multiply(x,para_dict['W'])+ para_dict['b']

6 初始化所有变量

init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)

0. 认识一个numpy方法np.newaxis

np.newaxis的作用就是在这一位置增加一个一维，这一位置指的是np.newaxis所在的位置，比较抽象，需要配合例子理解。
x1 = np.array([1, 2, 3, 4, 5])
# the shape of x1 is (5,)
x1_new = x1[:, np.newaxis]
# now, the shape of x1_new is (5, 1)
# array([[1],
#        [2],
#        [3],
#        [4],
#        [5]])
x1_new = x1[np.newaxis,:]
# now, the shape of x1_new is (1, 5)
# array([[1, 2, 3, 4, 5]])

再来一个例子

In [124]: arr = np.arange(5*5).reshape(5,5)

In [125]: arr.shape
Out[125]: (5, 5)

# promoting 2D array to a 5D array
In [126]: arr_5D = arr[np.newaxis, ..., np.newaxis, np.newaxis]

In [127]: arr_5D.shape
Out[127]: (1, 5, 5, 1, 1)

1.数据准备

从下图可以看出，变量a为1维的ndarray对象时，a[:, np.newaxis]与a.reshape(-1, 1)相同。

image

import numpy as np

X = np.linspace(-1, 1, 300)[:, np.newaxis].astype('float32')
noise = np.random.normal(0, 0.05, X.shape).astype('float32')
y = np.square(X) - 0.5 + noise

第1行代码导入numpy库，起别名np；
第3行代码调用np.linspace方法获得一个区间内的等间距点，例如np.linspace(0, 1, 11)是获取[0, 1]区间的11个等间距点。如下图所示：

image

第4行代码调用np.random.normal方法初始化符合正态分布的点，第1个参数是正态分布的均值，第2个参数是正态分布的方差，第3个参数是返回值的shape，返回值的数据类型为ndarray对象。
第5行代码调用np.square方法对X中的每一个值求平方，- 0.5使用了ndarray对象的广播特性，最后加上噪声noise，将计算结果赋值给变量y。

2.搭建神经网络

import tensorflow as tf 

Weights_1 = tf.Variable(tf.random_normal([1, 10]))
biases_1 = tf.Variable(tf.zeros([1, 10]) + 0.1)
Wx_plus_b_1 = tf.matmul(X, Weights_1) + biases_1
outputs_1 = tf.nn.relu(Wx_plus_b_1)
Weights_2 = tf.Variable(tf.random_normal([10, 1]))
biases_2 = tf.Variable(tf.zeros([1, 1]) + 0.1)
Wx_plus_b_2 = tf.matmul(outputs_1, Weights_2) + biases_2
outputs_2 = Wx_plus_b_2
loss = tf.reduce_mean(tf.square(y - outputs_2))
optimizer = tf.train.AdamOptimizer(0.1)
train = optimizer.minimize(loss)

第1行代码导入tensorflow库，起别名tf；
第3-6这4行代码定义神经网络中的输入层到第1隐层的连接；
第7-10这4行代码定义神经网络中的第1隐层到输出层的连接；
第3、7行代码定义Weights，它的形状是连接上一层神经元的个数*连接下一层神经元的个数；
第4、8行代码定义biases，它是二维矩阵，行数一直为1，列数为连接下一层神经元的个数，即它的形状为1*连接下一层神经元的个数；
第5、9行代码表示wx+b的计算结果;
第6行代码表示在第1个连接的输出结果，经过激活函数relu得出；
第10行代码表示在第2个连接的输出结果，因为此连接的下一层是输出层，所以不需要激活函数。
第11行代码定义损失函数，等同于回归预测中的MSE，中文叫做均方误差，数据类型如下图所示：

image

第12行代码调用tf.train库中的AdamOptimizer方法实例化优化器对象，数据类型如下图所示：

image

第13行代码调用优化器的minimize方法定义训练方式，参数为损失函数。方法的返回结果赋值给变量train，数据类型如下图所示：

image

3.变量初始化

init = tf.global_variables_initializer()
session = tf.Session()
session.run(init)

对于神经网络模型，重要是其中的W、b这两个参数。
开始神经网络模型训练之前，这两个变量需要初始化。
第1行代码调用tf.global_variables_initializer实例化tensorflow中的Operation对象。

image

第2行代码调用tf.Session方法实例化会话对象；
第3行代码调用tf.Session对象的run方法做变量初始化。

4.模型训练

模型训练200次，每运行1次代码session.run(train)则模型训练1次。
在训练次数为20的整数倍时，打印训练步数、loss值。

for step in range(201):
    session.run(train)
    if step % 20 == 0:
        print(step, 'loss:', session.run(loss))

上面一段代码的运行结果如下：

> 0 loss: 0.23739298
> 20 loss: 0.0074774586
> 40 loss: 0.0032493745
> 60 loss: 0.0026177235
> 80 loss: 0.0025075015
> 100 loss: 0.002472407
> 120 loss: 0.0024537172
> 140 loss: 0.002427246
> 160 loss: 0.002398049
> 180 loss: 0.002373801
> 200 loss: 0.002357695

5.完整代码

下面代码与前文相比，将搭建神经网络时重复定义Weights、biases的步骤封装成了函数。

import numpy as np
import tensorflow as tf 

X = np.linspace(-1, 1, 300)[:, np.newaxis].astype('float32')
noise = np.random.normal(0, 0.05, X.shape).astype('float32')
y = np.square(X) - 0.5 + noise

def addConnect(inputs, in_size, out_size, activation_function=None):
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)
    Wx_plus_b = tf.matmul(inputs, Weights) + biases
    if not activation_function:
        return Wx_plus_b
    else:
        return activation_function(Wx_plus_b)

connect_1 = addConnect(X, 1, 10, tf.nn.relu)
predict_y = addConnect(connect_1, 10, 1)
loss = tf.reduce_mean(tf.square(y - predict_y))
optimizer = tf.train.AdamOptimizer(0.1)
train = optimizer.minimize(loss)

init = tf.global_variables_initializer()
session = tf.Session()
session.run(init)

for step in range(201):
    session.run(train)
    if step % 20 == 0:
        print(step, 'loss:', session.run(loss))

上面一段代码的运行结果如下：

> 0 loss: 0.28191957
> 20 loss: 0.011470509
> 40 loss: 0.0044303066
> 60 loss: 0.003392854
> 80 loss: 0.0031887146
> 100 loss: 0.0030761429
> 120 loss: 0.0029888747
> 140 loss: 0.0029117232
> 160 loss: 0.0028402375
> 180 loss: 0.0027794265
> 200 loss: 0.0027436544

6.可视化

import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt

X = np.linspace(-1, 1, 300)[:, np.newaxis].astype('float32')
noise = np.random.normal(0, 0.05, X.shape).astype('float32')
y = np.square(X) - 0.5 + noise


def addConnect(inputs, in_size, out_size, activation_function=None):
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)
    Wx_plus_b = tf.matmul(inputs, Weights) + biases
    if not activation_function:
        return Wx_plus_b
    else:
        return activation_function(Wx_plus_b)


layer_1 = addConnect(X, 1, 10, tf.nn.relu)
predict_y = addConnect(layer_1, 10, 1)
loss = tf.reduce_mean(tf.square(y - predict_y))
optimizer = tf.train.AdamOptimizer(0.1)
train = optimizer.minimize(loss)

init = tf.global_variables_initializer()
session = tf.Session()
session.run(init)



for step in range(151):
    session.run(train)
    if step == 150:
        predict_value = session.run(predict_y)
        ax = plt.subplot(111)
        ax.scatter(X, y)
        plt.ylim(-0.65, 0.65)

        lines = ax.plot(X, predict_value, 'r-', lw=5)
        plt.title('step: %d loss: %.4f' % (step, session.run(loss)))
        plt.show()

可视化部分截图：

image