【TensorFlow】机器之心博客_学习笔记_基础知识

一、基础

第一章的笔记。之前有手写记录，所以这边基础知识就直接搬运了。

首先是导入TensorFlow。以及NumPy。

import tensorflow as tf

import numpy as np

1.1 张量和图

TensorFlow 是一种采用数据流图（data flow graphs），用于数值计算的开源软件库。其中 Tensor 代表传递的数据为张量（多维数组），Flow 代表使用计算图进行运算。数据流图用「结点」（nodes）和「边」（edges）组成的有向图来描述数学运算。「结点」一般用来表示施加的数学操作，但也可以表示数据输入的起点和输出的终点，或者是读取/写入持久变量（persistent variable）的终点。边表示结点之间的输入/输出关系。这些数据边可以传送维度可动态调整的多维数据数组，即张量（tensor）。

下面代码是使用计算图的案例：

在 Tensorflow 中，所有不同的变量和运算都是储存在计算图。所以在我们构建完模型所需要的图之后，还需要打开一个会话（Session）来运行整个计算图。在会话中，我们可以将所有计算分配到可用的 CPU 和 GPU 资源中。

如下所示代码，我们声明两个常量 a 和 b，并且定义一个加法运算。但它并不会输出计算结果，因为我们只是定义了一张图，而没有运行它：

1. a=tf.constant([1,2],name="a")

2. b=tf.constant([2,4],name="b")

3. result = a+b

4. print(result)

下面的代码才会输出计算结果，因为我们需要创建一个会话才能管理 TensorFlow 运行时的所有资源。但计算完毕后需要关闭会话来帮助系统回收资源，不然就会出现资源泄漏的问题。下面提供了使用会话的两种方式：

1.2 常量和变量

TensorFlow 中最基本的单位是常量（Constant）、变量（Variable）和占位符（Placeholder）。常量定义后值和维度不可变，变量定义后值可变而维度不可变。在神经网络中，变量一般可作为储存权重和其他信息的矩阵，而常量可作为储存超参数或其他结构信息的变量。下面我们分别定义了常量与变量：

 

 a = tf.constant(2, tf.int16)

 b = tf.constant(4, tf.float32)

 c = tf.constant(8, tf.float32)


 d = tf.Variable(2, tf.int16)

 e = tf.Variable(4, tf.float32)

 f = tf.Variable(8, tf.float32)




 g = tf.constant(np.zeros(shape=(2,2), dtype=np.float32))



 h = tf.zeros([11], tf.int16)

 i = tf.ones([2,2], tf.float32)

 j = tf.zeros([1000,4,3], tf.float64)


 k = tf.Variable(tf.zeros([2,2], tf.float32))

 l = tf.Variable(tf.zeros([5,6,5], tf.float32))

在上面代码中，我们分别声明了不同的常量（tf.constant()）和变量（tf.Variable()），其中 tf.float 和 tf.int 分别声明了不同的浮点型和整数型数据。而 tf.ones() 和 tf.zeros() 分别产生全是 1、全是 0 的矩阵。我们注意到常量 g，它的声明结合了 TensorFlow 和 Numpy，这也是可执行的。

w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))

以上语句声明一个 2 行 3 列的变量矩阵，该变量的值服从标准差为 1 的正态分布，并随机生成。TensorFlow 还有 tf.truncated_normal() 函数，即截断正态分布随机数，它只保留 [mean-2*stddev,mean+2*stddev] 范围内的随机数。

现在，我们可以应用变量来定义神经网络中的权重矩阵和偏置项向量：

weights = tf.Variable(tf.truncated_normal([256 * 256, 10]))

biases = tf.Variable(tf.zeros([10]))

print(weights.get_shape().as_list())

print(biases.get_shape().as_list())

#输出

>>>[65536, 10]

>>>[10]

1.3 占位符和 feed_dict

我们已经创建了各种形式的常量和变量，但 TensorFlow 同样还支持占位符。占位符并没有初始值，它只会分配必要的内存。在会话中，占位符可以使用 feed_dict 馈送数据。

feed_dict 是一个字典，在字典中需要给出每一个用到的占位符的取值。在训练神经网络时需要每次提供一个批量的训练样本，如果每次迭代选取的数据要通过常量表示，那么 TensorFlow 的计算图会非常大。因为每增加一个常量，TensorFlow 都会在计算图中增加一个结点。所以说拥有几百万次迭代的神经网络会拥有极其庞大的计算图，而占位符却可以解决这一点，它只会拥有占位符这一个结点。

下面一段代码分别展示了使用常量和占位符进行计算：

w1=tf.Variable(tf.random_normal([1,2],stddev=1,seed=1))


#因为需要重复输入x，而每建一个x就会生成一个结点，计算图的效率会低。所以使用占位符

x=tf.placeholder(tf.float32,shape=(1,2))

x1=tf.constant([[0.7,0.9]])


a=x+w1

b=x1+w1


sess=tf.Session()

sess.run(tf.global_variables_initializer())


#运行y时将占位符填上，feed_dict为字典，变量名不可变

y_1=sess.run(a,feed_dict={x:[[0.7,0.9]]})

y_2=sess.run(b)

print(y_1)

print(y_2)

sess.close

其中 y_1 的计算过程使用占位符，而 y_2 的计算过程使用常量。

下面是使用占位符的案例：

list_of_points1_ = [[1,2], [3,4], [5,6], [7,8]]

list_of_points2_ = [[15,16], [13,14], [11,12], [9,10]]


list_of_points1 = np.array([np.array(elem).reshape(1,2) for elem in list_of_points1_])

list_of_points2 = np.array([np.array(elem).reshape(1,2) for elem in list_of_points2_])



graph = tf.Graph()


with graph.as_default():  


    #我们使用 tf.placeholder() 创建占位符 ，在 session.run() 过程中再投递数据 

    point1 = tf.placeholder(tf.float32, shape=(1, 2))

    point2 = tf.placeholder(tf.float32, shape=(1, 2))


    def calculate_eucledian_distance(point1, point2):

        difference = tf.subtract(point1, point2)

        power2 = tf.pow(difference, tf.constant(2.0, shape=(1,2)))

        add = tf.reduce_sum(power2)

        eucledian_distance = tf.sqrt(add)

        return eucledian_distance


    dist = calculate_eucledian_distance(point1, point2)



with tf.Session(graph=graph) as session:

    tf.global_variables_initializer().run()  

    for ii in range(len(list_of_points1)):

        point1_ = list_of_points1[ii]

        point2_ = list_of_points2[ii]


        #使用feed_dict将数据投入到[dist]中

        feed_dict = {point1 : point1_, point2 : point2_}

        distance = session.run([dist], feed_dict=feed_dict)

        print("the distance between {} and {} -> {}".format(point1_, point2_, distance))



#输出：

>>> the distance between [[1 2]] and [[15 16]] -> [19.79899]

>>> the distance between [[3 4]] and [[13 14]] -> [14.142136]

>>> the distance between [[5 6]] and [[11 12]] -> [8.485281]

>>> the distance between [[7 8]] and [[ 9 10]] -> [2.8284271]

下面，我们将先解析一段构建了三层全连接神经网络的代码。

import tensorflow as tf

from numpy.random import RandomState



batch_size=10

w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))

w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))



# None 可以根据batch 大小确定维度，在shape的一个维度上使用None

x=tf.placeholder(tf.float32,shape=(None,2))

y=tf.placeholder(tf.float32,shape=(None,1))



#激活函数使用ReLU

a=tf.nn.relu(tf.matmul(x,w1))

yhat=tf.nn.relu(tf.matmul(a,w2))



#定义交叉熵为损失函数，训练过程使用Adam算法最小化交叉熵

cross_entropy=-tf.reduce_mean(y*tf.log(tf.clip_by_value(yhat,1e-10,1.0)))

train_step=tf.train.AdamOptimizer(0.001).minimize(cross_entropy)


rdm=RandomState(1)

data_size=516



#生成两个特征，共data_size个样本

X=rdm.rand(data_size,2)

#定义规则给出样本标签，所有x1+x2<1的样本认为是正样本，其他为负样本。Y，1为正样本

Y = [[int(x1+x2 < 1)] for (x1, x2) in X]


with tf.Session() as sess:

    sess.run(tf.global_variables_initializer())

    print(sess.run(w1))

    print(sess.run(w2))

    steps=11000

    for i in range(steps):



        #选定每一个批量读取的首尾位置，确保在1个epoch内采样训练

        start = i * batch_size % data_size

        end = min(start + batch_size,data_size)

        sess.run(train_step,feed_dict={x:X[start:end],y:Y[start:end]})

        if i % 1000 == 0:

            training_loss= sess.run(cross_entropy,feed_dict={x:X,y:Y})

            print("在迭代 %d 次后，训练损失为 %g"%(i,training_loss))

上面的代码定义了一个简单的三层全连接网络（输入层、隐藏层和输出层分别为 2、3 和 2 个神经元），隐藏层和输出层的激活函数使用的是 ReLU 函数。该模型训练的样本总数为 512，每次迭代读取的批量为 10。这个简单的全连接网络以交叉熵为损失函数，并使用 Adam 优化算法进行权重更新。

其中需要注意的几个函数如 tf.nn.relu() 代表调用 ReLU 激活函数，tf.matmul() 为矩阵乘法等。tf.clip_by_value(yhat,1e-10,1.0) 这一语句代表的是截断 yhat 的值，因为这一语句是嵌套在 tf.log() 函数内的，所以我们需要确保 yhat 的取值不会导致对数无穷大。

tf.train.AdamOptimizer(learning_rate).minimize(cost_function) 是进行训练的函数，其中我们采用的是 Adam 优化算法更新权重，并且需要提供学习速率和损失函数这两个参数。后面就是生成训练数据，X=rdm.rand(512,2) 表示随机生成 512 个样本，每个样本有两个特征值。最后就是迭代运行了，这里我们计算出每一次迭代抽取数据的起始位置（start）和结束位置（end），并且每一次抽取的数据量为前面我们定义的批量，如果一个 epoch 最后剩余的数据少于批量大小，那就只是用剩余的数据进行训练。最后两句代码是为了计算训练损失并迭代一些次数后输出训练损失。这一部分代码运行的结果如下：