深度学习——稠密连接网络（DenseNet）原理讲解+代码（torch） ...

一、开辟配景

DenseNet（稠密连接网络）是由Cornell大学的Gao Huang等人于2017年提出的深度学习网络架构。它的设计灵感来自于ResNet（残差网络）以及其前身 Highway Networks 的思想。
论文链接：https：//arxiv.org/pdf/1608.06993.pdf 
代码的github链接：https：//github.com/liuzhuang13/DenseNet 
这是作者发表的一篇CVPR顶会上的一篇论文，代码的所在，大家可以自行下载。
在深度卷积神经网络中，通常存在梯度消失或梯度爆炸等问题，尤其是随着网络层数的增加，这种问题变得尤为严重，上篇讲到的残差网络引入了残差连接（跨层连接）来办理了这些问题，从而允许网络更深地练习，但是，ResNet中的跨层连接是通过相加的方式实现的，这意味着每一层只能直接访问前一层的输出。
DenseNet（麋集卷积网络）的焦点思想（创新之处）是麋集连接，使得每一层都与所有之前的层直接连接，即某层的输入除了包含前一层的输出外还包含前面所有层的输出。
这样的话，有许多的长处：
（1）梯度复用：每一层都可以直接访问之前所有层的特征图，从而促进了特征的重用，有助于提取更丰富和更具有表征本领的特征，这句话更文学点的说法是可以明确成多尺度融合。
（2）梯度传播：麋集连接使得梯度可以更轻松地传播到较早的层，有助于缓解梯度消失和梯度爆炸问题，从而使得更深的网络可以练习，和残差网络一样都具备这个长处。
（3）参数服从：参数量要少一些和残差网络大差不差。

二、模型讨论

整个网络主要是包含了三个焦点布局，分别是DenseLayer（模型中最基础的原子单元，使用卷积完成一次最基础的特征提取）、DenseBlock(整个模型麋集连接的基础单元，整个网络最焦点的部分)和Transition(通常用于两个相邻的Dense块之间，主要的两个作用是减小特征图的巨细和特征图的数量），通过上述的三个焦点的布局的拼接加上其他层来完成整个模型的搭建。

DenseLayer层包含BN + Relu + 1*1Conv + BN + Relu + 3*3Conv。第L个DenseLayer层的第一个1*1Conv的输入通道层数为num_input_features+(L-1)*growth_rate，输出通道层数为bn_size*growth_rate；第二个3*3Conv的输入通道数为bn_size*growth_rate，输出通道数为growth_rate。整个DenseLayer层内特征层宽度稳固，不存在stride=2或者池化的情况。这里有一点特殊之处，DenseLayer层的第一个布局是BN层而不是像其它模型那样是Conv。在BN层前面还存在一个Concatenation操作，负责本DenseBlock模块内前面所有层的输出以及第一层的输出进行拼接操作。
DenseBlock模块实在就是堆叠一定数量的DenseLayer层，在整个DenseBlock模块内不同DenseLayer层之间会发生麋集连接，在DenseBlock模块内特征层宽度稳固，不存在stride=2或者池化的情况。在一个block内部（即特征图巨细都相同），将所有的层都进行连接，即第一层的特征会直接传输给后面的所有的层，后面的层会接受前面所有层的输出特征，一个块中有多个卷积层，每个卷积层的输入来自前面所有层的输出。
Transition模块包含BN + Relu + 1*1Conv + 2*2AvgPool，1*1Conv负责降低通道数，2*2AvgPool负责降低特征层宽度，降低到1/2。Transition模块的作用是连接不同的DenseBlock模块，之以是这样设计原因是，密接连接必须包管特征层的宽度是划一的，原因是连接方式为沿通道维拼接，如果整个模型都采取麋集连接，那势必导致整个模型从输入到输出特征层宽度都稳固，那最后无法完成分类任务，也无法压缩特征。
Dense连接只会在每个Dense block内部进行，不会进行跨block的Dense连接。

团体的这个流程可以看一下下边的model.py这个文件，感觉前边有一些内容也不是梳理的很清楚，后期有时间在进行修改。
三、代码+注释

一、分别数据集

1. import os
2. from shutil import copy, rmtree
3. import random
6. def mk_file(file_path: str):
7.     if os.path.exists(file_path):
8.         # 如果文件夹存在，则先删除原文件夹再重新创建
9.         rmtree(file_path)
10.     os.makedirs(file_path)
13. def main():
14.     # 保证随机可复现
15.     random.seed(0)
17.     # 将数据集中10%的数据划分到验证集中
18.     split_rate = 0.1
20.     # 指向解压后的flower_photos文件夹
21.     # getcwd()：该函数不需要传递参数，获得当前所运行脚本的路径
22.     cwd = os.getcwd()
23.     # join()：用于拼接文件路径，可以传入多个路径
24.     data_root = os.path.join(cwd, "flower_data")
25.     origin_flower_path = os.path.join(data_root, "flower_photos")
26.     # 确定路径存在，否则反馈错误
27.     assert os.path.exists(origin_flower_path), "path '{}' does not exist.".format(origin_flower_path)
28.     # isdir()：判断某一路径是否为目录
29.     # listdir()：返回指定的文件夹包含的文件或文件夹的名字的列表
30.     flower_class = [cla for cla in os.listdir(origin_flower_path)
31.                     if os.path.isdir(os.path.join(origin_flower_path, cla))]
33.     # 创建训练集train文件夹，并由类名在其目录下创建子目录
34.     train_root = os.path.join(data_root, "train")
35.     mk_file(train_root)
36.     for cla in flower_class:
37.         # 建立每个类别对应的文件夹
38.         mk_file(os.path.join(train_root, cla))
40.     # 创建验证集val文件夹，并由类名在其目录下创建子目录
41.     val_root = os.path.join(data_root, "val")
42.     mk_file(val_root)
43.     for cla in flower_class:
44.         # 建立每个类别对应的文件夹
45.         mk_file(os.path.join(val_root, cla))
47.     # 遍历所有类别的图像并按比例分成训练集和验证集
48.     for cla in flower_class:
49.         cla_path = os.path.join(origin_flower_path, cla)
50.         # iamges列表存储了该目录下所有图像的名称
51.         images = os.listdir(cla_path)
52.         num = len(images)
53.         # 随机采样验证集的索引
54.         # 从images列表中随机抽取k个图像名称
55.         # random.sample：用于截取列表的指定长度的随机数，返回列表
56.         # eval_index保存验证集val的图像名称
57.         eval_index = random.sample(images, k=int(num * split_rate))
58.         for index, image in enumerate(images):
59.             if image in eval_index:
60.                 # 将分配至验证集中的文件复制到相应目录
61.                 image_path = os.path.join(cla_path, image)
62.                 new_path = os.path.join(val_root, cla)
63.                 copy(image_path, new_path)
64.             else:
65.                 # 将分配至训练集中的文件复制到相应目录
66.                 image_path = os.path.join(cla_path, image)
67.                 new_path = os.path.join(train_root, cla)
68.                 copy(image_path, new_path)
69.                 # '\r'回车，回到当前行的行首，而不会换到下一行，如果接着输出，本行以前的内容会被逐一覆盖
70.                 # end=""：将print自带的换行用end中指定的str代替
71.             print("\r[{}] processing [{}/{}]".format(cla, index + 1, num), end="")
72.         print()
74.     print("processing done!")
77. if __name__ == '__main__':
78.     main()

复制代码

二、模型文件

1. import torch
2. import torch.nn as nn
3. import torch.nn.functional as F
4. from collections import OrderedDict
7. class _DenseLayer(nn.Sequential):
8.     def __init__(self, num_input_features, growth_rate, bn_size, drop_rate):# 第一个参数是输入的通道数，第二个是增长率是一个重要的超参数，它控制了每个密集块中特征图的维度增加量，
9.         #                第四个参数是Dropout正则化上边的概率
10.         super(_DenseLayer, self).__init__()# 调用父类的构造方法，这句话的意思是在调用nn.Sequential的构造方法
11.         self.add_module('norm1', nn.BatchNorm2d(num_input_features)),  # 批量归一化
12.         self.add_module('relu1', nn.ReLU(inplace=True)),     # ReLU层
13.         self.add_module('conv1', nn.Conv2d(num_input_features, bn_size *
14.                                            growth_rate, kernel_size=1, stride=1, bias=False)),    # 表示其输出为4*k   其中bn_size等于4，growth_rate为k     不改变大小，只改变通道的个数
15.         self.add_module('norm2', nn.BatchNorm2d(bn_size * growth_rate)),  # 批量归一化
16.         self.add_module('relu2', nn.ReLU(inplace=True)),         # 激活函数
17.         self.add_module('conv2', nn.Conv2d(bn_size * growth_rate, growth_rate,
18.                                            kernel_size=3, stride=1, padding=1, bias=False)),    # 输出为growth_rate：表示输出通道数为k  提取特征
19.         self.drop_rate = drop_rate
21.     def forward(self, x):
22.         new_features = super(_DenseLayer, self).forward(x)
23.         if self.drop_rate > 0:
24.             new_features = F.dropout(new_features, p=self.drop_rate, training=self.training)
25.         return torch.cat([x, new_features], 1)  # 通道维度连接
28. class _DenseBlock(nn.Sequential):  # 构建稠密块
29.     def __init__(self, num_layers, num_input_features, bn_size, growth_rate, drop_rate): # 密集块中密集层的数量，第二参数是输入通道数量
30.         super(_DenseBlock, self).__init__()
31.         for i in range(num_layers):
32.             layer = _DenseLayer(num_input_features + i * growth_rate, growth_rate, bn_size, drop_rate)
33.             self.add_module('denselayer%d' % (i + 1), layer)
36. class _Transition(nn.Sequential):
37.     def __init__(self, num_input_features, num_output_features):# 输入通道数 输出通道数
38.         super(_Transition, self).__init__()
39.         self.add_module('norm', nn.BatchNorm2d(num_input_features))
40.         self.add_module('relu', nn.ReLU(inplace=True))
41.         self.add_module('conv', nn.Conv2d(num_input_features, num_output_features,
42.                                           kernel_size=1, stride=1, bias=False))
43.         self.add_module('pool', nn.AvgPool2d(kernel_size=2, stride=2))
46. # DenseNet网络模型基本结构
47. class DenseNet(nn.Module):
48.     def __init__(self, growth_rate=32, block_config=(6, 12, 24, 16),
49.                  num_init_features=64, bn_size=4, drop_rate=0, num_classes=4):
51.         super(DenseNet, self).__init__()
53.         # First convolution
54.         self.features = nn.Sequential(OrderedDict([
55.             ('conv0', nn.Conv2d(3, num_init_features, kernel_size=7, stride=2, padding=3, bias=False)),
56.             ('norm0', nn.BatchNorm2d(num_init_features)),
57.             ('relu0', nn.ReLU(inplace=True)),
58.             ('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
59.         ]))
61.         # Each denseblock
62.         num_features = num_init_features
63.         for i, num_layers in enumerate(block_config):
64.             block = _DenseBlock(num_layers=num_layers, num_input_features=num_features,
65.                                 bn_size=bn_size, growth_rate=growth_rate, drop_rate=drop_rate)
66.             self.features.add_module('denseblock%d' % (i + 1), block)
67.             num_features = num_features + num_layers * growth_rate
68.             if i != len(block_config) - 1:
69.                 trans = _Transition(num_input_features=num_features, num_output_features=num_features // 2)
70.                 self.features.add_module('transition%d' % (i + 1), trans)
71.                 num_features = num_features // 2
73.         # Final batch norm
74.         self.features.add_module('norm5', nn.BatchNorm2d(num_features))
76.         # Linear layer
77.         self.classifier = nn.Linear(num_features, num_classes)
79.         # Official init from torch repo.
80.         for m in self.modules():
81.             if isinstance(m, nn.Conv2d):
82.                 nn.init.kaiming_normal(m.weight.data)
83.             elif isinstance(m, nn.BatchNorm2d):
84.                 m.weight.data.fill_(1)
85.                 m.bias.data.zero_()
86.             elif isinstance(m, nn.Linear):
87.                 m.bias.data.zero_()
89.     def forward(self, x):
90.         features = self.features(x)
91.         out = F.relu(features, inplace=True)
92.         out = F.avg_pool2d(out, kernel_size=7, stride=1).view(features.size(0), -1)
93.         out = self.classifier(out)
94.         return out
97. def densenet121(**kwargs):
98.     model = DenseNet(num_init_features=64, growth_rate=32, block_config=(6, 12, 24, 16), **kwargs)
99.     return model
102. def densenet169(**kwargs):
103.     model = DenseNet(num_init_features=64, growth_rate=32, block_config=(6, 12, 32, 32), **kwargs)
104.     return model
107. def densenet201(**kwargs):
108.     model = DenseNet(num_init_features=64, growth_rate=32, block_config=(6, 12, 48, 32), **kwargs)
109.     return model
112. def densenet161(**kwargs):
113.     model = DenseNet(num_init_features=96, growth_rate=48, block_config=(6, 12, 36, 24), **kwargs)
114.     return model
117. if __name__ == '__main__':
118.     # 'DenseNet', 'densenet121', 'densenet169', 'densenet201', 'densenet161'
119.     # Example
120.     net = DenseNet()
121.     print(net)

复制代码

三、练习文件

1. import os
2. import sys
3. import json
5. import torch
6. import torch.nn as nn
7. import torch.optim as optim
8. from torchvision import transforms, datasets
9. from tqdm import tqdm
10. # 训练resnet34
11. from model import densenet121
14. def main():
15.     # 如果有NVIDA显卡，转到GPU训练，否则用CPU
16.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
17.     print("using {} device.".format(device))
19.     data_transform = {
20.         # 训练
21.         # Compose()：将多个transforms的操作整合在一起
22.         "train": transforms.Compose([
23.             # RandomResizedCrop(224)：将给定图像随机裁剪为不同的大小和宽高比，然后缩放所裁剪得到的图像为给定大小
24.             transforms.RandomResizedCrop(224),
25.             # RandomVerticalFlip()：以0.5的概率竖直翻转给定的PIL图像
26.             transforms.RandomHorizontalFlip(),
27.             # ToTensor()：数据转化为Tensor格式
28.             transforms.ToTensor(),
29.             # Normalize()：将图像的像素值归一化到[-1,1]之间，使模型更容易收敛
30.             transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),
31.         # 验证
32.         "val": transforms.Compose([transforms.Resize(256),
33.                                    transforms.CenterCrop(224),
34.                                    transforms.ToTensor(),
35.                                    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])}
36.     # abspath()：获取文件当前目录的绝对路径
37.     # join()：用于拼接文件路径，可以传入多个路径
38.     # getcwd()：该函数不需要传递参数，获得当前所运行脚本的路径
39.     data_root = os.path.abspath(os.getcwd())
40.     # 得到数据集的路径
41.     image_path = os.path.join(data_root, "data")
42.     # exists()：判断括号里的文件是否存在，可以是文件路径
43.     # 如果image_path不存在，序会抛出AssertionError错误，报错为参数内容“ ”
44.     assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
45.     train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
46.                                          transform=data_transform["train"])
47.     # 训练集长度
48.     train_num = len(train_dataset)
50.     # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
51.     # class_to_idx：获取分类名称对应索引
52.     flower_list = train_dataset.class_to_idx
53.     # dict()：创建一个新的字典
54.     # 循环遍历数组索引并交换val和key的值重新赋值给数组，这样模型预测的直接就是value类别值
55.     cla_dict = dict((val, key) for key, val in flower_list.items())
56.     # 把字典编码成json格式
57.     json_str = json.dumps(cla_dict, indent=4)
58.     # 把字典类别索引写入json文件
59.     with open('class_indices.json', 'w') as json_file:
60.         json_file.write(json_str)
62.     # 一次训练载入16张图像
63.     batch_size = 16
64.     # 确定进程数
65.     # min()：返回给定参数的最小值，参数可以为序列
66.     # cpu_count()：返回一个整数值，表示系统中的CPU数量，如果不确定CPU的数量，则不返回任何内容
67.     nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])
68.     print('Using {} dataloader workers every process'.format(nw))
69.     # DataLoader：将读取的数据按照batch size大小封装给训练集
70.     # dataset (Dataset)：输入的数据集
71.     # batch_size (int, optional)：每个batch加载多少个样本，默认: 1
72.     # shuffle (bool, optional)：设置为True时会在每个epoch重新打乱数据，默认: False
73.     # num_workers(int, optional): 决定了有几个进程来处理，默认为0意味着所有的数据都会被load进主进程
74.     train_loader = torch.utils.data.DataLoader(train_dataset,
75.                                                batch_size=batch_size, shuffle=True,
76.                                                num_workers=nw)
77.     # 加载测试数据集
78.     validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
79.                                             transform=data_transform["val"])
80.     # 测试集长度
81.     val_num = len(validate_dataset)
82.     validate_loader = torch.utils.data.DataLoader(validate_dataset,
83.                                                   batch_size=batch_size, shuffle=False,
84.                                                   num_workers=nw)
86.     print("using {} images for training, {} images for validation.".format(train_num,
87.                                                                            val_num))
89.     # 模型实例化
90.     net = densenet121()
91.     net.to(device)
92.     # 加载预训练模型权重
93.     # model_weight_path = "./resnet34-pre.pth"
94.     # exists()：判断括号里的文件是否存在，可以是文件路径
95.     # assert os.path.exists(model_weight_path), "file {} does not exist.".format(model_weight_path)
96.     # net.load_state_dict(torch.load(model_weight_path, map_location='cpu'))
97.     # 输入通道数
98.     # in_channel = net.fc.in_features
99.     # 全连接层
100.     # net.fc = nn.Linear(in_channel, 5)
102.     # 定义损失函数（交叉熵损失）
103.     loss_function = nn.CrossEntropyLoss()
105.     # 抽取模型参数
106.     params = [p for p in net.parameters() if p.requires_grad]
107.     # 定义adam优化器
108.     # params(iterable)：要训练的参数，一般传入的是model.parameters()
109.     # lr(float)：learning_rate学习率，也就是步长，默认：1e-3
110.     optimizer = optim.Adam(params, lr=0.0001)
112.     # 迭代次数（训练次数）
113.     epochs = 30
114.     # 用于判断最佳模型
115.     best_acc = 0.0
116.     # 最佳模型保存地址
117.     save_path = './DenseNet34.pth'
118.     train_steps = len(train_loader)
119.     for epoch in range(epochs):
120.         # 训练
121.         net.train()
122.         running_loss = 0.0
123.         # tqdm：进度条显示
124.         train_bar = tqdm(train_loader, file=sys.stdout)
125.         # train_bar: 传入数据（数据包括：训练数据和标签）
126.         # enumerate()：将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中
127.         # enumerate返回值有两个：一个是序号，一个是数据（包含训练数据和标签）
128.         # x：训练数据（inputs）(tensor类型的），y：标签（labels）(tensor类型）
129.         for step, data in enumerate(train_bar):
130.             # 前向传播
131.             images, labels = data
132.             # 计算训练值
133.             logits = net(images.to(device))
134.             # 计算损失
135.             loss = loss_function(logits, labels.to(device))
136.             # 反向传播
137.             # 清空过往梯度
138.             optimizer.zero_grad()
139.             # 反向传播，计算当前梯度
140.             loss.backward()
141.             optimizer.step()
143.             # item()：得到元素张量的元素值
144.             running_loss += loss.item()
146.             # 进度条的前缀
147.             # .3f：表示浮点数的精度为3（小数位保留3位）
148.             train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
149.                                                                      epochs,
150.                                                                      loss)
152.         # 测试
153.         # eval()：如果模型中有Batch Normalization和Dropout，则不启用，以防改变权值
154.         net.eval()
155.         acc = 0.0
156.         # 清空历史梯度，与训练最大的区别是测试过程中取消了反向传播
157.         with torch.no_grad():
158.             val_bar = tqdm(validate_loader, file=sys.stdout)
159.             for val_data in val_bar:
160.                 val_images, val_labels = val_data
161.                 outputs = net(val_images.to(device))
162.                 # torch.max(input, dim)函数
163.                 # input是具体的tensor，dim是max函数索引的维度，0是每列的最大值，1是每行的最大值输出
164.                 # 函数会返回两个tensor，第一个tensor是每行的最大值；第二个tensor是每行最大值的索引
165.                 predict_y = torch.max(outputs, dim=1)[1]
166.                 # 对两个张量Tensor进行逐元素的比较，若相同位置的两个元素相同，则返回True；若不同，返回False
167.                 # .sum()对输入的tensor数据的某一维度求和
168.                 acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
170.                 val_bar.desc = "valid epoch[{}/{}]".format(epoch + 1,
171.                                                            epochs)
173.         val_accurate = acc / val_num
174.         print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
175.               (epoch + 1, running_loss / train_steps, val_accurate))
177.         # 保存最好的模型权重
178.         if val_accurate > best_acc:
179.             best_acc = val_accurate
180.             # torch.save(state, dir)保存模型等相关参数，dir表示保存文件的路径+保存文件名
181.             # model.state_dict()：返回的是一个OrderedDict，存储了网络结构的名字和对应的参数
182.             torch.save(net.state_dict(), save_path)
184.     print('Finished Training')
187. if __name__ == '__main__':
188.     main()

复制代码

以上就是代码文件了，数据集的格式如下图所示

其中，crack、rust、spalling、stoma、这四个文件夹名是种别，这种还不需要标注了，到了目标检测的环节才需要标注，本次的博客也算是写完了，以后会不定期更新遇到的问题的。
四、参考文献

DenseNet网络布局的讲解与代码实现_transition层-CSDN博客
densenet的网络布局和实当代码总结(torch)_densenet布局-CSDN博客













链接：https://blog.csdn.net/BIT_Legend/article/details/124238533













免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。