深度学习之PyTorch物体检测实战，读书笔记（二）

一.主流数据集

1.ImageNet数据集：ImageNet数据集对应的有一个享誉全球的ImageNet国际计算机视觉挑战赛（ILSVRC），该竞赛包含了图像分类、物体检测与定位、视频物体识别等多个领域。

2.PASCAL VOC数据集：PASCAL VOC为图像分类与物体检测提供了一整套标准的数据集，常用的数据集主要有VOC 2007与VOC 2012两个版本。另一个贡献在于提供了一套标准的数据集格式。

对于物体检测，有3个重要的文件夹，具体如下：

·JPEGImages：包含所有训练与测试的图片。

·ons：存放XMLAnnotati格式的标签数据，每一个XML文件都对应于JPEGImages文件夹下的一张图片。·ImageSets：对于物体检测只需要Main子文件夹，并在Main文件夹中建立Trainval.txt、train.txt、val.txt及test.txt，在各文件中记录相应的图片名即可。

3.COCO（Common Objects in Context）数据集：针对物体检测、分割、图像语义理解和人体关节点等

二.用pytorch实现VGG网络

在VGGNet中，使用的卷积核基本都是3×3，这样做的好处是

首先从感受野来看，两个3×3的卷积核与一个5×5的卷积核是一样的；

然后，同等感受野时，3×3卷积核的参数量更少；

最重要的是，两个3×3卷积核的非线性能力要比5×5卷积核强，因为其拥有两个激活函数，可大大提高卷积网络的学习能力。

代码实现：

from torch import nn


class VGG(nn.Module):
    def __init__(self, num_classes=1000):
        super(VGG, self).__init__()
        layers = []
        in_dim = 3
        out_dim = 64
        # 循环构建卷积层，一共是13个卷积层
        for i in range(13):
            layers += [nn.Conv2d(in_channels=in_dim, out_channels=out_dim, kernel_size=3, stride=1, padding=1),
                       nn.ReLU(inplace=True)]  # inplace = False 时,不会修改输入对象的值,而是返回一个新创建的对象
            # ,所以打印出对象存储地址不同,类似于C语言的值传递,
            # inplace = True ,会改变输入数据的值,节省反复申请与释放内存的空间与时间,只是将原来的地址传递,效率更好
            # 总结就是inplace=true会减少训练时间，提高训练效率
            in_dim = out_dim
            # 在2，4，7，10，13后边加池化层
            if i == 1 or i == 3 or i == 6 or i == 9 or i == 12:
                layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
                if i != 9:
                    out_dim *= 2

        self.features = nn.Sequential(*layers)
        self.classifier = nn.Sequential(
            nn.Linear(512 * 7 * 7, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)  # 这里是将特征图的维度从[1,512,7,7]变到[1,512*7*7]
        x = self.classifier(x)
        return x

.三.pytorch实现纵横交错：Inception

nception v1的参数量是AlexNet的12分之一, VGGNet的六分之一，适合处理大规模数据，尤其是对于计算资源有限的平台.

网络复现：

import torch
from torch import nn
import torch.nn.functional as F


# 首先定义一个包括relu和卷积的的基础卷积类
class BasicConv2d(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, padding=0):
        super(BasicConv2d, self).__init__()
        self.conv = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size,
                              padding=padding)

        def forward(self, x):
            x = self.conv(x)
            return F.relu(input=x, inplace=True)


# 定义Inceptionv1的类，初始化各个子通道的个数
class Inceptionv1(nn.Module):
    def __init__(self, in_dim, hid_1_1, hid_2_1, hid_2_3, hid_3_1, out_3_5, out_4_1):
        super(Inceptionv1, self).__init__()
        # 分别定义四个子模块
        self.branch1X1 = BasicConv2d(in_channels=in_dim, out_channels=hid_1_1, kernel_size=1)
        self.branc3X3 = nn.Sequential(
            BasicConv2d(in_channels=in_dim, out_channels=hid_2_1, kernel_size=1),
            BasicConv2d(in_channels=hid_2_1, out_channels=hid_2_3, kernel_size=3, padding=1)
        )
        self.branch5X5 = nn.Sequential(
            BasicConv2d(in_channels=in_dim, out_channels=hid_3_1, kernel_size=1),
            BasicConv2d(in_channels=hid_3_1, out_channels=out_3_5, kernel_size=5, padding=2)
        )
        self.branch_pool = nn.Sequential(
            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
            BasicConv2d(in_channels=in_dim, out_channels=out_4_1)
        )

    def forward(self, x):
        b1 = self.branch1X1(x)
        b2 = self.branc3X3(x)
        b3 = self.branch5X5(x)
        b4 = self.branch_pool(x)
        # 对这四个模块进行拼接
        output = torch.cat((b1, b2, b3, b4), dim=1)
        return output

.而对于cat函数中dim的解释

当dim=0时，按列排列，如下：

编辑

添加图片注释，不超过 140 字（可选）

当dim=1时，按行排列，如下：

编辑

添加图片注释，不超过 140 字（可选）

编辑切换为居中

添加图片注释，不超过 140 字（可选）

Inception v2还将模块中的卷积核变得更宽而不是更深，形成第三个模块，以解决表征能力瓶颈的问题。Inception v2网络正是由上述的三种不同类型的模块组成的，其计算也更加高效。

四.

1.在python中元组用“+”拼接，也支持用*来复制元组，例如：

    tup_3=tup_1+tup_2
    tup_4=tup_2*3
    print(tup_3)
    print(tup_4)

2.定义一个名为my_func的函数，my_func函数接收三个int类型参数year、month和day分别作为给定日期的年份、月份和日期，导入datetime模块的datetime类，让my_func函数返回对应日期的正午时间点。

from datetime import datetime

def my_func(year,month,day):
    return datetime(year, month, day,12)

3.输入一个正整数n，输出元素值不超过n的三元组中，能组成三角形的三条边边长的元组个数。

# write your code here
count=0
for i in range(1,n+1):
    for j in range(1,n+1):
        for k in range(1,n+1):
            if i+j>k and i+k>j and j+k>i:
                count+=1
print(count)

4.输入一个列表arr，返回元素值是元素下标的倍数的元素个数。列表的下标从0开始。

# write your code here
# 如果第一个元素是0，那么直接count+1
# 其次依次遍历剩下的所有元素，
# 如果该元素等于0，直接count+1；
# 否则如果该元素是其 下标的倍数，就令count+1


count=0
if arr[0]==0:
    count+=1
for i in range (1,len(arr)):
    if arr[i]==0:
        count+=1
    elif arr[i]%i==0:
        count+=1

print(count)

.5.只需要满足两个条件：1，位数为2；2.是7的倍数

for i in range(1,n+1):
    if i%10==2 and i%7==0:
        count+=1

print(count)

6.获取两个整数a，b，并计算a，b的和、差、积、商。（商只保留整数部分）

a=int(input())
b=int(input())
print(a+b)
print(a-b)
print(a*b)
print(a//b)#b对于a的商，并且是只保留整数部分