黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

文章目录

这是黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

视频链接: 黑马程序员3天带你玩转Python深度学习TensorFlow框架

1、深度学习的介绍

1.1、深度学习与机器学习的区别

学习目标:了解深度学习和机器学习的区别

[En]

Learning goal: to know the difference between deep learning and machine learning

区别:深度学习中没有特征提取

[En]

Difference: there is no feature extraction in deep learning

黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

特征方面

  1. 机器学习的特征工程步骤是要靠手动完成的,而且需要大量领域专业知识
  2. 深度学习通常由多个层组成,它们通常将更简单的模型组合在一起,将数据从一层传递到另一层来构建更复杂的模型。通过训练大量数据自动得到模型, 不需要人工特征提取环节

深度学习算法试图从数据中学习高级功能,这是深度学习的一个非常独特的部分。因此,减少了为每个问题开发新特征提取器的任务。适合用在难提取特征的图像、语音、自然语言处理领域

数据量和计算性能要求

机器学习的执行时间远小于深度学习,深度学习的参数往往很大,需要通过对大量数据的多次优化来训练。

[En]

The execution time of machine learning is much less than that of deep learning, and the parameters of deep learning are often very large, which need to be trained through multiple optimizations of a large amount of data.

黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记
  1. 深度学习需要大量的训练数据集
  2. 训练深度神经网络需要大量的算力
  3. 可能要花费数天、甚至数周的时间,才能使用数百万张图像的数据集训练出一个深度网络。所以 深度学习通常需要强大的GPU服务器来进行计算

算法代表

  1. 机器学习:朴素贝叶斯,决策树
  2. 深度学习:神经网络

; 1.2、深度学习的应用场景

  1. 图像识别:物体识别、场景识别、车型识别、人脸检测跟踪、人脸关键点定位、人脸身份认证
  2. 自然语言处理技术:机器翻译、文本识别、聊天对话
  3. 语音技术:语音识别

1.3、深度学习框架介绍

常见深度学习框架对比

黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记
  1. 最常用的框架当数TensorFlow和Pytorch,而 Caffe和Caffe2次之。
  2. PyTorch和 Torch更适用于学术研究(research) ; TensorFlow,Caffe,Caffe2更适用于工业界的生产环境部署(industrial production)
  3. Caffe适用于处理静态图像(static graph) ; Torch和PyTorch更适用于动态图像(dynamic graph) ; TensorFlow在两种情况下都很实用。
  4. Tensorflow和Caffe2可在移动端使用。

Tensorflow的安装

官网:https://www.tensorflow.org/

CPU版本
2 GPU版本:核芯数量多,更适合处理并行任务

pip install tensorflow==1.8 -i https://pypi.douban.com/simple

pip install tensorflow==1.15
pip install tensorflow-gpu==1.15

CPU:核芯的数量少;
每一个核芯的速度更快,性能更强;更适用于处理连续性(sequential)任务。

GPU:核芯的数量多;
但是每一个核芯的处理速度较慢;更适用于并行(parallel)任务。

Tensorflow特点

  • 高度灵活(Deep Flexibility)
  • 它不仅可以用来做神经网络算法研究,也可以用来做普通的机器学习算法,甚至是只要把计算表示成数据流图,都可以用TensorFlow。
  • 语言多样(Language Options)
  • TensorFlow使用C++实现的,然后用Python封装。谷歌号召社区通过SwIG开发更多的语言接口来支持TensorFlow。
  • 设备支持
  • TensorFlow可以运行在各种硬件上,同时根据计算的需要,合理将运算分配到相应的设备,比如卷积就分配到GPU上,也允许在CPU和GPU上的计算分布,甚至支持使用gRPC进行水平扩展。
  • Tensorboard可视化
  • TensorBoard是TensorFlow的一组Web应用,用来监控TensorFlow运行过程,或可视化Computation Graph。TensorBoard目前支持5种可视化:标量(scalars) 、图片(images) 、音频(audio) 、直方图(histograms)和计算图(Computation Graph)。TensorBoard的Events Dashboard可以用来持续地监控运行时的关键指标,比如loss、学习速率(learning rate)或是验证集上的准确率(accuracy)

2、TensorFlow

2.1、初始TensorFlow

官网:https://www.tensorflow.org/

TensorFlow程序通常被组织成一个构件图阶段和一个执行图阶段。

  1. 在构建图阶段,数据与操作的执行步骤被描述为一个图
  2. 在执行图阶段,使用会话(调用系统资源)执行构建好的图中的操作

  3. 图:这是TensorFlow将计算表示为指令之间的依赖关系的一种表示法,(数据+操作)

  4. 会话:TensorFlow跨一个或多个本地或远程设备运行数据流图的机制
  5. 张量(数据):TensorFlow中的基本数据对象
  6. 节点(操作):提供图当中执行的操作W
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

def tensorflow_demo1():
"""
   tensoflow的基本结构
"""

   a=2
   b=3
   c=a+b
   print('python版本的加法操作:\n',c)

   a_t=tf.constant(2)
   b_t=tf.constant(3)
   c_t=a_t+b_t
   print('tensorflow版本的加法操作:\n',c_t)

   with tf.Session() as sess:
      c_t_value=sess.run(c_t)
      print('开启会话的结果\n',c_t_value)

if __name__ == '__main__':
   tensorflow_demo1()
'''
python版本的加法操作:
 5
tensorflow版本的加法操作:
 Tensor("add:0", shape=(), dtype=int32)
打开会话的结果<details><summary>*<font color='gray'>[En]</font>*</summary>*<font color='gray'>The result of opening a session</font>*</details>
 5
'''

2.2、图

图包含了一组tf.Operation代表的计算单元对象和tf.Tensor代表的计算单元之间流动的数据

一个图一个命名空间,互不干扰影响

  1. 默认图
  2. 自定义图

通常tensorflow会默认帮我们创建一张图

有两种方式可以查看默认图表:

[En]

There are two ways to view the default diagram:

  • 通过调用tf.get_default_graph()访问
  • 通过 graph属性访问
def graph_demo():

   a_t = tf.constant(2)
   b_t = tf.constant(3)
   c_t = a_t + b_t

   defalut_g=tf.get_default_graph()
   print('默认图:',defalut_g)

   print('a_t的图属性: ',a_t.graph)
   print('c_t的图属性: ',c_t.graph)

   with tf.Session() as sess:
      c_t_value = sess.run(c_t)
      print('sess的图属性:',sess.graph)
if __name__ == '__main__':
   graph_demo()
'''
默认图:
a_t的图属性:
c_t的图属性:
sess的图属性:
'''

自定义图

  1. 通过 tf.Graph() 自定义图
  2. 通过 tf.Graph.as_default() 图上下文管理器 去定义张量和节点,图上下文管理器会自动将张量和节点绑定在图中
  3. 开启会话,需要传入自定义图
def create_graph():

   new_graph=tf.Graph()

   with new_graph.as_default():
      a_new = tf.constant(20)
      b_new = tf.constant(30)
      c_new = a_new + b_new
      print("c_new:", c_new)
      print("a_new的图属性:", a_new.graph)
      print("c_new的图属性:", c_new.graph)

   with tf.Session(graph = new_graph) as sess:
      c_new_value=sess.run(c_new)
      print('自定义图的运算结果:',c_new_value)
      print('sess的图属性:',sess.graph)

if __name__ == '__main__':
   create_graph()
'''
c_new: Tensor("add:0", shape=(), dtype=int32)
a_new的图属性:
c_new的图属性:
自定义图形运行结果:50<details><summary>*<font color='gray'>[En]</font>*</summary>*<font color='gray'>Operation result of custom graph: 50</font>*</details>
sess的图属性:
'''

TensorBoard可视化工具

tensorflow可用于训练大规模深度神经网络所需的计算,使用该工具设计的计算往往复杂而深奥。为了更方便tensorflow程序的理解、调试与优化,tensorflow提供了TensorBoard可视化工具

实现程序可视化的过程:

[En]

Realize the process of program visualization:

  1. 将图进行数据序列化,为events文件
  2. 打开终端,启动tensorBoard

1、将图进行数据序列化,为events文件

TensorBoard通过读取TensorFlow的事件文件来运行,故需要将图序列化为Summary对象

tf.summary.FileWriter(path, graph=sess.graph)

2、打开终端,启动tensorBoard

tensorboard –logdir=path

def graph_demo():

    a_t = tf.constant(2)
    b_t = tf.constant(3)
    c_t = a_t + b_t

    with tf.Session() as sess:
        c_t_value = sess.run(c_t)
        print('sess的图属性:',sess.graph)

    tf.summary.FileWriter('./temp/summary',graph = sess.graph)

if __name__ == '__main__':
    graph_demo()

黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

在终端输入,注意路径
tensorboard –logdir=’./machine_learning/temp/summary’

黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

点击http://MSI:6006 跳到tensorBoard页面

黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

OP 操作对象 operation

类型实例标量运算add,sub, mul, div,exp, log, greater, less,equal向量运算concat,slice,splot, constant,rank,shape, shuffle矩阵运算matmul, matrixinverse,matrixdateminant带状态的运算Variable, assgin, assginadd神经网络组件softmax,sigmoid,relu,convolution,max_pool存储,恢复Save,Restroe队列及同步运算Enqueue,Dequeue,MutexAcquire,MutexRelease控制流Merge,Switch, Enter,Leave,Nextlteration 操作函数操作对象tf.constant(Tensor对象)输入Tensor对象-Const输出 Tensor对象tf.add(Tensor对象1,Tensor对象2)输入(Tensor对象1,Tensor对象2) ,add对象,输出 Tensor对象3

一个b操作对象(Operation)是TensorFlow图中的一个节点,可以接收0个或者多个输入Tensor对象,并且可以输出0个或者多个Tensor,Operation对象是通过op构造函数(如tf.matmul())创建的。

例如: c = tf.matmul(a, b)创建了一个Operation对象,类型为 MatMul类型,它将张量a, b作为输入,c作为输出,,并且输出数据,打印的时候也是打印的数据。其中tf.matmul)是函数,在执行matmul函数的过程中会通过MatMul类创建—个与之对应的对象

注意,打印出来的是张量值,可以理解成OP当中包含了这个值。并且每一个OP指令都对应一个唯一的名称,如上面的Const:0,这个在TensorBoard上面也可以显示

请注意,tf.Tensor对象以输出该张量的tf.Operation明确命名。张量名称的形式为”

指令名称
图片有自己的命名空间。

[En]

A picture has its own namespace.

tf.Graph对象为其包含的 tf.Operation对象定义的一个命名空间。TensorFlow 会自动为图中的每个指令选择一个唯一名称,用户也可以指定描述性名称,使程序阅读起来更轻松。我们可以以以下方式改写指令名称

  • 每个创建新的tf.Operation或返回新的tf.Tensor的 API函数可以接受可选的name参数。

例如, tf.constant(42.0, name=”answer”)创建了一个名为”answer”的新tf.Operation并返回一个名为”answer:0″的tf.Tensor。如果默认图已包含名为”answer”的指令,则TensorFlow 会在名称上附加”1″、”2″等字符,以便让名称具有唯一性。

  • 当修改好之后,我们在Tensorboard显示的名字也会被修改

2.3、会话

会话创建

  • tf.Session:用于完整的程序当中
  • tf.InteractiveSession:用于交互式上下文中的TensorFlow,例如shell

1 TensorFlow使用tf.Session类来表示客户端程序(通常为Python程序,但也提供了使用其他语言的类似接口)与C++运行时之间的连接

2 tf.Session对象使用分布式TensorFlow运行时提供对本地计算机中的设备和远程设备的访问权限。

快速查看张量的值,在会话中调用 对象.eval() 查看

黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

会话上下文管理器

会话可能拥有的资源,如tf.Variable,tf.QueueBase和tf.ReaderBase。当这些资源不再需要时,释放这些资源非常重要。因此,需要调用tf.Session.close会话中的方法,或将会话用作上下文管理器。

tf.Session(target=”,graph=None,config=None)

  1. target:如果将此参数留空(默认设置),会话将仅使用本地计算机中的设备。可以指定grpc://网址,以便指定TensorFlow服务器的地址,这使得会话可以访问该服务器控制的计算机上的所有设备
  2. graph:默认情况下,新的tf.Session将绑定到当前的默认图
  3. config:此参数允许您指定一个tf.ConfigProto以便控制会话的行为。例如,ConfigProto协议用于打印设备使用信息

with tf.Session() as sess:
    sess.run(sth)

sess=tf.Session()
sum_t=sess.run(c_t)
sess.close()

sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=True))

会话run()

run(fetches, feed_dict=None, options=None, run_metadata=None)

  • 通过使用sess.run()来运行operation
  • fetches:传入单一的operation,或者列表、元组(属于tensorflow的类型)
  • feed_dict:参数运行调用者覆盖图中张量的值,运行时赋值,与tf.placeholder()占位符搭配使用,则会检查值的形式是否与占位符兼容

注: 使用tf.operation.eval()也可以运行operation,但需要在会话中运行


a = tf.constant(5.0)
b = tf.constant(6.0)
c = a + b

sess = tf.Session()

print(sess.run(c))
print(c.eval(session=sess))

feed_dict()操作

请注意运行时候报的错误error:

RuntimeError:如果这Session是无效状态(例如已关闭)。

TypeError:如果fetches或者feed_dict键的类型不合适。

valueError:如果fetches或feed_dict键无效或引用Tensor不存在的键。

  • placeholder提供占位符,run时候通过feed_dict传参
def feed_dict_demo():

    a=tf.placeholder(tf.float32)
    b=tf.placeholder(tf.float32)
    c=tf.add(a,b)

    with tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=True)) as sess:
        c_value=sess.run([a,b,c],feed_dict={a:3.2,b:2.3})
        print('c_value: ',c_value)

if __name__ == '__main__':
    feed_dict_demo()
'''
Device mapping: no known devices.

Add: (Add): /job:localhost/replica:0/task:0/device:CPU:0
Placeholder_1: (Placeholder): /job:localhost/replica:0/task:0/device:CPU:0
Placeholder: (Placeholder): /job:localhost/replica:0/task:0/device:CPU:0
c_value:  [array(3.2, dtype=float32), array(2.3, dtype=float32), 5.5]
'''

2.4、张量

2.4.1、定义

TensorFlow的张量就是一个N维数组,类型为tf.Tensor。

标量:一个数字-0阶张量

[En]

Scalar: a number-0 order tensor

向量:一维阵列一阶张量

[En]

Vector: one-dimensional array-first order tensor

矩阵:二维数组二阶张量

[En]

Matrix: two-dimensional array-order 2 tensor

3阶张量

  • type:数据类型
  • 未指定类型时,默认类型:
    [En]

    when no type is specified, the default type:*

  • 整型:tf.int32
  • 浮点型:tf.float32
  • shape:形状(阶)

张量的类型

数据类型Python类型描述DT_FLOATtf.float3232位浮点数.DT_DOUBLEtf.float6464位浮点数.DT_INT64tf. int6464位有符号整型.DT_INT32tf. int3232位有符号整型.DT_INT16tf.int1616位有符号整型.DT_INT8tf.int88位有符号整型.DT_UINT8tf.uint88位无符号整型.DT_STRINGtf.string可变长度的字节数组.每一个张量元素都是一个字节数组.DT_BOOLtf.bool布尔型.DT_COMPLEX64tf.complex64由两个32位浮点数组成的复数:实数和虚数.DT_QINT32tf.qint32用于量化Ops的32位有符号整型.DT_QINT8tf.qint8用于量化Ops的8位有符号整型.DT_QUINT8tf.quint8用于最化Ops的8位无符号整型

张量的阶

阶数学实例Python例子0表量(只有大小)s = 4831向量(大小和方向)v = [1.1,2.2,3.3]2矩阵(数据表)m = [[1,2,3],[4,5.6],[7,8,9]]33阶张量(数据立体)t = [[[2],[4],[6]],[[8],[10],[12]],[[14],[16],[18]]]nn阶(自己想想看)

def tensor_demo():
"""
    张量的演示
"""
    tensor1 = tf.constant(4.0)
    tensor2 = tf.constant([1,2,3,4])
    linear_squares = tf.constant([[4],[9],[16],[25]],dtype=tf.int32)
    print("tensor1:", tensor1)
    print("tensor2:", tensor2)
    print("linear_square:", linear_squares)
    return None

if __name__ == "__main__":
    tensor_demo()
'''
tensor1: Tensor("Const:0", shape=(), dtype=float32)
tensor2: Tensor("Const_1:0", shape=(4,), dtype=int32)
linear_square: Tensor("Const_2:0", shape=(4, 1), dtype=int32)
'''

2.4.2、创建张量

创建固定值张量

tf.zeros(shape, dtype=tf.float32,name=None)

创建所有元素设置为零的张量。此操作返回一个dtype具有形状shape和所有元素设置为零的类型的张量。

tf.zeros_like(tensor,dtype=None, name=None)

给tensor定单张量(),此操作返回tensor与所有元素设置为零相同的类型和形状的张量。

tf.ones(shape, dtype=tf.float32, name=None)

创建一个所有元素设置为1的张量。此操作返回一个类型的张量,dtype形状shape和所有元素设置为1。

tf.ones_like(tensor, dtype=None, name=None)

给tensor定单张量(),此操作返回tensor与所有元素设置为1相同的类型和形状的张量。

tf.fill(dims, value, name=None)

创建一个填充了标量值的张量。此操作创建一个张量的形状dims并填充它value.

tf.constant(value, dtype=None,shape=None, name=’Const'”

创建一个常量张量。

[En]

Create a constant tensor.

创建随机张量

一般我们经常使用的随机数函数Math.randoml()产生的是服从均匀分布的随机数,能够模拟等概率出现的情况,例如扔一个骰子,1到6点的概率应该相等,但现实生活中更多的随机现象是符合正态分布的,例如20岁成年人的体重分布等。

假如我们在制作一个游戏,要随机设定许许多多NPC的身高,如果还用Math.random),生成从140到220之间的数字,就会发现每个身高段的人数是一样多的,这是比较无趣的,这样的世界也与我们习惯不同,现实应该是特别高和特别矮的都很少,处于中间的人数最多,这就要求随机函数符合正态分布。

tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32,seed=None,name=None)

从截断的正态分布中输出随机值,和 tf.random_normal(0一样,但是所有数字都不超过两个标准差

tf.random_normal(shape, mean=0.0,stddev=1.0, dtype=tf.float32, seed=None, name=None)

从正态分布输出随机值的矩阵,由来自随机正态分布的数字组成。

[En]

A matrix that outputs random values from a normal distribution and consists of numbers from a random normal distribution.

其它特殊的创建张量的OP

  • tf.Variable
  • tf.placeholder

黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

; 2.4.3、张量的变换

1 类型改变

  • tf.string_to_number(string_tensor, out_type=None, name=None)
  • tf.to_double(x, name=’ToDouble’)
  • tf.to_float(x, name=’ToFloat’)
  • tf.to_bfloat16(x, name=”ToBFloat16″)
  • tf.to_int32(x, name=’Tolnt32′)
  • tf.to_int64(x, name=’Tolnt64′)
  • *tf.cast(x, dtype, name=None),通用类型转换
def cast_demo():
   a=tf.constant(4.0)
   b=tf.cast(a,dtype = tf.float64)
   print(a)
   print(b)

if __name__ == '__main__':
   cast_demo()
'''
Tensor("Const:0", shape=(), dtype=float32)
Tensor("Cast:0", shape=(), dtype=float64)
'''

2 形状改变
tensorflow的张量具有两种形状变换, 动态形状静态形状

  1. tf.reshape(tensor,shape):动态创建新张量,当原形状固定的时候,动态改变张量的时候,张量的元素个数必须一致。如shape(2,3) 元素个数为6,则动态改变张量的时候,也要确保元素的个数为6
  2. tensor.set_shape(shape):改变静态形状

静态形状:最初创建张量时的形状

[En]

Static shape: shape when the tensor is initially created

什么情况下可以改变静态形状:

只有在形状还没有完全固定下来的情况下,如shape(?,?);转换形状的时候,只能一维到一维,二维到二维,而不能跨维度改变形状,如 shape=[None, 10],前面无所谓变化,但后面一个必须要10

def shape_demo():
   a = tf.constant(4.0)
   b = tf.placeholder(dtype=tf.float32, shape=[None, 10])
   print('a:',a)
   print('b:',b)

   b.set_shape((2,10))
   print('修改b静态形状',b)
   c_dynamic=tf.reshape(b,shape = (10,2))

   print('修改b动态形状',c_dynamic)

if __name__ == '__main__':
   shape_demo()
'''
a: Tensor("Const:0", shape=(), dtype=float32)
b: Tensor("Placeholder:0", shape=(?, 10), dtype=float32)
修改b静态形状 Tensor("Placeholder:0", shape=(2, 10), dtype=float32)
修改b动态形状 Tensor("Reshape:0", shape=(10, 2), dtype=float32)
'''

张量的数学运算,自己去查api

  • 算术运算符(如tf.add())
  • 基本数学函数
  • 矩阵运算(如tf.matmul())
  • reduce操作(如tf.reduce_sum()、tf.reduce_mean()
  • 序列索引操作

2.5、变量OP

TensorFlow变量是表示程序处理的共享持久状态的最佳方法。变量通过tf.Variable类进行操作。

变量的特点:

  • 存储持久化,如可变存储模型参数
    [En]

    Storage persistence, such as variable storage model parameters*

  • 可修改值
  • 可指定被训练

2.5.1 创建变量

tf.Variable(initia_value=None, trainable=True, collections=None, name=None)

  1. initial_value:初始化的值
  2. trainable:是否被训练
  3. collections:新变量将添加到列出的图的集合中collections,默认为[GraphKeys.GLOBAL_VARIABLES],如果trainable是True变量也被添加到图形集合GraphKeys.TRAINABLE_VARIABLES

注意:创建完变量后,需要进行变量初始化,且运行该初始化后,才能使用变量

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

def variable_demo():

    a=tf.Variable(initial_value = 30)
    b=tf.Variable(initial_value = 50)
    c=tf.add(a,b)
    print('a:',a)
    print('b:',b)
    print('c:',c)

    init=tf.global_variables_initializer()

    with tf.Session() as sess:
        sess.run(init)
        a_value,b_value,c_value=sess.run([a,b,c])
        print('a_value,',a_value)
        print('b_value,',b_value)
        print('c_value,',c_value)

if __name__ == '__main__':
    variable_demo()
'''
a:
b:
c: Tensor("Add:0", shape=(), dtype=int32)
a_value, 30
b_value, 50
c_value, 80
'''

2.5.2、修改变量的命名空间

tf.variable_scope()

  1. 会在OP变量的名字前面添加新的命名空间名
  2. 命名空间会使图的结构更加清晰
def scope_demo():
   with tf.variable_scope('myscore'):
      a = tf.Variable(initial_value = 30)
      b = tf.Variable(initial_value = 50)
   with tf.variable_scope('yourscore'):
      c = tf.add(a, b)
   print('a:', a)
   print('b:', b)
   print('c:', c)

if __name__ == '__main__':
   scope_demo()
'''
a:
b:
c: Tensor("yourscore/Add:0", shape=(), dtype=int32)
'''

2.6、高级API

2.6.1、其他基础API

1、tf.app
这个模块相当于为TensorFlow进行的脚本提供一个main函数入口,可以定义脚本运行的flags

2、tf.image
TensorFlow的图像处理操作。主要是一些颜色变换、变形和图像的编码和解码

3、tf.gfile
该模块提供了一组文件操作函数

[En]

This module provides a set of file manipulation functions

4、tf.summary
用来生成TensorBoard可用的统计日志,目前Summary主要提供了4种类型:
audio、image、histogram、scalar

5、tf.python_io
用来读写TFRecords文件

6、tf.train
这个模块提供了一些训练器,与tf.nn结合起来,实现一些网络的优化计算

7、tf.nn
这个模块提供了一些构建神经网络的底层函数。TensorFlow构建网络的核心模块,其中包含了添加各种层的函数,比如添加卷积层、池化层等。

2.6.2、高级API

1、tf.keras
Kears本来是一个独立的深度学习库,tensorflow将其学习过来,增加这部分模块在于快速构建模型

2、tf.layers
高级API,以便高级的概念层来定义一个模型。类似tf.kears

3、tf.contrib
tf.contrib.layers提供够将计算图中的网络层、正则化、摘要操作,是构建计算图的高级操作,但是tf.contrib包含不稳定和实验代码,有可能以后API会改变

4、tf.estimator
一个estimator相当于model + training + evaluate 的合体。在模块中,已经实现了几种简单的分类器和回归其,包括:Baseline,learning 和 DNN。这里的DNN的网络,只是全连接网络,没有提供卷积之类的

关于tensorflow的API展示

黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

; 2.7、案例:实现线性回归

回顾:根据数据建立回归模型,w1x1+w2x2+…+b = y,通过真实值与预测值之间建立误差,使用梯度下降优化得到损失最小对应的权重和偏置。最终确定模型的权重和偏置参数。最后可以用这些参数进行预测。

  1. 构建线性回归模型
  2. 构造损失函数(均方误差)
  3. 优化损失(梯度下降)

使用到的API

运算:

  • 矩阵运算:tf.matmul(x,w)
  • 平方:tf.square(error)
  • 均方:tf.reduce_mean(error)

梯度下降优化:

tf.train.GradientDescentOptimizer(learning_rate)

  • 梯度下降优化
  • learning_rate:学习率,一般为0~1之间比较小的值
  • method:
  • minimize(loss) 最小化
  • return:梯度下降op

分析

1)准备真实数据:

tf.random_normal()

x:特征值,形状:(100,1),随机指定100个点,只有一个特征值
y_true:目标值,形状:(100,1)
y_true = 0.8x + 0.7 ,100个样本
即假设x和y之间的关系满足: y =kx + b, 最后求出k≈0.8,b=0.7 为正确的答案

即y_predict=x*weights+bias

2)构建模型

y_predict = tf.matmul(x, weights) + bias

3)构造损失函数(均方误差)

error = tf.reduce_mean(tf.square(y_predict – y_true))

4)优化损失:梯度下降优化器

optimizer = tf.train.GrandientDescentOptimizer(learning_rate=0.01).minimize(error)

def linear_regression():

    X=tf.random_normal(shape=[100,1])
    y_true=tf.matmul(X,[[0.8]])+0.7

    weigths=tf.Variable(initial_value = tf.random_normal(shape = [1,1]))
    bias=tf.Variable(initial_value = tf.random_normal(shape = [1,1]))
    y_predict=tf.matmul(X,weigths)+bias

    error=tf.reduce_mean(tf.square(y_predict-y_true))

    optimizer=tf.train.GradientDescentOptimizer(learning_rate = 0.01).minimize(error)

    init=tf.global_variables_initializer()

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

        print('训练前模型参数为:权重%f, 偏置%f, 损失值%f '%(weigths.eval(),bias.eval(),error.eval()))

        for i in range(100):
            sess.run(optimizer)
            print('第%d次训练前模型参数为:权重%f, 偏置%f, 损失值%f '%(i+1,weigths.eval(),bias.eval(),error.eval()))

if __name__ == '__main__':
    linear_regression()
'''
训练前的模型参数为:权值-2.152965,偏差值-1.636178,损失值14.106889。<details><summary>*<font color='gray'>[En]</font>*</summary>*<font color='gray'>Before training, the model parameters are: weight-2.152965, bias-1.636178, loss value 14.106889.</font>*</details>
第1次训练前模型参数为:权重-2.086562, 偏置-1.589710, 损失值15.449847
第2次训练前模型参数为:权重-2.022885, 偏置-1.536769, 损失值12.712150
第3次训练前模型参数为:权重-1.953819, 偏置-1.488234, 损失值11.221785
.....

第98次训练前模型参数为:权重0.379509, 偏置0.383643, 损失值0.302479
第99次训练前模型参数为:权重0.386806, 偏置0.389533, 损失值0.247333
第100次训练前模型参数为:权重0.396212, 偏置0.395469, 损失值0.296869
'''

学习率的设置、步数的设置与梯度爆炸

学习率越大,得到更好结果的步数越少;学习率越小,得到更好结果的步数越多。

[En]

The greater the learning rate, the smaller the number of steps to better results; the smaller the learning rate, the greater the number of steps to better results.

但我了解到,这次会议将出现梯度爆炸。

[En]

But I have learned that there will be a gradient explosion at the conference.

  1. 在极情况下,权重的值变得非常大,以至于溢出,导致 NaN值
  2. 如当线性回归的学习率设置为100时候,迭代100次的时候就出现权重和偏置为NaN

如何解决梯度爆炸问题(深度神经网络当中更容易出现)

  1. 重新设计网络
  2. 调整学习率
  3. 使用梯度截断(在训练过程中检查和限制梯度的大小)
  4. 使用激活函数

2.8、其他功能

2.8.1、增加变量显示

目的:在TensorBoard当中观察模型的参数、损失值等变量值的变化

1、收集变量

  • tf.summary.scalar(name=”,tensor) 收集对于损失函数和准确率等单值变量,name为收集变量的名字,tensor为对象
  • tf.summary.histogram(name=”,tensor) 收集高维度的变量参数
  • tf.summary.image(name=”,tensor) 收集输入的图片张量能显示图片

2、合并变量写入事件文件

  • 创建事件文件 tf.summary.FileWriter(‘path, graph=sess.graph)
  • merged = tf.summary.merge_all() 合并变量
  • 运行合并: summary = sess.run(merged),每次迭代都需运行
  • 添加:FileWriter.add_summary(summary,i),i表示第几次的值

  • 创建事件文件

  • 收集变量
  • 合并变量
  • 运行合并变量
  • 将迭代后的变量写入到事件文件中
def linear_regression():

    X=tf.random_normal(shape=[100,1])
    y_true=tf.matmul(X,[[0.8]])+0.7

    weigths=tf.Variable(initial_value = tf.random_normal(shape = [1,1]))
    bias=tf.Variable(initial_value = tf.random_normal(shape = [1,1]))
    y_predict=tf.matmul(X,weigths)+bias

    error=tf.reduce_mean(tf.square(y_predict-y_true))

    optimizer=tf.train.GradientDescentOptimizer(learning_rate = 0.01).minimize(error)

    init=tf.global_variables_initializer()

    tf.summary.scalar('error',error)
    tf.summary.histogram('weights',weigths)
    tf.summary.histogram('bias',bias)

    merged=tf.summary.merge_all()

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

        print('训练前模型参数为:权重%f, 偏置%f, 损失值%f '%(weigths.eval(),bias.eval(),error.eval()))

        file_writer=tf.summary.FileWriter('./temp/linear/',graph = sess.graph)

        summary=sess.run(merged)

        for i in range(100):
            sess.run(optimizer)
            print('第%d次训练前模型参数为:权重%f, 偏置%f, 损失值%f '%(i+1,weigths.eval(),bias.eval(),error.eval()))

            file_writer.add_summary(summary,i)

if __name__ == '__main__':
    linear_regression()

在Terminal输入 tensorboard –logdir=’./temp/linear’

黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

2.8.2、增加命名空间

tf.variable_scope(name=”)

使得代码结构更加信息,TensorBoard图结构更加清楚

def linear_regression():

   with tf.variable_scope('prepare_data'):
      X=tf.random_normal(shape=[100,1],name='feature')
      y_true=tf.matmul(X,[[0.8]])+0.7

   with tf.variable_scope('create_model'):
      weigths=tf.Variable(initial_value = tf.random_normal(shape = [1,1]),name = 'Weights')
      bias=tf.Variable(initial_value = tf.random_normal(shape = [1,1]),name='Bias')
      y_predict=tf.matmul(X,weigths)+bias

   with tf.variable_scope('loss_function'):
      error=tf.reduce_mean(tf.square(y_predict-y_true))

   with tf.variable_scope('optimizer'):
      optimizer=tf.train.GradientDescentOptimizer(learning_rate = 0.01).minimize(error)

   init=tf.global_variables_initializer()

   tf.summary.scalar('error',error)
   tf.summary.histogram('weights',weigths)
   tf.summary.histogram('bias',bias)

   merged=tf.summary.merge_all()

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

      print('训练前模型参数为:权重%f, 偏置%f, 损失值%f '%(weigths.eval(),bias.eval(),error.eval()))

      file_writer=tf.summary.FileWriter('./temp/linear/',graph = sess.graph)

      summary=sess.run(merged)

      for i in range(100):
         sess.run(optimizer)
         print('第%d次训练前模型参数为:权重%f, 偏置%f, 损失值%f '%(i+1,weigths.eval(),bias.eval(),error.eval()))

         file_writer.add_summary(summary,i)

if __name__ == '__main__':
   linear_regression()

黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

2.8.3、模型的保存与加载

tf.train.Saver(var_list=None,max_to_keep=5)

  • 保存和加载模型(保存文件格式: checkpoint文件)
  • var_list:指定将要保存和还原的变量。它可以作为一个dict或一个列表传递
  • max_to_keep:指示要保留的最近检查点文件的最大数量。创建新文件时,会删除较旧的文件。如果无或0,则保留所有检查点文件。默认为5(即保留最新的5个检查点文件。)

步骤:

注意:
1、path,目录一定要提前创建
2、保存的是会话(里面是具体模型的参数)
3、保存模型的格式为 ckpt

  1. 实例化Saver
  2. 保存:saver.save(sess, path)
  3. 加载:saver.restore(sess, path)
def linear_regression():

   with tf.variable_scope('prepare_data'):
      X=tf.random_normal(shape=[100,1],name='feature')
      y_true=tf.matmul(X,[[0.8]])+0.7

   with tf.variable_scope('create_model'):
      weigths=tf.Variable(initial_value = tf.random_normal(shape = [1,1]),name = 'Weights')
      bias=tf.Variable(initial_value = tf.random_normal(shape = [1,1]),name='Bias')
      y_predict=tf.matmul(X,weigths)+bias

   with tf.variable_scope('loss_function'):
      error=tf.reduce_mean(tf.square(y_predict-y_true))

   with tf.variable_scope('optimizer'):
      optimizer=tf.train.GradientDescentOptimizer(learning_rate = 0.01).minimize(error)

   init=tf.global_variables_initializer()

   tf.summary.scalar('error',error)
   tf.summary.histogram('weights',weigths)
   tf.summary.histogram('bias',bias)

   merged=tf.summary.merge_all()

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

      print('训练前模型参数为:权重%f, 偏置%f, 损失值%f '%(weigths.eval(),bias.eval(),error.eval()))

      file_writer=tf.summary.FileWriter('./temp/linear/',graph = sess.graph)

      summary=sess.run(merged)

      saver=tf.train.Saver()

      if os.path.exists('./temp/model/checkpoint'):
         saver.restore(sess, './temp/model/my_linear.ckpt')
         print('训练后模型参数为:权重%f, 偏置%f, 损失值%f ' % (weigths.eval(), bias.eval(), error.eval()))

if __name__ == '__main__':
    linear_regression()

'''
训练前的模型参数为:权值-1.358256,偏差值2.844705,损失值6.984871。<details><summary>*<font color='gray'>[En]</font>*</summary>*<font color='gray'>Before training, the model parameters are: weight-1.358256, bias 2.844705, loss value 6.984871.</font>*</details>
训练后的模型参数为:权值0.486487,偏差值0.413228,损失值0.159787。<details><summary>*<font color='gray'>[En]</font>*</summary>*<font color='gray'>The parameters of the model after training are: weight 0.486487, bias 0.413228, loss value 0.159787.</font>*</details>
'''

2.8.4、命令行参数设置

tf.app.flags(DEFINE),它支持应用从命令行接受参数,可以用来指定集群配置等。在tf.app.flags()下面有各种定义参数的类型

  • DEFINE_string(flag _name,default_value, docstring)
  • DEFINE_integer(flag_name, default_value, docstring)
  • DEFINE_boolean(flag_name, default_value, docstring)
  • DEFINE_float(flag_name, default_value, docstring)
  • tf.app.flags,在flags有一个FLAGS标志,它在程序中可以调用到我们前面具体定义的flag_name
  • 通过tf.app.run() 会自动启动 main(argv) 函数

tf.app.flags.DEFINE_integer("max_step",0,"训练模型的步数")

tf.app.flags.DEFINE_string("model_dir", " ","模型保存的路径+模型名字")

FLAGS = tf.app.flags.FLAGS

tf.app.flags(DEFINE) 使用

import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

tf.app.flags.DEFINE_integer("max_step", 100, "训练模型的步数")
tf.app.flags.DEFINE_string("model_dir", "Unknown", "模型保存的路径+模型的名字")

FLAGS = tf.app.flags.FLAGS

def command_demo():
"""
    命令行参数演示
"""
    print("max_step:", FLAGS.max_step)
    print("model_dir:", FLAGS.model_dir)

if __name__ == '__main__':
   command_demo()

'''
max_step: 100
model_dir: Unknown
'''

黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

tf.app.run()使用

def main(argv):
"""
   这里是总文件,各种模块调用写在这里
"""
   print(argv)

if __name__ == '__main__':
   tf.app.run()
'''
['E:/RuanJian_2/PyCharm/PyCode/heima/junior/machine_learning/tensorflow_demo1.py']
'''

3、数据读取

3.1、文件读取流程

3.1.1、文件读取流程

黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

shuffle 洗牌

阶段1:构建文件名队列

[En]

Phase 1: construct a queue of file names

第二阶段:阅读和解码

[En]

The second stage: reading and decoding

阶段3:批量处理(需要手动启动线程)

[En]

Phase 3: batch processing (threads need to be started manually)

注意:这些操作需要启动运行这些队列操作的线程,这样我们才能在文件读取过程中成功排队和出队。

[En]

Note: these operations need to * start the thread running these queue operations * , so that we can successfully queue up and dequeue during the file reading process.

1、构造文件名队列
将要读取的文件的文件名放入文件名队列

[En]

Put the file name of the file to be read into the file name queue

tf.train.string_input_producer(string_tensor, shuffle=True)

  1. string_tensor:包含文件名+路径的1阶张量, 一般传入列表
  2. num_epochs:过几遍数据,默认无限过数据
  3. return:文件队列

2、读取与解码
从队列中读取文件的内容并对其进行解码。

[En]

The contents of the file are read from the queue and decoded.

2.1、读取文件内容

阅读器默认每次只读取一个样本

具体来说:

文本文件默认一次读取一行,图片文件默认一次读取一张图片,二进制文件一次读取指定字节数(最好是一个样本的字节数),TFRecords默认一次读取一个example

  1. tf.TextLineReader: 读取文本
  2. 阅读文本文件逗号分隔值(CSV)格式,默认按行读取
  3. return:读取器实例
  4. tf.WholeFileReader: 用于读取图片文件
  5. return:读取器实例
  6. tf.FixedLengthRecordReader(record_bytes) : 读取二进制文件
  7. 要读取每个记录是固定数量字节的二进制文件
  8. orecord_bytes:整型,指定每次读取(一个样本)的字节数
  9. return:读取器实例

1、它们有共同的读取方法: read(file_queue),并且都会返回一个Tensors元组(key文件名字,value默认的内容(一个样本))

2、由于默认只会读取一个样本,所以如果想要进行批处理,需要使用tf.train.batch或tf.train.shuffle_batch进行批处理操作,便于之后指定每批次多个样本的训练。

即file_queue=tf.train.strng_input_produce(string_tensor, shuffle=True)

key,value=读取器.read(file_queue)

key: 文件名

value: 一个样本

2.2、内容解码

读取不同类型的文件,也应该对读取到的不同类型的内容进行相对应的解码操作,解码成统一的Tensor格式

  1. tf.decode_csv(): 解码文本文件内容·
  2. tf.image.decode_jpeg(contents即样本)
  3. 将JPEG编码的图像解码为uint8张量
  4. return :uint8张量,3-D形状[height, width, channels].

  5. tf.image.decode_png(contents即样本)

  6. 将PNG编码的图像解码为uint8张量
  7. return: 张量类型,3-D形状[height, width, channels]
  8. tf.decode_raw()︰解码二进制文件内容
  9. 与tf.FixedLengthRecordReader搭配使用,二进制读取为uint8类型

解码阶段,默认所有的内容都解码成tf.uint8类型,如果之后需要转换成指定类型则可使用 tf.cast() 进行相应转换。

3 批处理

解码之后,可以直接获取默认的一个样本内容了,但如果想要获取多个样本,需要加入到新的队列进行批处理。

  1. tf.train. batch(tensors, batch_size, num_threads = 1, capacity = 32,name=None)
  2. 读取指定大小(个数)的张量
  3. tensors:可以是包含张量的列表,批处理的内容放到列表当中
  4. batch_size:从队列中读取的批处理大小
  5. num_threads:进入队列的线程数
  6. capacity:整数,队列中元素的最大数量
  7. return:tensors
  8. tf.train. shuffle_batch() : 随机批量操作

; 3.1.2、线程操作

以上用到的队列都是 tf.train.QueueRunner对象。

每个QueueRunner都负责一个阶段,tf.train.start_queue_runners()函数会要求图中的每个QueueRunner启动它的运行队列操作的线程。(这些操作需要在会话中开启)

tf.train. start_queue_runners(sess=None, coord=None)

  • 收集图中所有队列线程。默认情况下,同时启动线程
    [En]

    collect all queue threads in the figure. Start threads at the same time by default*

  • sess:所在的会话
  • coord:线程协调器
  • return:返回所有线程

tf.train. Coordinator()

  • 线程协调器管理和协调线程
    [En]

    Thread coordinator to manage and coordinate threads*

  • request_stop():请求停止
  • should_stop():询问是否结束
  • join(threads=None, stop_grace_period_secs=120):回收线程
  • return:线程协调器实例

3.2、图片读取

3.2.1、图像基本知识

组成图片最基本单位是 像素

1、图片三要素
一张图片的特征值都是像素值,有三个维度:图片长度、图片宽度、图片通道数

[En]

The eigenvalues of a picture are all pixel values, which have three dimensions: * picture length, picture width, and number of picture channels *

图片的通道数是什么?

描述一个像素,如果它是一个灰度图像,那么只需要一个值来描述它,也就是单通道

[En]

Describe a pixel, if it is a grayscale image, then only one value is needed to describe it, that is, a single channel

如果一个像素点,有RGB三种颜色来描述它,及时三通道

灰度图:单通道,[长,宽,1]

彩色图片:三通道,[长,宽,3] 像素点为 长 X 宽 X 3

黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

2、张量形状

在TensorFlow中如何用张量表示一张图片呢?

一张图片可以被表示成一个3D张量,即其形状为[height,width, channel],height就表示高,width表示宽,channel表示通道数。我们会经常遇到3D和4D的表示

  1. 单个图片:[height, width, channel] 3D张量
  2. 多个图片:[batch,height,width, channel],batch表示一个批次的张量数量 4D张量

; 3.2.2、图片特征值处理

为什么要缩放图片到统一大小?

在图像识别中,每个图像样本的特征数目应该是相同的。因此,有必要对所有图片的张量大小进行统一转换。

[En]

In image recognition, the number of features of each image sample should be the same. Therefore, it is necessary to uniformly convert the tensor size of all pictures.

缩小放大图片

tf.image.resize_images(images, size)

  1. images:4-D形状[batch, height, width, channels]或3-D形状的张量[height, width, channels]的图片数据
  2. size:1-D int32张量:new_height,new_width,图像的新尺寸
  3. 返回4-D格式或者3-D格式图片 存储:unit8(节省空间)
    矩阵计算:float32(提高精度)

3.2.3、案例:狗图片读取

流程:
1)构造文件名队列
2)读取与解码,使样本的形状和类型统一
3)批处理,一次性处理多张图片

def picture_read(file_list):

    file_queue=tf.train.string_input_producer(file_list)

    reader=tf.WholeFileReader()

    key,value=reader.read(file_queue)
    print("key:", key)
    print("value:", value)

    image=tf.image.decode_jpeg(value)
    print('image:',image)

    image_resize=tf.image.resize_images(image,[200,200])
    print('image_resize:',image_resize)

    image_resize.set_shape(shape = [200,200,3])

    image_batch=tf.train.batch([image_resize],batch_size = 100,num_threads = 1,capacity = 100)
    print("image_batch:", image_batch)

    with tf.Session() as sess:

        coord=tf.train.Coordinator()

        threads=tf.train.start_queue_runners(sess=sess,coord = coord)
        key_new, value_new, image_new, image_resize_new, image_batch_new = sess.run([key, value, image, image_resize, image_batch])
        print("key_new:", key_new)
        print("value_new:", value_new)
        print("image_new:", image_new)
        print("image_resize_new:", image_resize_new)
        print("image_batch_new:", image_batch_new)

        coord.request_stop()
        coord.join(threads)

    pass

if __name__ == '__main__':
    file_name=os.listdir('./data/image/dog')

    file_list=[os.path.join('./data/image/dog',file) for file in file_name]
    print(file_name)
    print(file_list)
    picture_read(file_list)

'''
['dog.1.jpg', 'dog.10.jpg', 'dog.100.jpg', 'dog.11.jpg', 'dog.12.jpg', 'dog.13.jpg', 'dog.14.jpg', 'dog.15.jpg', ....., 'dog.99.jpg']
['./data/image/dog\\dog.1.jpg', './data/image/dog\\dog.10.jpg', './data/image/dog\\dog.100.jpg', './data/image/dog\\dog.11.jpg', './data/image/dog\\dog.12.jpg', './data/image/dog\\dog.13.jpg', './data/image/dog\\dog.14.jpg', './data/image/dog\\dog.15.jpg',...., './data/image/dog\\dog.99.jpg']
key: Tensor("ReaderReadV2:0", shape=(), dtype=string)
value: Tensor("ReaderReadV2:1", shape=(), dtype=string)
image: Tensor("DecodeJpeg:0", shape=(?, ?, ?), dtype=uint8)
image_resize: Tensor("resize_images/Squeeze:0", shape=(200, 200, ?), dtype=float32)
image_batch: Tensor("batch:0", shape=(100, 200, 200, 3), dtype=float32)
key_new: b'./data/image/dog\\dog.50.jpg'
value_new: b'\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x00\x00\x01\x00\x01\x00\x00\xff\xdb\x00C\x00\n\x07\x07\x08\x07\x06\n\x08\x08\x08\x0b\n\n\x0b\x0e\x18\x10\x0e\r\r\x0e\x1d\x15\x16\x11\x18#\x1f%$"\x1f"!&+7/&)4)!"0A149;>>>%.DIC;\xff\xdb\x00C\x01\n\x0b\x0b\x0e\r\x0e\x1c\x10\x10\x1c;("(;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\xff\xc0\x00\x11\x08\x00\xc7\x00\x9d\x03\x01"\x00\x02\x11\x01\x03\x11\x01\xff\xc4\x00\x1f\x00\x00\x01\x05\x01\x01\x01\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\xff\xc4\x00\xb5\x10\x00\x02\x01\x03\x03\x02\x04\x03\x05\x05\x04\x04\x00\x00\x01}\x01\x02\x03\x00\x04\x11\x05\x12!1A\x06\x13Qa\x07"q\x142\x81\x91\xa1\x08#B\xb1\xc1\x15R\xd1\xf0$3br\x82\t\n\x16\x17\x18\x19\x1a%&\'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz\x83\x84\x85\x86\x87\x88\x89\x8a\x92\x93\x94\x95\x96\x97\x98\x99\x9a\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xff\xc4\x00\x1f\x01\x00\x03\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\xff\xc4\x00\xb5\x11\x00\x02\x01\x02\x04\x04\x03\x04\x07\x05\x04\x04\x00\x01\x02w\x00\x01\x02\x03\x11\x04\x05!1\x06\x12AQ\x07aq\x13"2\x81\x08\x14B\x91\xa1\xb1\xc1\t#3R\xf0\x15br\xd1\n\x16$4\xe1%\xf1\x17\x18\x19\x1a&\'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x92\x93\x94\x95\x96\x97\x98\x99\x9a\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xff\xda\x00\x0c\x03\x01\x00\x02\x11\x03\x11\x00?'
image_new: [[[ 62  78  67]
  [ 42  58  47]
  [ 69  85  74]
  ...

  [193 223 225]
  [194 221 230]
  [149 172 188]]

 [[ 55  71  60]
  [ 46  62  51]
  [ 56  72  61]

  ...

  [231 231 231]
  [231 231 231]
  [231 231 231]]]
image_resize_new: [[[ 62.        78.        67.      ]
  [ 46.3       62.3       51.3     ]
  [ 57.39      73.39      62.39    ]
  ...

  [231.       231.       231.      ]
  [231.       231.       231.      ]
  [231.       231.       231.      ]]]

image_batch_new: [[[[  0.          0.          0.       ]
   [  0.          0.          0.       ]
   [  0.          0.          0.       ]
   ...

  [[125.09195   128.09195   137.09195  ]
   [171.11003   174.03503   183.26003  ]
   [129.0711    131.0711    143.2211   ]
   ...

   [ 15.224976   15.224976   15.224976 ]
   [ 12.149994   12.149994   12.149994 ]
   [ 11.         11.         11.       ]]]

   [ 77.06506    45.09503    13.125    ]
   [ 74.14496    43.14496    15.1449585]
   [ 78.745026   47.745026   18.745026 ]]]]

Process finished with exit code 0

'''

3.3、二进制数据

3.3.1、CIFAR10二进制数据集介绍

CIFAR10数据集官网: https://www.cs.toronto.edu/~kriz/cifar.html

数据集分为五个训练批次和一个测试批次,每个批次有10000幅图像。测试批次碰巧包含从每个类别中随机选择的1000张图像。训练批次包含随机顺序的剩余图像,但一些训练批次可能包含来自一个类别的图像多于另一个类别的图像。在它们之间,训练批次恰好包含来自每个类别的5000张图像

[En]

The data set is divided into five training batches and one test batch, each with 10000 images. The test batch happens to contain 1000 randomly selected images from each category. Training batches contain remaining images in random order, but some training batches may contain more images from one class than another. Between them, the training batch happens to contain 5000 images from each category

黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

二进制版本数据文件

[En]

Binary version data file

二进制版本包含文件data_batch_1.bin,data_batch_2.bin,…,data_batch_5.bin以及test_batch.bin

cifar10 的特征值是 image(3072Bytes) 目标值是 label 0-9 (1Bytes)

每个文件都采用以下格式,数据中的每个样本都包含本征值和目标值:

[En]

Each of these files is in the following format, and each sample in the data contains eigenvalues and target values:

; 3.3.2、CIFAR10二进制数据读取

流程分析

1、构建文件名队列

file_queue=tf.train.string_input_producer(file_list)

2、读取与解码

reader=tf.FixedLengthRecordReader(3073)

key,value=reader.read(file_queue)

decoded=tf.decoded_raw(value,tf.uint8)

对tensor对象进行切片 label

一个样本image(3072字节=1024r+1024g+1024b)

[[r[32,32]],[g[32,32]],[b[32,32]]] 32×32=1024

shape=(3,32,32) = (channels,height,width)

故需要转换为TensorFlow的图像表示(height,width,channels)

tf.transpose(image,[a,b,c])

如 image_new=tf.transpose(image,[1,2,0]) 参数二是将image的原来索引位置,换成现在对应的索引。

即image_new 0,1,2的位置的值,对应image 1,2,0位置的值

3、批处理

tf.train. batch(tensors, batch_size, num_threads = 1, capacity = 32,name=None)

NHWC与NCHW

读取和设置图片形状时有两种格式:

[En]

There are two formats when reading and setting the shape of a picture:

设置为”NHWC”时,排列顺序为 [batch, height, width,channels];

设置为”NCHW”时,排列顺序为[batch, channels, height, width]。

其中N表示这批图像有几张,H表示图像在竖直方向有多少像素,W表示水平方向像素数,C表示通道数。

Tensorflow默认的[height, width, channel]

`python
class Cifar(object):

def __init__(self):

    self.height=32
    self.width=32
    self.channels=3

    self.image_bytes=self.height*self.width*self.channels
    self.label_bytes=1
    self.all_bytes=self.label_bytes+self.image_bytes

def read_and_decode(self,file_list):

    file_queue=tf.train.string_input_producer(file_list)

    reader=tf.FixedLengthRecordReader(self.all_bytes)

    key,value=reader.read(file_queue)
    print('key: ',key)
    print('value: ',value)

    decode=tf.decode_raw(value,tf.uint8)
    print('decode: ',decode)

    label=tf.slice(decode,[0],[self.label_bytes])
    image=tf.slice(decode,[self.label_bytes],[self.image_bytes])
    print('label: ',label)
    print('image: ',image)

    image_reshaped=tf.reshape(image,shape = [self.channels,self.height,self.width])
    print('image_reshaped: ',image_reshaped)

    image_transposed=tf.transpose(image_reshaped,[1,2,0])
    print('image_transposed: ',image_transposed)

    image_cast=tf.cast(image_transposed,tf.float32)

    label_batch,image_batch=tf.train.batch([label,image_cast],batch_size = 100,num_threads = 1,capacity = 100)
    print('label_batch: ',label_batch)
    print('image_batch: ',image_batch)

    with tf.Session() as sess:
        print('------------------开启会话------------------')

        coord=tf.train.Coordinator()
        threads=tf.train.start_queue_runners(sess=sess,coord = coord)

key_new,value_new,decode_new,label_new,image_new,image_reshaped_new,image_transposed_new,label_batch_new,image_batch_new=sess.run([key,value,decode,label,image,image_reshaped,image_transposed,label_batch,image_batch])
print(‘key_new: ‘,key_new)
print(‘value_new: ‘,value_new)
print(‘decode_new’,decode_new)
print(‘label_new’,label_new)
print(‘image_new’,image_new)
print(‘image_reshaped_new\n’,image_reshaped_new)
print(‘image_transposed_new\n’,image_transposed_new)
print(‘label_batch_new\n’,label_batch_new)
print(‘image_batch_new\n’,image_batch_new)

        coord.request_stop()
        coord.join(threads)
    return None

if name == ‘main‘:
file_name=os.listdir(‘./data/cifar-10-batches-bin’)

file_list=[os.path.join('./data/cifar-10-batches-bin',file) for file in file_name if file[-3:]=='bin']
print('file_llist: ',file_list)

cifar=Cifar()
cifar.read_and_decode(file_list)

”’
file_llist: [‘./data/cifar-10-batches-bin\data_batch_1.bin’, ‘./data/cifar-10-batches-bin\data_batch_2.bin’, ‘./data/cifar-10-batches-bin\data_batch_3.bin’, ‘./data/cifar-10-batches-bin\data_batch_4.bin’, ‘./data/cifar-10-batches-bin\data_batch_5.bin’, ‘./data/cifar-10-batches-bin\test_batch.bin’]
key: Tensor(“ReaderReadV2:0”, shape=(), dtype=string)
value: Tensor(“ReaderReadV2:1”, shape=(), dtype=string)
decode: Tensor(“DecodeRaw:0”, shape=(?,), dtype=uint8)
label: Tensor(“Slice:0”, shape=(1,), dtype=uint8)
image: Tensor(“Slice_1:0”, shape=(3072,), dtype=uint8)
image_reshaped: Tensor(“Reshape:0”, shape=(3, 32, 32), dtype=uint8)
image_transposed: Tensor(“transpose:0”, shape=(32, 32, 3), dtype=uint8)
label_batch: Tensor(“batch:0”, shape=(100, 1), dtype=uint8)
image_batch: Tensor(“batch:1”, shape=(100, 32, 32, 3), dtype=float32)

Original: https://blog.csdn.net/qq_44231797/article/details/125086565
Author: 曾桂花酒同少年游
Title: 黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记

原创文章受到原创版权保护。转载请注明出处:https://www.johngo689.com/7682/

转载文章受原作者版权保护。转载请注明原作者出处!

(0)

大家都在看

发表回复

登录后才能评论
免费咨询
免费咨询
扫码关注
扫码关注
联系站长

站长Johngo!

大数据和算法重度研究者!

持续产出大数据、算法、LeetCode干货,以及业界好资源!

2022012703491714

微信来撩,免费咨询:xiaozhu_tec

分享本页
返回顶部