003TensorFlow基础

曾经终败给现在 2023-07-03 02:58 25阅读 0赞

### 文章目录 ###

*   *   *  核心内容
         *   *  TensorFlow
             *  Graph
             *  Session
             *   *  创建和关闭会话
                 *  注入机制
                 *  指定资源设备
                 *  资源分配-控制GPU资源使用率
             *  Tensor
             *   *  Operation
                 *  Feed
                 *  Fetch
             *  Tensorflow中核心API
             *   *  基本运算
             *  范例：读取cifar10数据
             *  TFRecord数据打包
             *  利用tensorflow对图片数据进行读取
             *   *  利用tf.train.slice\_input\_producer进行读取
                 *  利用tf.train.string\_input\_producer进行读取
             *  利用TF对已经打包的数据进行解析
             *  Tensorflow中的高层接口（待学）
             *  Tensorflow实现数据增强（介绍）
             *  TensorBoard使用

### 核心内容 ###

*  TensorFlow中的基本概念介绍
 *  TensorFlow中的核心API
 *  TensorFlow中的高层接口**slim**
 *  TensorFlow的调试技巧
 *  TensorFlow实现数据增强
 *  TensorFlow挑战Cifar-10图像分类任务

#### TensorFlow ####

Google开源的基于数据流图的科学计算库，适用于机器学习、深度学习等人工智能领域

开源库：[https://github.com/tensorflow][https_github.com_tensorflow]  
相关模型：[https://github.com/tensorflow/models][https_github.com_tensorflow_models]

Tensor+Flow=TensorFlow

张量+数据流=TensorFlow

数据是按一定方向流动的，需要一定的计算

#### Graph ####

*  图描述了计算的过程，可以通过tensorflow图形化流程结构
    
     *  graph是在前端进行的，可用tensorflow来进行可视化
     *  声明（单个/多个图）
     *  保存为pb文件
     *  从pb中恢复Graph
     *  Tensorboard可视化  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70]

input\_a,input\_b为数据的输入，add\_e，maltiply\_c为数据的加，乘运算，箭头表示数据的流向

计算图则为网络，网络的参数通过后续的学习得到

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 3]

import tensorflow as tf
    a=tf.constant(1,name='input_a') #张量（常量）
    b=tf.constant(2,name='input_b')#张量
    c=tf.multiply(a,b,name='multiply_c')#乘运算
    d=tf.add(a,b,name='add_d')#加运算
    e=tf.add(d,c,name='add_e')
    sess=tf.Session()#会话
    sess.run(e)
    writer=tf.summary.FileWriter('graph',sess.graph)

#### Session ####

*  图必须在称之为“会话”的上下文中进行
 *  会话将图的op分发到诸如CPU或者GPU之类的设备上执行

session完成了前端和后端的沟通，起到了桥梁的作用  
**常见操作：**

*  session的创建和关闭
 *  session 的注入机制
 *  利用session指定不同的设备
 *  通过session完成资源分配

##### 创建和关闭会话 #####

import tensorflow as tf
    sess=tf.Session()#使用最多，和使用with创建等价
    
    sess=tf.InteractiveSession()#交互式Session，主要用在交互性要求较高的脚本中
    
    with tf.Session() as Sess:
        ...
        
    sess.close()#session关闭

##### 注入机制 #####

是Session具体完成计算图运算的过程，前端和后端的桥梁，注入数据

sess.run(...)#run 中指定需要计算的节点
    sess.run(tf.global_variables_initializer())#tf.global_variables_initializer()：获取当前计算图全部变量
    
    a=tf.placeholder(dtype=tf.float32)#定义a和b，是占位符，实际取值是计算时再赋值即feed操作
    b=tf.placeholder(dtype=tf.float32)
    add=a+b
    add_val=sess.run(add,feed_dict={ a:1,b:2})#a赋值为1，b赋值为2，最终得到value为3=a+b

##### 指定资源设备 #####

a=tf.placeholder(dtype=tf.float32)
    b=tf.placeholder(dtype=tf.float32)
    add=a+b
    with tf.Session() as sess:
        with tf.device("/cpu:0")#指定要运行的计算图所占用的资源设备
        print(sess.run(add,feed_dict={ a:1,b:2}))

##### 资源分配-控制GPU资源使用率 #####

config=tf.ConfigProto()
    config.gpu_options.allow_growth=True#定义gpu参数
    session=tf.Session(config=config,...)#利用config进行session的初始化

#### Tensor ####

在TensorFlow中，所有在节点之间传递的数据都为Tensor对象

将tensor表示为N维数组，图像:(batch \* height \* width \* channel )：NHWC

**Tensor 的定义：**

tf.constant()#常量
    tf.Variable()#变量
    tf.placeholder()#占位符
    tf.SparseTensor()#稀疏张量

**具体定义：**

#常量定义要给定具体的取值，value[1,2]以及当前常量的形状shape(1,2)
    #数据类型dtype，可缺省，也可定义
    #指定常量的name
    #指定常量是否可以改变:verify_shape
    cons=tf.constant(value=[1,2],dtype=tf.float32,shape=(1,2),name='testconst',verify_shape=False)
    
    #占位
    X=tf.placeholder(dtype=tf.float32,shape=[144,10],name='X')
    
    X=tf.placeholder(dtype=float32,shape=[None,None],name='X')
    
    
    #变量定义时不需要指定value，但需要shape，以及数据类型dtype和name
    #变量即其值可以根据训练过程进行改变
    W=tf.Variable(tf.zeros([3,10]),dtype=tf.float64,name='W')

##### Operation #####

Tensorflow Graph中的计算节点，输入输出均为Tensor  
调用Session.run(tensor)或者tensor.eval()方可获取该Tensor的值

##### Feed #####

通过feed为计算图注入值:  
注入值通常就是占位符

a=tf.placeholder(tf.float32)
    b=tf.placeholder(tf.float32)
    c=tf.add(a,b)
    with tf.Session() as sess:
        result=sess.run(c,feed_dict={ a:3,b:4})#这里的c值就是Fecth
        print(result)

##### Fetch #####

使用Fetch获取计算结果

tf.Session.run(fetches,feed_dict=None)
    #fetches可以是单独的参数，也可以是list

范例：

import tensorflow as tf
    x=tf.placeholder(tf.float32,shape=(1,2))
    w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
    w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
    
    a=tf.matmul(x,w1)#矩阵相乘
    y=tf.matmul(a,w2)
    
    with tf.Session() as sess:
    
    	#变量运行前必须进行初始化操作
        init_op=tf.global_variables_initializer()
        sess.run(init_op)
        print(sess.run(y,feed_dict={ x:[[0.7,0.5]]}))#对x赋值，计算y

结果：\[\[3.0904665\]\]

#### Tensorflow中核心API ####

##### 基本运算 #####

tf.expand_dims(input,dim,name=None)
    tf.split(split_dim,num_split,value,name='split')
    tf.concat(concat_dim,values,name='concat')
    tf.cast()
    tf.reshape()
    tf.equal()
    tf.matmul(a,b)
    tf.argmax()#求最大索引值
    tf.squeeze()#去掉纬度为1的张量值

搭建网络时常用tf.nn库

tf.nn.conv2d:卷积层
    tf.nn.max_pool:池化层
    tf.nn.abg_pool:池化层
    tf.nn.relu:激活层
    tf.nn.dropout:
    tf.nn.l2_normalize:归一化层
    tf.nn.batch_nomalization:BN层
    tf.nn.l2_loss:损失层
    tf.nn.softmax_cross_entropy_with_logits:交叉熵损失层

tf.train库：定义了和优化相关的函数  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 4]

Tensorflow提供了TFRecord的格式来统一存储数据（数据的打包）  
\- TFRecord将图像数据和标签放在一起的二进制文件（protocol buffer），能更好的利用内存，实现快速的复制，移动，读取，存储

相应的接口函数：

*  数据读取：`tf.train.string_input_producer`
 *  数据解析：`tf.TFRecordReader,tf.parse_single_example`
 *  数据写入：`tf.python_io.TFRecordWriter`

**数据写入相关API方法：**

`writer=tf.python_io.TFRecordWriter()`

`example=tf.train.Example()//在tf.train.Example()中存取具体的数据，可以定义一个feature，如图像的宽和高`

`writer.close()`

example=tf.train.Example(features=tf.train.Features(feature={ 
    #定义标签和图片，相应的数据类型
        'label':tf.train.Feature(int64_list=tf.train.Feature(value=[index])),
        'img_raw':tf.train.Feature(bytes_list=tf.train.BytesList(value=[img_raw]))
    }))

#### 范例：读取cifar10数据 ####

在cifar-10-batches-py中，已经是二进制文件，可以用python语言解析，也可以自行下载cifar数据进行解析后变成二进制文件。  
官网数据下载：[http://www.cs.toronto.edu/~kriz/cifar.html][http_www.cs.toronto.edu_kriz_cifar.html]

其中data\_batch为训练集，test\_batch为测试集。

import urllib
    import os
    import sys
    import tarfile
    import glob
    import pickle
    import numpy as np
    import cv2
    
    
    classification=['airplane',
                    'automobile',
                    'bird',
                    'cat',
                    'deer',
                    'dog',
                    'frog',
                    'horse',
                    'ship',
                    'truck']
    
    #解析函数
    def unpickle(file):
        import pickle
        with open(file, 'rb') as fo:
            dict = pickle.load(fo, encoding='bytes')
        return dict
    
    folders = '/Users/apple/Downloads/11人脸识别/projects/One/data/cifar-10-batches-py'
    
    trfiles = glob.glob(folders + "/data_batch*")#获取所有文件，训练文件
    
    data = []
    labels = []
    
    for file in trfiles:
        dict = unpickle(file) #解码之后的数据，以字典的格式
        data += list(dict[b"data"])
        labels += list(dict[b"labels"])
    
    
    print(labels)
    
    #图片解析，图片存储
    
    imgs = np.reshape(data,[-1,3,32,32]) #将数据reshape为3 x 32 x 32 ，-1表示为当前有多少图片
    
    for i in range(imgs.shape[0]):
        im_data = imgs[i,...]
        im_data = np.transpose(im_data,[1,2,0])
        im_data = cv2.cvtColor(im_data,cv2.COLOR_RGB2BGR)#数据，转换模式rgb，获取到适用opencv的数据
    
        f="{}/{}".format("data/image/train",classification[labels[i]])#拼接地址，并根据标签找到图片
    
        if not os.path.exists(f):#如果路径不存在
            os.mkdir(f)
    
        cv2.imwrite("{}/{}.jpg".format(f,str(i)),im_data)

结果：在项目train文件夹下多了十个文件夹，是cifar10数据集里的图片

#### TFRecord数据打包 ####

使用tensorflow实现TFRecord图像数据打包，打包成二进制格式讲这些数据用于后续模型的训练

**获得所有图片路径及其种类：**

import glob
    
    classification=['airplane',
                    'automobile',
                    'bird',
                    'cat',
                    'deer',
                    'dog',
                    'frog',
                    'horse',
                    'ship',
                    'truck']
    
    #按照图片类别进行打包
    index = 0 #种类索引
    im_data = [] #存储图片路径
    im_lables = [] #存储图片种类标签
    
    for path in classification: #遍历种类
        path = "/Users/apple/Downloads/11人脸识别/projects/face/data/image/train/" + path
        im_list = glob.glob(path + "/*") #获取图片list
        im_label = [index for i in range(im_list.__len__())] #获取图片的label，label就是classification对应的值，需要遍历索引号
        index +=1
        im_data += im_list #将每个种类下对应的图片路径存放在一起
        im_lables +=im_label
    
    print(im_lables)
    print(im_data)

**封装图片数据：**

#存储获取到的图片数据
    
    tfrecord_file = "/Users/apple/Downloads/11人脸识别/projects/face/data/image/train.tfrecord"
    writer = tf.python_io.TFRecordWriter(tfrecord_file)#传入文件路径
    
    #要将获取到的文件资源写入tfrecord
    
    #获取数据列表
    for i in range(im_data.__len__()):
        im_d = im_data[i]#获取数据
        im_l = im_lables[i]#获取label
        #利用opencv函数对图像进行读取
        data = cv2.imread(im_d)#传入文件路径
    
        #将数据封装到example中
        ex = tf.train.Example(
            features = tf.train.Features(
                feature = { 
                    #图像数据采用byte格式存储
                    "image":tf.train.Feature(
                        bytes_list=tf.train.BytesList(
                            value=[data.tobytes()])), #value：图片数据转成bytes
                    "label":tf.train.Feature(
                        int64_list=tf.train.Int64List(
                            value=[im_l]))
                }
            )
        )
    
        writer.write(ex.SerializeToString())
    
    writer.close()

在对图片数据进行打包时，要注意图片大小是否一致，cifar10中大小都为32x32x3,  
图片大小不一致需对宽高进行定义：

#定义图片大小
                    "height": tf.train.Feature(
                        int64_list=tf.train.Int64List(
                            value=[data.shape[0]])),
                    "width": tf.train.Feature(
                        int64_list=tf.train.Int64List(
                            value=[data.shape[1]]))

**打包时可将数据打乱：**

index = [i for i in range(im_data.__len__())]
    np.random.shuffle(index)

#打包时可以将图片数据打乱
    index = [i for i in range(im_data.__len__())]
    
    np.random.shuffle(index)
    
    #获取数据列表
    for i in range(im_data.__len__()):
        im_d = im_data[index[i]]#获取数据
        im_l = im_lables[index[i]]#获取label
        #利用opencv函数对图像进行读取
        data = cv2.imread(im_d)#传入文件路径
    
        #将数据封装到example中
        ex = tf.train.Example(
            features = tf.train.Features(
                feature = { 
                    #图像数据采用byte格式存储
                    "image":tf.train.Feature(
                        bytes_list=tf.train.BytesList(
                            value=[data.tobytes()])), #value：图片数据转成bytes
                    "label":tf.train.Feature(
                        int64_list=tf.train.Int64List(
                            value=[im_l]))
                }
            )
        )
    
        writer.write(ex.SerializeToString())
    
    writer.close()

**读取文件有两种方式：**  
opencv和tensorflow

data = cv2.imread(im_d)#传入文件路径
    data = tf.gfile.FastGFile(im_d,"rb").read()#得到的文件更小，会进行编码，使用时要进行解码

#### 利用tensorflow对图片数据进行读取 ####

##### 利用tf.train.slice\_input\_producer进行读取 #####

#利用tensorflow对图片数据进行读取
    
    import tensorflow as tf
    
    images = ['image1.jpg','image2.jpg','image3.jpg','image4.jpg']
    labels = [1,2,3,4]
    
    #利用tf.train.slice_input_producer进行读取，传入参数为路径和标签
    
    [images,labels] = tf.train.slice_input_producer([images,labels],num_epochs=None,shuffle=True)
    #一个epoch表示将所有样本进行一轮循环,None 表示不规定多少个epoch，只要想从文件序列读取数据就有数据
    #shuffle:对文件数据打乱
    
    
    with tf.Session() as sess:
        sess.run(tf.local_variables_initializer())#初始化文件
        #文件队列填充的线程，启动后则填充
        tf.train.start_queue_runners(sess=sess)
    
        #从文件对列中获取数据
        #文件队列中只要八个数据，如果大于八则报错，epoch=2轮*4，如果想要更多数据则epoch=None
        for i in range(10):
            print(sess.run([images,labels]))
    
    #结果：
    """[b'image1.jpg', 1] [b'image3.jpg', 3] [b'image2.jpg', 2] [b'image4.jpg', 4] [b'image1.jpg', 1] [b'image4.jpg', 4] [b'image3.jpg', 3] [b'image2.jpg', 2] [b'image3.jpg', 3] [b'image1.jpg', 1]"""

##### 利用tf.train.string\_input\_producer进行读取 #####

import tensorflow as tf
    #利用tf读取文件
    
    filename = ['/Users/apple/Downloads/11人脸识别/projects/face/data/A.csv',
    '/Users/apple/Downloads/11人脸识别/projects/face/data/B.csv',
    '/Users/apple/Downloads/11人脸识别/projects/face/data/C.csv']
    
    file_queue = tf.train.string_input_producer(filename,shuffle=True,num_epochs=2)#传入路径
    
    reader = tf.WholeFileReader()#文件读取器
    
    key, value = reader.read(file_queue) #获取键值对，key：图片名称，value图片内容
    
    with tf.Session() as sess:
        sess.run(tf.local_variables_initializer())
        tf.train.start_queue_runners(sess=sess)#填充进程
        for i in range(6):#epoce=2,文件数为3
            print(sess.run([key,value]))
    
    
    #结果：
    """[b'/Users/apple/Downloads/11\xe4\xba\xba\xe8\x84\xb8\xe8\xaf\x86\xe5\x88\xab/projects/face/data/A.csv', b'1.jpg,1\n2.jpg,2\n3.jpg,3\n'] [b'/Users/apple/Downloads/11\xe4\xba\xba\xe8\x84\xb8\xe8\xaf\x86\xe5\x88\xab/projects/face/data/C.csv', b'7.jpg,7\n8.jpg,8\n9.jpg,9\n'] [b'/Users/apple/Downloads/11\xe4\xba\xba\xe8\x84\xb8\xe8\xaf\x86\xe5\x88\xab/projects/face/data/B.csv', b'4.jpg,4\n5.jpg,5\n6.jpg,6\n'] [b'/Users/apple/Downloads/11\xe4\xba\xba\xe8\x84\xb8\xe8\xaf\x86\xe5\x88\xab/projects/face/data/B.csv', b'4.jpg,4\n5.jpg,5\n6.jpg,6\n'] [b'/Users/apple/Downloads/11\xe4\xba\xba\xe8\x84\xb8\xe8\xaf\x86\xe5\x88\xab/projects/face/data/C.csv', b'7.jpg,7\n8.jpg,8\n9.jpg,9\n'] [b'/Users/apple/Downloads/11\xe4\xba\xba\xe8\x84\xb8\xe8\xaf\x86\xe5\x88\xab/projects/face/data/A.csv', b'1.jpg,1\n2.jpg,2\n3.jpg,3\n']"""

#### 利用TF对已经打包的数据进行解析 ####

#对打包后的文件进行解析
    
    import tensorflow as tf
    
    filelist = ['/Users/apple/Downloads/11人脸识别/projects/face/data/image/train.tfrecord2']
    file_queue = tf.train.string_input_producer(filelist, num_epochs=None,shuffle=True)
    
    reader = tf.TFRecordReader()
    
    _, ex = reader.read(file_queue)
    
    #读取的数据是序列化后的数据
    
    feature = { 
        'image':tf.FixedLenFeature([],tf.string),
        'label':tf.FixedLenFeature([],tf.int64)
    }
    batchsize = 1
    batch = tf.train.shuffle_batch([ex],batchsize,capacity=batchsize*10,min_after_dequeue=batchsize*5)
    
    #解码
    example = tf.parse_example(batch, features=feature)
    
    image = example['image']
    label = example['label']
    
    image = tf.decode_raw(image,tf.uint8)
    image = tf.reshape(image,[-1,32,32,3])
    
    with tf.Session() as sess:
        sess.run(tf.local_variables_initializer())
        tf.train.start_queue_runners(sess=sess)
    
        for i in range(1):
            image_bth, _ = sess.run([image, label])
            import cv2
    
            #可视化
            cv2.imshow("image", image_bth[0, ...])
            cv2.waitKey(0)

#### Tensorflow中的高层接口（待学） ####

搭建网络结构：TF-Slim, TFLearn, Keras, TensorLayer

#### Tensorflow实现数据增强（介绍） ####

**使用tf.image库进行数据增强**

*  使用tf.image库进行数据增强
    
     *  颜色扰动（亮度、对比度、HSV、RGB等）
     *  裁剪/Pad
     *  噪声/模糊
     *  翻转/旋转（空间几何变换/放射变换）
     *  Draw Boxes
     *  标准化
     *  其他数据增强方法
        
         *  Mixup
         *  Oversampling
         *  锐化/浮雕/灰度
         *  边界检测
         *  超像素
         *  255-V  
            ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 5]

模型训练必须使用数据增强，充分利用大数据

#### TensorBoard使用 ####

TensorBoard可以进行网络可视化/训练中间结果可视化

查看数据增强之后结果，数据分布，参数分布，各种图

[https_github.com_tensorflow]: https://github.com/tensorflow
[https_github.com_tensorflow_models]: https://github.com/tensorflow/models
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200201114555345.jpeg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200201115126499.jpeg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2020020111555143.jpeg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200201115853391.jpeg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200201160757509.jpeg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1,size_16,color_FFFFFF,t_70
[http_www.cs.toronto.edu_kriz_cifar.html]: http://www.cs.toronto.edu/~kriz/cifar.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200203151741982.jpeg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2F5YW5nYW5uOTE1,size_16,color_FFFFFF,t_70