TensorFlow基础概念和编程（第一讲）

╰+攻爆jí腚メ 2022-04-13 05:54 655阅读 0赞

# TensorFlow基本概念 #

### A machine learning platform for everyone to solve real problems ###

TensorFlow = Tensor + Flow；

Tensor 张量：代表的是一种多维数组的数据结构

Flow 流：张量之间通过计算而转换的过程

TensorFlow是一个通过计算图的形式表达计算的编程系统，每一个计算都是计算图上的一个点，节点之间的边描述了计算之间的关系。

### 计算图（数据流图）的概念 ###

计算图是一个有向图，由以下内容组成：

*  一个节点，每个节点都代表一个操作，是一种运算
 *  一组有向边，每条边代表节点之间的关系（数据传递和控制依赖）

TensorFlow有两种边：

*  常规边（实线）：代表数据依赖关系。一个节点的运算输出成为另一个节点的输入，两个节点之间有tensor流动（值传递）
 *  特殊边（虚线）：不携带值，表示两个节点之间的控制相关性。比如，happens-before关系，源节点必须在目的节点执行前完成执行

![20181127200155488.jpg][]

### 计算图实例 ###

import tensorflow as tf
    node1 = tf.constant(3.0, tf.float32, name="node1")
    node2 = tf.constant(4.0, tf.float32, name="node2")
    node3 = tf.add(node1, node2)
    print(node3)

内部会生成一个流图，不会显示，可以利用tensorboard显示。print输出的是“Tensor("Add\_1:0", shape=(), dtype=float32)”，证明输出的不是一个确定的数据，而是一个张量的结构。为了能够输出我们想要看到的那种数据类型，想要加上一点代码：

import tensorflow as tf
    #name虽然可以不填，但是为了方便，我们一般都直接写上
    node1 = tf.constant(3.0, tf.float32, name="node1")
    node2 = tf.constant(4.0, tf.float32, name="node2")
    node3 = tf.add(node1, node2)
    print(node3)
    
    #创建对话并显示运算结果
    sess = tf.Session()
    print(sess.run(node1))
    print(sess.run(node3))
    
    #关闭session
    #如果下面不进行其他操作了，可以关闭session，可以把相关的资源释放出来，关闭之后就不能再调用session了。需要重新创建对话
    sess.close()
    
    #分别输出3.0和7.0

### Tensor张量 ###

在TensorFlow中，所有的数据都是通过张量的形式来表示

从功能的角度上来说，张量可以简单理解为多维数组：

*  零阶张量表示标量，也就是一个数
 *  一阶张量为向量，也就是一维数组
 *  n阶张量可以理解为一个n维数组
 *  张量并没有真正保存数字，它保存的是计算过程，前面的node打印出来就可以看出来

张量的属性：“Tensor("Add\_1:0", shape=(), dtype=float32)”：

*  这个“Add\_1:0”其实是“node:src\_output”的具体表现；node表示节点名称，src\_output表示来自节点的第几个输出
 *  形状：张量的维度信息，shape=()，表示是标量
 *  类型：每一个张量会有一个唯一的类型
 *  TensorFlow会对参与运算的所有张量进行类型的检查，发现类型不匹配时会报错

张量的形状：

<table> 
 <tbody> 
  <tr> 
   <td>阶</td> 
   <td>形状</td> 
   <td>维数</td> 
   <td>例子</td> 
  </tr> 
  <tr> 
   <td> <p>0</p> </td> 
   <td>()</td> 
   <td>0-D</td> 
   <td>4</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>(D0)</td> 
   <td>1-D</td> 
   <td>[2, 3]</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>(D1,D1)</td> 
   <td>2-D</td> 
   <td>[[2],[3]]</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>(D0,D1,D2)</td> 
   <td>3-D</td> 
   <td>[[[1],[2]],[[3]]]</td> 
  </tr> 
  <tr> 
   <td>N</td> 
   <td>(D0,D1....Dn-1)</td> 
   <td>n-D</td> 
   <td>n阶的张量</td> 
  </tr> 
 </tbody> 
</table>

小插曲：直接用get\_shape()函数获得...，观察的话太麻烦了...

### 获取张量中的向量 ###

import tensorflow as tf
    tens1 = tf.constant([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], name="tens1")
    print(tens1)
    
    sess = tf.Session()
    print(sess.run(tens1)[1,1,0])
    sess.close()
    
    #输出为Tensor("tens1_1:0", shape=(2, 2, 2), dtype=int32)
    #7

### 张量的类型 ###

TensorFlow支持14种不同的类型

实数：tf.float32, tf.float64

整数：tf.int8, tf.int16, tf.int32, tf.int64

布尔：tf.bool

复数：tf.complex64，tf.complex128

默认类型：不带小数点的数会被默认为int32，带小数点的会被默认为float32。

下面这段代码会报错，因为张量在执行的过程中会对类型进行严格的检查，如果不同类型是不能进行操作的

import tensorflow as tf
    a = tf.costant([1, 2], name='a')
    b = tf.constant([2.0, 3.0], name='b')
    result = a + b

### operation ###

*  计算中的节点就是操作，一次加法是一次操作，一次乘法也是一次操作，构建一些变量的初始值也是一个操作
 *  每个运算操作都有属性，它在构建图的时候需要确定下来
 *  操作可以和计算设备绑定，指定操作在某设备上执行
 *  操作之间存在顺序关系，这些操作就是依赖“边”
 *  如果操作A的输入是操作B执行的结果，那么操作A就依赖于操作B

看代码：(tensorboard的相关知识后面再进行补充)

import tensorflow as tf
    #清除default graph和不断增加的节点
    tf.reset_default_graph()
    #定义变量A
    a = tf.Variable(1, tf.int32, name='a')
    b = tf.add(a, 1, name='b')
    c = tf.multiply(a, 2, name='c')
    d = tf.subtract(c, b, name='d')
    #logdir改写自己机器上的合适路径
    logdir = r'D:\picture'
    #生成一个写日志的writer，并在当前的TensorFlow计算图写上日志
    writer = tf.summary.FileWriter(logdir, tf.reset_default_graph())
    writer.close()

## TensorFlow运行模型--会话 ##

会话拥有并管理TensorFlow程序运行时的所有资源，当所有计算完成之后需要关闭会话帮助系统回收资源。

会话的模式除了上面直接创建一个会话之后还有一种模式：

import tensorflow as tf
    node1 = tf.constant(3.0, tf.float32, name="node1")
    node2 = tf.constant(4.0, tf.float32, name="node2")
    node3 = tf.add(node1, node2)
    
    #创建一个会话，并通过Python的上下文管理器来管理这个会话
    with tf.Session() as sess:
        #使用这创建的会话来运行关心的结果
        print(sess.run(node3))
        
    #不需要再次调用Session.close()函数，在上下文管理器结束的时候系统会默认关闭和释放资源

### 指定默认的会话 ###

TensorFlow不会自动生成默认的会话，需要手动指定。当默认的会话被指定之后可以通过tf.Tensor.eval()函数来计算一个张量的取值。

import tensorflow as tf
    node1 = tf.constant(3.0, tf.float32, name="node1")
    node2 = tf.constant(4.0, tf.float32, name="node2")
    node3 = tf.add(node1, node2)
    sess = tf.Session()
    #创建一个会话，设置这个会话作为默认的会话
    with sess.as_default():
        #使用这创建的会话来运行关心的结果
        print(node3.eval())

### 交互环境下设置默认会话 ###

在交互模式下，Python脚本或者jupyter编辑器下，通过设置默认会话来获取张量的取值更加方便。tf.InteractiveSession使用这个函数会自动将生成的会话注册为默认会话

import tensorflow as tf
    node1 = tf.constant(3.0, tf.float32, name="node1")
    node2 = tf.constant(4.0, tf.float32, name="node2")
    node3 = tf.add(node1, node2)
    
    #创建一个会话，设置这个会话作为默认的会话
    sess = tf.InteractiveSession()
    print(node3.eval())
    sess.close()

## tensorflow的基本运算 ##

### 常量和变量 ###

常量在运行过程中不会改变的单元，在TensorFlow中无需进行初始化操作，创建语句：

constant\_name = tf.constant(value)

变量是在运行过程中值会改变的单元，在TensorFlow中须进行初始化操作。创建语句：

name\_variable = tf.Variable(value.name)

个别变量的初始化：

init\_op = name\_variable.initializer()

所有变量的初始化：

init\_op = tf.global\_variables\_initializer()

import tensorflow as tf
    node1 = tf.Variable(3.0, tf.float32, name="node1")
    node2 = tf.Variable(4.0, tf.float32, name="node2")
    node3 = tf.add(node1, node2, name='add')
    
    sess = tf.Session()
    
    #变量初始化
    init = tf.global_variables_initializer()
    #必须要先运行初始化，如果没有这句话会报错，还是没有初始化
    sess.run(init)
    print(sess.run(node3))

### 变量的赋值 ###

与传统的编程语言不同，TensorFlow中的变量定义后，一般无需人工赋值，系统会根据算法模型训练优化过程中自动调整变量对应的数值。后面在将机器学习模型训练时会更有体会，比如权重weight变量w，经过多次迭代会自动调用。

特殊的情况下需要人工赋值的，可用变量赋值语句：

update\_op = tf.assign(variable\_to\_be\_updateed, new\_value)

#通过变量赋值输出1、2、3、4、5...10
    import tensorflow as tf
    value = tf.Variable(0, name='value')
    one = tf.constant(1, name='one')
    new_value = tf.add(value, one)
    #将new_value赋值给value
    update_value = tf.assign(value, new_value)
    
    init = tf.global_variables_initializer()
    with tf.Session() as sess:
        sess.run(init)
        #运行十次
        for _ in range(10):
            #run一下updatevalue
            sess.run(update_value)
            print(sess.run(value))

## 占位符 placeholder ##

tensorflow中的Variable变量类型，在定义时需要初始化，但有些变量定义时并不知道其数值，只有当真正开始运行程序的时候才由外部输入，比如训练数据，这时候需要占位符。tf.placeholder占位符，是TensorFlow中特有的一种数据结构，类似动态变量，函数的参数，或者C语言中格式化输出时的‘%’占位符。占位符的函数接口如下：

tf.placeholder(dtype, shape=None, name=None)

x = tf.placeholder(tf.float32, [2, 3], name='tx')
    #代码生成一个2*3的二维数组，矩阵中每个元素的类型都是tf.float32，内部对应的名称为tx

### Feed提交数据和Fetch提取数据 ###

Feed提交数据：如果构建了一个包含placeholder操作的计算图，当在Session中调用run方法时，placeholder占用的变量必须通过feed\_dict参数传递进去，否则报错。

import tensorflow as tf
    a = tf.placeholder(tf.float32, name='a')
    b = tf.placeholder(tf.float32, name='b')
    c = tf.multiply(a, b, name='c')
    init = tf.global_variables_initializer()
    
    with tf.Session() as sess:
        #下面这句话和上面的初始化语句可以直接注掉，因为placeholder不是Variable，所以可以不应运行初始化
        sess.run(init)
        #通过feed_dict的参数传递，按字典格式
        result = sess.run(c, feed_dict={a:8.0, b:3.5})
        print(result)

多个操作可以通过一次Feed完成执行：看代码

import tensorflow as tf
    import numpy as np
    a = tf.placeholder(tf.float32, name='a')
    b = tf.placeholder(tf.float32, name='b')
    c = tf.multiply(a, b, name='c')
    d = tf.subtract(a, b, name='d')
    init = tf.global_variables_initializer()
    
    with tf.Session() as sess:
        sess.run(init)
        #通过feed_dict的参数传递，按字典格式
        result = sess.run([c,d], feed_dict={a:[8.0, 2.0, 3.0], b:[3.5, 2.0, 4.0]})
        rc,rv = sess.run([c,d], feed_dict={a:[8.0, 2.0, 3.0], b:[3.5, 2.0, 4.0]})
        print(result)
        print(np.array(result).shape)
        print(result[0])

### TensorBoard可视化初步 ###

TensorBoard是TensorFlow的可视化工具，通过TensorFlow程序运行过程中输出的日志文件可视化TensorFlow程序的运行状态。TensorBoard和TensorFlow程序跑在不同的进程中。

#在TensorBoard中查看图结构
    import tensorflow as tf
    #清除default_graph和不断增加的节点
    tf.reset_default_graph()
    
    #logdir改成自己机器上的合适路径
    logdir = 'D:\picture'
    
    #定义一个简单的计算图，实现向量加法的操作
    input1 = tf.constant([1.0,2.0,3.0], name='input1')
    input2 = tf.Variable(tf.random_uniform([3]), name='input2')
    output = tf.add_n([input1, input2], name='add')
    
    #生成一个写日志的writer，并将当前的TensorFlow计算图写入日志
    writer = tf.summary.FileWriter(logdir, tf.get_default_graph())
    writer.close()

### 启动TensorBoard ###

在Anaconda Prompt中先进入日志存放的目录（非常重要！！！），然后返回至上一层，继续敲命令。

命令：tensorboard --logdir=path，Google浏览器，其他浏览器不太好，一般我们画的都是图示，所以要到graph中去找。

# 单变量线性回归--TensorFlow实战 #

简单的线性回归：这里就不介绍了...

### 使用TensorFlow进行算法设计与训练的核心步骤 ###

*  准备数据
 *  构建模型
 *  训练模型
 *  进行预测

看例子：随机生成一个近似采样随机分布，使得w=2.0, b=1,并加入一个噪声，噪声的最大振幅为0.4；

构建模型：

定义训练数据的占位符，x是特征值，y是标签值

x = tf.placeholder("float", name='x')

y = tf.placeholder("float", name='y')

定义模型函数：

def model(x, w, b):

return tf.multiply(x, w) + b

创建变量：

*  TensorFlow变量的声明函数是tf.Variable
 *  tf.Variable的作用是保存和更新参数
 *  变量的初始值可以是随机数、常数、或是通过其他变量的初始值计算得到

#构建变量的初始值
    w = tf.Variable(1.0, name="w0")
    b = tf.Variable(0.0, name="b0")
    #pred是预测值，前向计算
    pred = model(x, w, b)

#在jupyter中，使用matplotlib显示图像需要设置为inline模式，否则不会显示图像
    %matplotlib inline
    import matplotlib.pyplot as plt
    import numpy as np
    import tensorflow as tf
    
    #设置随机数种子，为了得到相同的随机数
    np.random.seed(5)
    #直接采用等差数列的方式，生成100个点，每个点的取值在-1,1之间
    x_data = np.linspace(-1, 1, 100)
    #y = 2*x + 1 + 噪声，其中噪声的纬度应与x_data一致
    #实参前面加上*就相当于拆包，单个*表示将元组拆成一个个单独的实参
    y_data = 2 * x_data + 1.0 + np.random.randn(*x_data.shape) * 0.4
    #画出随机生成数据的散点图
    plt.scatter(x_data, y_data)
    #画出我们想要的线性函数
    plt.plot(x_data, 1.0 + 2.0 * x_data, color='red', linewidth=3)
    
    x = tf.placeholder("float", name='x')
    y = tf.placeholder("float", name='y')
    def model(x, w, b):
        return tf.multiply(x, w) + b
       #return tf.multiply(x, w) + b
    #构建变量的初始值
    w = tf.Variable(1.0, name="w")
    b = tf.Variable(0.0, name="b")
    #pred是预测值，前向计算
    pred = model(x, w, b)
    #迭代次数
    train_epochs = 10
    
    #学习率
    learning_rate = 0.05
    #定义损失函数，均方差（MSE）
    loss_function = tf.reduce_mean(tf.square(y-pred))
    #定义优化器，选用梯度下降优化器
    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss_function)
    sess = tf.Session()
    init = tf.global_variables_initializer()
    
    sess.run(init)
    for epoch in range(train_epochs):
        #zip函数会将两个一维数组合并为一个一维数组，这样数组中的每个变量都相当于一个元组
        for xs,ys in zip(x_data, y_data):
            loss = sess.run([optimizer, loss_function], feed_dict={x:xs, y:ys})
            
        b0temp = b.eval(session=sess)
        w0temp = w.eval(session=sess)
        plt.plot(x_data, w0temp * x_data + b0temp)

#进行训练
    x_test = 3.2
    target = 2 * x_test + 1
    print(target)
    
    #通过模型预测的结果
    result = sess.run(pred, feed_dict={x:x_test})
    print(result)

\#最终的输出结果为7.4和7.385617

### 随机梯度下降法 ###

在梯度下降法中，批量指的是用于单次迭代中计算梯度的样本总数。假定批量是指整个数据集，数据集通常包括很大样本，此外数据集通常包含很多特征。因此一个批量可能是相当巨大。如果是超大批量，则迭代次数可能要花费很多时间。

随机梯度下降法（SGD）：每次迭代只使用一个样本，如果进行足够的迭代，SGD也可以发挥作用。“随机”这一术语表示构成各个批量的样本都是随机选择的。

小批量随机梯度下降法（小批量SGD）：是介于全批量迭代和SGD之间的折中方案。小批量通常包括10-1000个随机样本。小批量SGD可以减少SGD中的杂乱的样本数量，仍是比较高效的一种方案。

[20181127200155488.jpg]: /images/20220413/6079058857e24b28b45da32115c0f8a6.png