亚信图像算法实习笔记

授权书区域识别项目：2023.7.24～2023.8.20

修改Linux服务器文件权限问题

• 将文件设置为可读写执行权限：

1

$ chmod 777 file

• 给文件所有者增加写权限：

1

$ chmod u+w file

• 给文件所有者和同组用户赋予读写权限，其他用户只有读权限：

1

$ chmod 664 file

• 递归修改目录及其子目录中的文件权限：

1

$ chmod -R 755 directory

• 显示修改后的权限信息：

1

$ chmod -v 755 file

请注意，修改文件或目录的权限需要有足够的权限进行操作。只有文件或目录的所有者或超级用户(root)才能更改权限。

Docker配置深度学习环境

第一步，安装Docker

• 检查docker是否安装：

1

$ docker help

• 如果没有安装docker，则使用官方提供的脚本进行安装：

1

$ curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

Docker镜像加速

• 在/etc/docker/daemon.json中写入如下内容，如果没有该文件则新建：

1

{"registry-mirrors":["https://XXX.mirror.aliyuncs.com/"]}

• 重启Docker服务：

1
2

$ sudo systemctl daemon-reload
$ sudo systemctl restart docker

从Docker Hub下载镜像

• 进入Docker Hub，因为我使用的是pytorch的训练框架，搜索torch1.9.0-cuda11.1-cudnn8
• 点击左边的tags，复制拉取镜像的脚本，在服务器的命令行上运行

运行Docker容器

• 下载完容器镜像之后，查看所有images：

1

$ docker images

• 找到自己的容器，启动该容器：

1

$ docker run -it mindest/torch1.9.0-cuda11.1-cudnn8:bevt /bin/bash 

参数说明：

-i：交互式操作

-t：终端

mindest/torch1.9.0-cuda11.1-cudnn8:bevt：镜像名称：镜像标签

bin/bash：放在镜像后面的是命令，这里我们希望有个交互式 Shell，因此用的是bin/bash。/bin/bash的作用是表示载入容器后运行bash ,docker中必须要保持一个进程的运行，要不然整个容器启动后就会马上kill itself，这个/bin/bash就表示启动容器后启动bash。

在容器内安装所需要的包，并更新镜像

• 安装需要的包，直接使用pip install和conda install
• 更新镜像：容器是动态的，镜像是静态的。我们在容器里更新了Python包，为了以后可以持久地使用，还需要使用commit将容器打包为镜像。

1

$ docker commit -m="update packages" -a="XXX" bb8967093b48 XXX/torch1.9.0-cuda11.1-cudnn8:bevt

各个参数说明：

• -m: 提交的描述信息
• -a: 指定镜像作者
• bb8967093b48：容器 ID
• XXX/mypymarl:v1: 指定要创建的目标镜像名（作者名/镜像名：标签）

在本地使用容器运行代码

• 首先我们需要创建一个本地的Ubuntu系统和docker容器共享的文件夹：

1
2

$ sudo mkdir /data
$ sudo docker run -v /data:/data -itd caixj/pytorch:v1

• 查看正在运行的容器:

1

$ docker ps

• 找到我们容器的ID，并进入该容器

1

$ docker attach 500ad76de1cf

安装nvdia-cuda

Docker 默认是不支持在容器内 GPU 加速的，NVIDIA 官方做了个工具箱来支持容器内 GPU 加速运算，这大大方便了深度学习开发者。这里直接根据官方教程安装即可。

https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html

安装完nvidia-cuda之后，再创建容器时加上--gpus all，即可在容器内调用cuda，即

1

$ sudo docker run -v /data:/data -itd --gpus all caixj/pytorch:v1 /bin/bash

然后跟上述步骤相同，进入容器，然后运行代码就ok。

• 本地保存镜像

1
2
3

$ docker save -o <your_file_name.tar> <image id>
# 根据测试的反馈来说，最好不用image id进行save
$ docker save -o <your_file_name.tar> <image name:version>

• 通过本地镜像导入docker容器

1
2
3
4

$ docker load < your_file.tar.gz
# 或者
$ docker load --input your_file.tar
# 它的images的名字会变为your_file:latest

• 比较好的进入容器的方法：

1

$ docker exec -it 容器id /bin/bash

• 使用docker exec命令进入容器后，再使用exit命令退出容器，容器仍将保持运行，而docker attach进入使用exit退出后容器会停止运行

Docker常用命令

• 查看所有镜像

1

docker images

• 查找镜像

1

docker search XXX/image

• 下载镜像

1

docker pull XXX/images:tag

• 删除镜像

1

docker rmi XXX/images:ta

• 启动容器

1

docker run -it image:tag /bin/bash

• 退出容器

1

exit

• 查看正在运行的容器

1

docker ps

• 进入正在运行的容器

1

docker attach container_ID

• 查看已停止运行的容器

1

docker ps -a

• 启动已停止的容器

1

docker start container_ID

• 停止容器

1

docker stop container_ID

• 重启已停止容器

1

docker restart container_I

• 进入容器方式（退出容器终端时但不停止）

1

docker exec

• 清理Docker容器

1

docker rm [container id]

• 清理所有Docker镜像

1

docker image prune -a

• 清理Docker缓存文件

1

docker system prune --force --all --volumes

目标检测检测框原理

YOLOv4检测头原理

检测头由一个常规的$3\times 3$卷积接上一个$1\times 1$卷积组成。假设输入图像为$416\times 416$，最后得到的特征图的大小为(B, 75, 26, 26)，这里的分类数为20。

那么通道数75是如何得到的呢？

75 = 3 * （5 + 分类数） = 3 * （4 + 1 + 20）= 75

在$26\times 26$的特征层中，会预先标定三个先验框，YOLOv4网络的预测结果只会判定先验框内部是否包含物体和这个物体的种类以及对先验框进行调整，获得一个新的预测框。

所以上面的3代表每一个特征图上的三个先验框。4 + 1中的4代表了先验框的调整参数，1的内容代表先验框内部是否包含物体，num_classes个通道分别代表属于该类的概率。

先验框详解与解码

先看先验框的解码代码：

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103

class DecodeBox():
    def __init__(self, anchors, num_classes, input_shape, anchors_mask = [[6,7,8], [3,4,5], [0,1,2]]):
        super(DecodeBox, self).__init__()
        self.anchors        = anchors
        self.num_classes    = num_classes
        self.bbox_attrs     = 5 + num_classes
        self.input_shape    = input_shape
        #-----------------------------------------------------------#
        #   13x13的特征层对应的anchor是[81,82],[135,169],[344,319]
        #   26x26的特征层对应的anchor是[10,14],[23,27],[37,58]
        #-----------------------------------------------------------#
        self.anchors_mask   = anchors_mask

    def decode_box(self, inputs):
        outputs = []
        for i, input in enumerate(inputs):
            #-----------------------------------------------#
            #   输入的input一共有三个，他们的shape分别是
            #   batch_size, 255, 13, 13
            #   batch_size, 255, 26, 26
            #-----------------------------------------------#
            batch_size      = input.size(0)
            input_height    = input.size(2)
            input_width     = input.size(3)

            #-----------------------------------------------#
            #   输入为416x416时
            #   stride_h = stride_w = 32、16、8
            #-----------------------------------------------#
            stride_h = self.input_shape[0] / input_height
            stride_w = self.input_shape[1] / input_width
            #-------------------------------------------------#
            #   此时获得的scaled_anchors大小是相对于特征层的
            #-------------------------------------------------#
            scaled_anchors = [(anchor_width / stride_w, anchor_height / stride_h) for anchor_width, anchor_height in self.anchors[self.anchors_mask[i]]]

            #-----------------------------------------------#
            #   输入的input一共有三个，他们的shape分别是
            #   batch_size, 3, 13, 13, 85
            #   batch_size, 3, 26, 26, 85
            #-----------------------------------------------#
            prediction = input.view(batch_size, len(self.anchors_mask[i]),
                                    self.bbox_attrs, input_height, input_width).permute(0, 1, 3, 4, 2).contiguous()

            #-----------------------------------------------#
            #   先验框的中心位置的调整参数
            #-----------------------------------------------#
            x = torch.sigmoid(prediction[..., 0])  
            y = torch.sigmoid(prediction[..., 1])
            #-----------------------------------------------#
            #   先验框的宽高调整参数
            #-----------------------------------------------#
            w = prediction[..., 2]
            h = prediction[..., 3]
            #-----------------------------------------------#
            #   获得置信度，是否有物体
            #-----------------------------------------------#
            conf        = torch.sigmoid(prediction[..., 4])
            #-----------------------------------------------#
            #   种类置信度
            #-----------------------------------------------#
            pred_cls    = torch.sigmoid(prediction[..., 5:])

            FloatTensor = torch.cuda.FloatTensor if x.is_cuda else torch.FloatTensor
            LongTensor  = torch.cuda.LongTensor if x.is_cuda else torch.LongTensor

            #----------------------------------------------------------#
            #   生成网格，先验框中心，网格左上角 
            #   batch_size,3,13,13
            #----------------------------------------------------------#
            grid_x = torch.linspace(0, input_width - 1, input_width).repeat(input_height, 1).repeat(
                batch_size * len(self.anchors_mask[i]), 1, 1).view(x.shape).type(FloatTensor)
            grid_y = torch.linspace(0, input_height - 1, input_height).repeat(input_width, 1).t().repeat(
                batch_size * len(self.anchors_mask[i]), 1, 1).view(y.shape).type(FloatTensor)

            #----------------------------------------------------------#
            #   按照网格格式生成先验框的宽高
            #   batch_size,3,13,13
            #----------------------------------------------------------#
            anchor_w = FloatTensor(scaled_anchors).index_select(1, LongTensor([0]))
            anchor_h = FloatTensor(scaled_anchors).index_select(1, LongTensor([1]))
            anchor_w = anchor_w.repeat(batch_size, 1).repeat(1, 1, input_height * input_width).view(w.shape)
            anchor_h = anchor_h.repeat(batch_size, 1).repeat(1, 1, input_height * input_width).view(h.shape)

            #----------------------------------------------------------#
            #   利用预测结果对先验框进行调整
            #   首先调整先验框的中心，从先验框中心向右下角偏移
            #   再调整先验框的宽高。
            #----------------------------------------------------------#
            pred_boxes          = FloatTensor(prediction[..., :4].shape)
            pred_boxes[..., 0]  = x.data + grid_x
            pred_boxes[..., 1]  = y.data + grid_y
            pred_boxes[..., 2]  = torch.exp(w.data) * anchor_w
            pred_boxes[..., 3]  = torch.exp(h.data) * anchor_h

            #----------------------------------------------------------#
            #   将输出结果归一化成小数的形式
            #----------------------------------------------------------#
            _scale = torch.Tensor([input_width, input_height, input_width, input_height]).type(FloatTensor)
            output = torch.cat((pred_boxes.view(batch_size, -1, 4) / _scale,
                                conf.view(batch_size, -1, 1), pred_cls.view(batch_size, -1, self.num_classes)), -1)
            outputs.append(output.data)
        return outputs

下面展示了一个具体图片的先验框调整过程：

可以看到原本的三个先验框的中心点是相同的，调整之后，先验框的中心点发生了偏移。

YOLOv4的预测过程

计算输入图片的宽高 ——> 将图片转化为RGB图片 ——> 给图片增加灰条，实现不失真的resize ——> 归一化转置后，添加上Batch维度 ——> 将图片输入网络进行预测（需要转为tensor）——> 对输出特征层进行解码 ——> 对预测框进行堆叠，进行非极大抑制

其中非极大抑制过程：取出每一种类的粉最大的框，把它和其他的框进行一个交并比的计算，如果该值大于设置的阈值，则保留这个框。

VOC检测数据集的格式

该格式的主体目录为：

1
2
3
4
5

- 数据集名称
-|- VOC2007
-|-|- ImageSets（文件夹里面放训练集，验证集，测试集，以txt的形式呈现）
-|-|- JPEGImages（文件夹里面放原图）
-|-|- Annotations（文件夹里面放标签的信息，以xml文件形式存在）

其中Annotations中对应JPEGImages里面每张图片对应一个xml文件，放一个xml文件的格式示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

<annotation>
    <folder>VOC2007</folder>
    <filename>ed27edc6-cec1-11ed-96cf-58961d2b4192.jpg</filename>
    <size>
        <width>1000</width>
        <height>750</height>
        <depth>3</depth>
    </size>
    <object>
        <name>class1</name>
        <bndbox>
            <xmin>899</xmin>
            <ymin>29</ymin>
            <xmax>923</xmax>
            <ymax>286</ymax>
        </bndbox>
    </object>
    <object>
        <name>class2</name>
        <bndbox>
            <xmin>814</xmin>
            <ymin>69</ymin>
            <xmax>840</xmax>
            <ymax>319</ymax>
        </bndbox>
    </object>
    <object>
        <name>class3</name>
        <bndbox>
            <xmin>745</xmin>
            <ymin>60</ymin>
            <xmax>761</xmax>
            <ymax>195</ymax>
        </bndbox>
    </object>
    <object>
        <name>class4</name>
        <bndbox>
            <xmin>741</xmin>
            <ymin>307</ymin>
            <xmax>759</xmax>
            <ymax>520</ymax>
        </bndbox>
    </object>
    <object>
        <name>class5</name>
        <bndbox>
            <xmin>693</xmin>
            <ymin>61</ymin>
            <xmax>710</xmax>
            <ymax>211</ymax>
        </bndbox>
    </object>
    <object>
        <name>class6</name>
        <bndbox>
            <xmin>511</xmin>
            <ymin>51</ymin>
            <xmax>613</xmax>
            <ymax>579</ymax>
        </bndbox>
    </object>
    <object>
        <name>class7</name>
        <bndbox>
            <xmin>93</xmin>
            <ymin>304</ymin>
            <xmax>114</xmax>
            <ymax>544</ymax>
        </bndbox>
    </object>
</annotation>

其中我们需要的信息只有