【SSD目标检测】1：图片、视频内的物体检测与定位

曾经终败给现在 2021-08-19 15:58 637阅读 1赞

# 一、SSD用于图片物体的定位与检测 #

[SSD原理介绍][SSD]这一篇博客对我的帮助比较大，很详细的介绍了SSD原理，送给大家做了解

## 1、下载SSD框架源码 ##

1.1：闲话不多说——下载[SSD源码][SSD 1]，解压后打开文件，将`checkpoints`文件夹下的压缩包也解压出来，再在pycharm上建立工程，大体如下图所示：  
![这里写图片描述][70]  
1.2：打开`demo`文件夹，这里就是用于外测的图片集  
![这里写图片描述][70 1]

## 2、SSD做目标检测 ##

在`notebooks`文件夹下，建立`demo_test.py`文件，在`demo_test.py`文件内写入如下代码后，直接运行`demo_test.py`(以下代码也是`notebooks`文件夹`ssd_tests.ipynb`内的代码，可以用notebook读取；我只是做了一些小改动)

# -*- coding：utf-8 -*-
    # -*- author：zzZ_CMing CSDN address:https://blog.csdn.net/zzZ_CMing
    # -*- 2018/07/14; 15:19
    # -*- python3.5
    """ address: https://blog.csdn.net/qq_35608277/article/details/78660469 本文代码来自于github中微软官方仓库 """
    import os
    import cv2
    import math
    import random
    import tensorflow as tf
    import matplotlib.pyplot as plt
    import matplotlib.cm as mpcm
    import matplotlib.image as mpimg
    from notebooks import visualization
    from nets import ssd_vgg_300, ssd_common, np_methods
    from preprocessing import ssd_vgg_preprocessing
    import sys
    
    # 当引用模块和运行的脚本不在同一个目录下，需在脚本开头添加如下代码：
    sys.path.append('./SSD-Tensorflow/')
    
    slim = tf.contrib.slim
    
    # TensorFlow session
    gpu_options = tf.GPUOptions(allow_growth=True)
    config = tf.ConfigProto(log_device_placement=False, gpu_options=gpu_options)
    isess = tf.InteractiveSession(config=config)
    
    l_VOC_CLASS = ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle',
                   'bus', 'car', 'cat', 'chair', 'cow',
                   'diningTable', 'dog', 'horse', 'motorbike', 'person',
                   'pottedPlant', 'sheep', 'sofa', 'train', 'TV']
    
    # 定义数据格式，设置占位符
    net_shape = (300, 300)
    # 预处理，以Tensorflow backend, 将输入图片大小改成 300x300，作为下一步输入
    img_input = tf.placeholder(tf.uint8, shape=(None, None, 3))
    # 输入图像的通道排列形式，'NHWC'表示 [batch_size,height,width,channel]
    data_format = 'NHWC'
    
    # 数据预处理，将img_input输入的图像resize为300大小，labels_pre,bboxes_pre,bbox_img待解析
    image_pre, labels_pre, bboxes_pre, bbox_img = ssd_vgg_preprocessing.preprocess_for_eval(
        img_input, None, None, net_shape, data_format,
        resize=ssd_vgg_preprocessing.Resize.WARP_RESIZE)
    # 拓展为4维变量用于输入
    image_4d = tf.expand_dims(image_pre, 0)
    
    # 定义SSD模型
    # 是否复用，目前我们没有在训练所以为None
    reuse = True if 'ssd_net' in locals() else None
    # 调出基于VGG神经网络的SSD模型对象，注意这是一个自定义类对象
    ssd_net = ssd_vgg_300.SSDNet()
    # 得到预测类和预测坐标的Tensor对象，这两个就是神经网络模型的计算流程
    with slim.arg_scope(ssd_net.arg_scope(data_format=data_format)):
        predictions, localisations, _, _ = ssd_net.net(image_4d, is_training=False, reuse=reuse)
    
    # 导入官方给出的 SSD 模型参数
    ckpt_filename = '../checkpoints/ssd_300_vgg.ckpt'
    # ckpt_filename = '../checkpoints/VGG_VOC0712_SSD_300x300_ft_iter_120000.ckpt'
    isess.run(tf.global_variables_initializer())
    saver = tf.train.Saver()
    saver.restore(isess, ckpt_filename)
    
    # 在网络模型结构中，提取搜索网格的位置
    # 根据模型超参数，得到每个特征层（这里用了6个特征层，分别是4，7，8，9，10，11）的anchors_boxes
    ssd_anchors = ssd_net.anchors(net_shape)
    """ 每层的anchors_boxes包含4个arrayList，前两个List分别是该特征层下x，y坐标轴对于原图（300x300）大小的映射 第三,四个List为anchor_box的长度和宽度，同样是经过归一化映射的，根据每个特征层box数量的不同，这两个List元素 个数会变化。其中，长宽的值根据超参数anchor_sizes和anchor_ratios制定。 """
    
    
    # 加载辅助作图函数
    def colors_subselect(colors, num_classes=21):
        dt = len(colors) // num_classes
        sub_colors = []
        for i in range(num_classes):
            color = colors[i * dt]
            if isinstance(color[0], float):
                sub_colors.append([int(c * 255) for c in color])
            else:
                sub_colors.append([c for c in color])
        return sub_colors
    
    
    def bboxes_draw_on_img(img, classes, scores, bboxes, colors, thickness=2):
        shape = img.shape
        for i in range(bboxes.shape[0]):
            bbox = bboxes[i]
            color = colors[classes[i]]
            # Draw bounding box...
            p1 = (int(bbox[0] * shape[0]), int(bbox[1] * shape[1]))
            p2 = (int(bbox[2] * shape[0]), int(bbox[3] * shape[1]))
            cv2.rectangle(img, p1[::-1], p2[::-1], color, thickness)
            # Draw text...
            s = '%s/%.3f' % (l_VOC_CLASS[int(classes[i]) - 1], scores[i])
            p1 = (p1[0] - 5, p1[1])
            # cv2.putText(img, s, p1[::-1], cv2.FONT_HERSHEY_DUPLEX, 1.5, color, 3)
    
    
    colors_plasma = colors_subselect(mpcm.plasma.colors, num_classes=21)
    
    
    # 主流程函数
    def process_image(img, case, select_threshold=0.15, nms_threshold=.1, net_shape=(300, 300)):
        # select_threshold：box阈值——每个像素的box分类预测数据的得分会与box阈值比较，高于一个box阈值则认为这个box成功框到了一个对象
        # nms_threshold：重合度阈值——同一对象的两个框的重合度高于该阈值，则运行下面去重函数
    
        # 执行SSD模型，得到4维输入变量，分类预测，坐标预测，rbbox_img参数为最大检测范围，本文固定为[0,0,1,1]即全图
        rimg, rpredictions, rlocalisations, rbbox_img = isess.run([image_4d, predictions,
                                                                   localisations, bbox_img], feed_dict={ img_input: img})
    
        # ssd_bboxes_select()函数根据每个特征层的分类预测分数，归一化后的映射坐标，
        # ancohor_box的大小，通过设定一个阈值计算得到每个特征层检测到的对象以及其分类和坐标
        rclasses, rscores, rbboxes = np_methods.ssd_bboxes_select(rpredictions, rlocalisations, ssd_anchors,
                                                                  select_threshold=select_threshold,
                                                                  img_shape=net_shape,
                                                                  num_classes=21, decode=True)
    
        """ 这个函数做的事情比较多，这里说的细致一些： 首先是输入，输入的数据为每个特征层（一共6个，见上文）的： rpredictions: 分类预测数据， rlocalisations: 坐标预测数据， ssd_anchors: anchors_box数据 其中： 分类预测数据为当前特征层中每个像素的每个box的分类预测 坐标预测数据为当前特征层中每个像素的每个box的坐标预测 anchors_box数据为当前特征层中每个像素的每个box的修正数据 函数根据坐标预测数据和anchors_box数据，计算得到每个像素的每个box的中心和长宽，这个中心坐标和长宽会根据一个算法进行些许的修正， 从而得到一个更加准确的box坐标；修正的算法会在后文中详细解释，如果只是为了理解算法流程也可以不必深究这个，因为这个修正算法属于经验算 法，并没有太多逻辑可循。 修正完box和中心后，函数会计算每个像素的每个box的分类预测数据的得分，当这个分数高于一个阈值（这里是0.5）则认为这个box成功 框到了一个对象，然后将这个box的坐标数据，所属分类和分类得分导出，从而得到： rclasses：所属分类 rscores：分类得分 rbboxes：坐标 最后要注意的是，同一个目标可能会在不同的特征层都被检测到，并且他们的box坐标会有些许不同，这里并没有去掉重复的目标，而是在下文 中专门用了一个函数来去重 """
    
        # 检测有没有超出检测边缘
        rbboxes = np_methods.bboxes_clip(rbbox_img, rbboxes)
        rclasses, rscores, rbboxes = np_methods.bboxes_sort(rclasses, rscores, rbboxes, top_k=400)
        # 去重，将重复检测到的目标去掉
        rclasses, rscores, rbboxes = np_methods.bboxes_nms(rclasses, rscores, rbboxes, nms_threshold=nms_threshold)
        # 将box的坐标重新映射到原图上（上文所有的坐标都进行了归一化，所以要逆操作一次）
        rbboxes = np_methods.bboxes_resize(rbbox_img, rbboxes)
    
        if case == 1:
            bboxes_draw_on_img(img, rclasses, rscores, rbboxes, colors_plasma, thickness=8)
            return img
        else:
            return rclasses, rscores, rbboxes
    
    
    """ # 只做目标定位，不做预测分析 case = 1 img = cv2.imread("../demo/person.jpg") img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) plt.imshow(process_image(img, case)) plt.show() """
    # 做目标定位，同时做预测分析
    case = 2
    path = '../demo/person.jpg'
    # 读取图片
    img = mpimg.imread(path)
    # 执行主流程函数
    rclasses, rscores, rbboxes = process_image(img, case)
    # visualization.bboxes_draw_on_img(img, rclasses, rscores, rbboxes, visualization.colors_plasma)
    # 显示分类结果图
    visualization.plt_bboxes(img, rclasses, rscores, rbboxes), rscores, rbboxes

## 3、SSD目标检测结果 ##

会得到如下图示，如图已经成功的把物体标注出来，每个标记框中前一个数是标签项，后一个是预测的准确率；

# 标签项与其对应的标签内容
    dict = { 1:'aeroplane',    2:'bicycle', 3:'bird',   4:'boat',       5:'bottle',
            6:'bus',          7:'car',     8:'cat',    9:'chair',      10:'cow',
            11:'diningTable', 12:'dog',    13:'horse', 14:'motorbike', 15:'person',
            16:'pottedPlant', 17:'sheep',  18:'sofa',  19:'train',     20:'TV'}

![这里写图片描述][70 2]

–**----**\----**----**\----**----**\----**----**\----**----**\----**----**\-----**----**\----**----**\----**----**\----**----**—**----**\----**----**\----**----**\----**----**\----**----**\----**----  
–**\----**----**\----**----**\----**----**\----**----**\----**----**\----**-----**\----**----**\----**----**\----**----**\----**—**\----**----**\----**----**\----**----**\----**----**\----**----**\----

# 二、SSD用于视频内物体的定位 #

以上`demo`文件夹内都只是图片，如果你想在视频中标记物体——首先你需要拍一段视频，建议不要太长不然你要跑很久，然后需要在主目录下建立`Video`文件夹，在其下建立`input`、`output`文件夹，如下图所示：  
![这里写图片描述][70 3]

再将拍摄的视频存入`input`文件夹下，注意视频的名称哦！最后在主目录下建立`demo_Video.py`文件，存入如下代码，运行`demo_Video.py`

**请注意：安装imageio：`pip install imageio==2.4.1`**

class="token boolean">True

# -*- coding：utf-8 -*-
    # -*- author：zzZ_CMing CSDN address:https://blog.csdn.net/zzZ_CMing
    # -*- 2018/07/09; 15:19
    # -*- python3.6
    import os
    import cv2
    import math
    import random
    import tensorflow as tf
    import matplotlib.pyplot as plt
    import matplotlib.cm as mpcm
    import matplotlib.image as mpimg
    from notebooks import visualization
    from nets import ssd_vgg_300, ssd_common, np_methods
    from preprocessing import ssd_vgg_preprocessing
    import sys
    
    # 当引用模块和运行的脚本不在同一个目录下，需在脚本开头添加如下代码：
    sys.path.append('./SSD-Tensorflow/')
    
    slim = tf.contrib.slim
    
    # TensorFlow session
    gpu_options = tf.GPUOptions(allow_growth=True)
    config = tf.ConfigProto(log_device_placement=False, gpu_options=gpu_options)
    isess = tf.InteractiveSession(config=config)
    
    l_VOC_CLASS = ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle',
                   'bus', 'car', 'cat', 'chair', 'cow',
                   'diningTable', 'dog', 'horse', 'motorbike', 'person',
                   'pottedPlant', 'sheep', 'sofa', 'train', 'TV']
    
    # 定义数据格式，设置占位符
    net_shape = (300, 300)
    # 预处理，以Tensorflow backend, 将输入图片大小改成 300x300，作为下一步输入
    img_input = tf.placeholder(tf.uint8, shape=(None, None, 3))
    # 输入图像的通道排列形式，'NHWC'表示 [batch_size,height,width,channel]
    data_format = 'NHWC'
    
    # 数据预处理，将img_input输入的图像resize为300大小，labels_pre,bboxes_pre,bbox_img待解析
    image_pre, labels_pre, bboxes_pre, bbox_img = ssd_vgg_preprocessing.preprocess_for_eval(
        img_input, None, None, net_shape, data_format,
        resize=ssd_vgg_preprocessing.Resize.WARP_RESIZE)
    # 拓展为4维变量用于输入
    image_4d = tf.expand_dims(image_pre, 0)
    
    # 定义SSD模型
    # 是否复用，目前我们没有在训练所以为None
    reuse = True if 'ssd_net' in locals() else None
    # 调出基于VGG神经网络的SSD模型对象，注意这是一个自定义类对象
    ssd_net = ssd_vgg_300.SSDNet()
    # 得到预测类和预测坐标的Tensor对象，这两个就是神经网络模型的计算流程
    with slim.arg_scope(ssd_net.arg_scope(data_format=data_format)):
        predictions, localisations, _, _ = ssd_net.net(image_4d, is_training=False, reuse=reuse)
    
    # 导入官方给出的 SSD 模型参数
    ckpt_filename = 'checkpoints/ssd_300_vgg.ckpt'
    # ckpt_filename = '../checkpoints/VGG_VOC0712_SSD_300x300_ft_iter_120000.ckpt'
    isess.run(tf.global_variables_initializer())
    saver = tf.train.Saver()
    saver.restore(isess, ckpt_filename)
    
    # 在网络模型结构中，提取搜索网格的位置
    # 根据模型超参数，得到每个特征层（这里用了6个特征层，分别是4，7，8，9，10，11）的anchors_boxes
    ssd_anchors = ssd_net.anchors(net_shape)
    """ 每层的anchors_boxes包含4个arrayList，前两个List分别是该特征层下x，y坐标轴对于原图（300x300）大小的映射 第三,四个List为anchor_box的长度和宽度，同样是经过归一化映射的，根据每个特征层box数量的不同，这两个List元素 个数会变化。其中，长宽的值根据超参数anchor_sizes和anchor_ratios制定。 """
    
    
    # 加载辅助作图函数
    def colors_subselect(colors, num_classes=21):
        dt = len(colors) // num_classes
        sub_colors = []
        for i in range(num_classes):
            color = colors[i * dt]
            if isinstance(color[0], float):
                sub_colors.append([int(c * 255) for c in color])
            else:
                sub_colors.append([c for c in color])
        return sub_colors
    
    
    def bboxes_draw_on_img(img, classes, scores, bboxes, colors, thickness=2):
        shape = img.shape
        for i in range(bboxes.shape[0]):
            bbox = bboxes[i]
            color = colors[classes[i]]
            # Draw bounding box...
            p1 = (int(bbox[0] * shape[0]), int(bbox[1] * shape[1]))
            p2 = (int(bbox[2] * shape[0]), int(bbox[3] * shape[1]))
            cv2.rectangle(img, p1[::-1], p2[::-1], color, thickness)
            # Draw text...
            s = '%s/%.3f' % (l_VOC_CLASS[int(classes[i]) - 1], scores[i])
            p1 = (p1[0] - 5, p1[1])
            # cv2.putText(img, s, p1[::-1], cv2.FONT_HERSHEY_DUPLEX, 1.5, color, 3)
    
    
    colors_plasma = colors_subselect(mpcm.plasma.colors, num_classes=21)
    
    
    # 主流程函数
    def process_image(img, select_threshold=0.4, nms_threshold=.1, net_shape=(300, 300)):
        # select_threshold：box阈值——每个像素的box分类预测数据的得分会与box阈值比较，高于一个box阈值则认为这个box成功框到了一个对象
        # nms_threshold：重合度阈值——同一对象的两个框的重合度高于该阈值，则运行下面去重函数
    
        # 执行SSD模型，得到4维输入变量，分类预测，坐标预测，rbbox_img参数为最大检测范围，本文固定为[0,0,1,1]即全图
        rimg, rpredictions, rlocalisations, rbbox_img = isess.run([image_4d, predictions, localisations, bbox_img],
                                                                  feed_dict={ img_input: img})
    
        # ssd_bboxes_select函数根据每个特征层的分类预测分数，归一化后的映射坐标，
        # ancohor_box的大小，通过设定一个阈值计算得到每个特征层检测到的对象以及其分类和坐标
        rclasses, rscores, rbboxes = np_methods.ssd_bboxes_select(rpredictions, rlocalisations, ssd_anchors,
                                                                  select_threshold=select_threshold,
                                                                  img_shape=net_shape,
                                                                  num_classes=21, decode=True)
    
        """ 这个函数做的事情比较多，这里说的细致一些： 首先是输入，输入的数据为每个特征层（一共6个，见上文）的： 分类预测数据（rpredictions）， 坐标预测数据（rlocalisations）， anchors_box数据（ssd_anchors） 其中： 分类预测数据为当前特征层中每个像素的每个box的分类预测 坐标预测数据为当前特征层中每个像素的每个box的坐标预测 anchors_box数据为当前特征层中每个像素的每个box的修正数据 函数根据坐标预测数据和anchors_box数据，计算得到每个像素的每个box的中心和长宽，这个中心坐标和长宽会根据一个算法进行些许的修正， 从而得到一个更加准确的box坐标；修正的算法会在后文中详细解释，如果只是为了理解算法流程也可以不必深究这个，因为这个修正算法属于经验算 法，并没有太多逻辑可循。 修正完box和中心后，函数会计算每个像素的每个box的分类预测数据的得分，当这个分数高于一个阈值（这里是0.5）则认为这个box成功 框到了一个对象，然后将这个box的坐标数据，所属分类和分类得分导出，从而得到： rclasses：所属分类 rscores：分类得分 rbboxes：坐标 最后要注意的是，同一个目标可能会在不同的特征层都被检测到，并且他们的box坐标会有些许不同，这里并没有去掉重复的目标，而是在下文 中专门用了一个函数来去重 """
    
        # 检测有没有超出检测边缘
        rbboxes = np_methods.bboxes_clip(rbbox_img, rbboxes)
        rclasses, rscores, rbboxes = np_methods.bboxes_sort(rclasses, rscores, rbboxes, top_k=400)
        # 去重，将重复检测到的目标去掉
        rclasses, rscores, rbboxes = np_methods.bboxes_nms(rclasses, rscores, rbboxes, nms_threshold=nms_threshold)
        # 将box的坐标重新映射到原图上（上文所有的坐标都进行了归一化，所以要逆操作一次）
        rbboxes = np_methods.bboxes_resize(rbbox_img, rbboxes)
    
        bboxes_draw_on_img(img, rclasses, rscores, rbboxes, colors_plasma, thickness=8)
        return img
    
    
    # 视频物体定位
    import imageio        # pip install imageio==2.4.1
    imageio.plugins.ffmpeg.download()
    from moviepy.editor import VideoFileClip
    
    
    def get_process_video(input_path, output_path):
        video = VideoFileClip(input_path)
        result = video.fl_image(process_image)
        result.write_videofile(output_path, fps=25)
    
    
    
    try:
        os.makedirs("Video/input/")
        os.makedirs("Video/output/")
    except:
        input_folder = "Video/input/"
        input_video_name = sorted(os.listdir(input_folder))[-1]
        input_video_path = input_folder + input_video_name
        output_video_path = "Video/output/output_" + input_video_name
    
        get_process_video(input_video_path, output_video_path)

经过一段时间的等待，终于跑完程序；  
![这里写图片描述][70 4]  
打开`Video/input`文件夹，查看输出的视频是什么样子的吧！

由于博客里只能上传gif图，虽然原图画质很好，但到了这里怎么变成这样？我能怎么办——我也很绝望  
但是依稀可以看到里面的汽车、行人、自行车都被不同的颜色框标注起来了，说明我们是成功的！赶快动手试一试，很好玩的

![这里写图片描述][70 5]

## 后续： ##

[SSD目标检测(2)：如何制作自己的数据集（详细说明附源码）][SSD_2]  
[SSD目标检测(3)：使用自己的数据集做预测（详细说明附源码）][SSD_3]  
这两篇是SSD框架的实际运用——因为SSD框架只有20类物体被标注，也就是说只能用来识别这特定的20种物体，而实际需求会随着环境有很大的改变，所以这两篇就是教大家如何利用SSD框架，**制作自己的数据集，并通过自己的数据集标注定位新物体**，这个拓展练习有趣且实用，也是模式识别常见的问题研究，大家赶快动手试一试吧。

## yfw–补充说明： ##

**linux下测试结果**  
系统：ubuntu16.04  
tensorflow版本 ：tensorflow 1.15.0  
python：3.5![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI1Nzc0NzQ_size_16_color_FFFFFF_t_70]  
**Windows下测试结果**  
tensorflow版本 ：tensorflow1.15.0  
python：3.7.1

**tf-gpu环境搭建**  
tensorflow-gpu版本：tensorflow-gpu 1.15.0  
cuda版本：[cuda 10.0][]  
[各版本官网下载链接][Link 1]  
cudnn版本 ：[cuDNN v7.6.0.64][]  
[各版本官网下载链接][Link 2]

**出现下面错误解决：**

2019-12-24 12:55:23.087912: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Could not find library cudart64_100.dll
    2019-12-24 12:55:23.092913: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Could not find library  cublas64_100.dll
    2019-12-24 12:55:23.096913: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Could not find library  cufft64_100.dll
    2019-12-24 12:55:23.098913: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Could not find library  curand64_100.dll
    2019-12-24 12:55:23.103913: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Could not find library  cusolver64_100.dll
    2019-12-24 12:55:23.106913: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Could not find library  cusparse64_100.dll
    2019-12-24 12:55:23.116914: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Could not find library  cudnn64_7.dll

[tensorflow-gpu的使用相关Windows7环境配置][tensorflow-gpu_Windows7]  
[错误解决参考][tensorflow-gpu_Windows7]

[SSD]: https://jizhi.im/blog/post/gpu-p6
[SSD 1]: https://github.com/balancap/SSD-Tensorflow
[70]: /images/20210726/933966da4a7a40d0a621ef1cea936e4c.png
[70 1]: /images/20210726/c9a77b8f3389479f8fd1f794d049574c.png
[70 2]: /images/20210726/a894f400bde34ca189fefe698b413003.png
[70 3]: /images/20210726/58b89a90c81245ada05ac33789aba2d8.png
[70 4]: /images/20210726/85e4da9ec3e9472d89b11e1ced6579b4.png
[70 5]: /images/20210726/89defdf4f4ad4be8af2feffab7cb5bcf.png
[SSD_2]: https://blog.csdn.net/zzz_cming/article/details/81131101
[SSD_3]: https://blog.csdn.net/zzz_cming/article/details/81131523
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTI1Nzc0NzQ_size_16_color_FFFFFF_t_70]: /images/20210726/3f410ba0cdd44e708c2a66d9ca15c462.png
[cuda 10.0]: http://developer.download.nvidia.com/compute/cuda/7.5/Prod/local_installers/cuda_7.5.18_windows.exe
[Link 1]: https://developer.nvidia.com/cuda-75-downloads-archive
[cuDNN v7.6.0.64]: https://developer.nvidia.com/compute/machine-learning/cudnn/secure/v7.6.0.64/prod/10.0_20190516/cudnn-10.0-windows7-x64-v7.6.0.64.zip
[Link 2]: https://developer.nvidia.com/rdp/cudnn-archive
[tensorflow-gpu_Windows7]: https://blog.csdn.net/u012577474/article/details/103679481