网站规划的流程,杭州平面设计公司排行,站酷网如何接单,中国服装网官网#x1f368; 本文为#x1f517;365天深度学习训练营中的学习记录博客#x1f356; 原作者#xff1a;K同学啊|接辅导、项目定制 1 前言 在计算机视觉领域#xff0c;卷积神经网络#xff08;CNN#xff09;已经成为最主流的方法#xff0c;比如GoogleNet#xff0c;… 本文为365天深度学习训练营中的学习记录博客 原作者K同学啊|接辅导、项目定制 1 前言 在计算机视觉领域卷积神经网络CNN已经成为最主流的方法比如GoogleNetVGG-16Incepetion等模型。CNN史上的一个里程碑事件是ResNet模型的出现ResNet可以训练出更深的CNN模型从而实现更高的准确率。ResNet模型的核心是通过建立前面层与后面层之间的“短路连接”shortcut, skip connection进而训练出更深的CNN网络。 DenseNet模型的基本思路与ResNet一致但是它建立的是前面所有层与后面层的紧密连接dense connection它的名称也是由此而来。DenseNet的另一大特色是通过特征在channel上的的连接来实现特征重用feature reuse。这些特点让DenseNet在参数和计算成本更少的情形下实现比ResNet更优的性能DenseNet也因此斩获CVPR2017的最佳论文奖。 图1 Dense模块5-layer,growth rate of k4 其中DenseNet论文原文地址为https://arxiv.org/pdf/1608.06993v5.pdf 2 设计理念 相比ResNetDenseNet提出了一个更激进的密集连接机制即互相连接所有的层具体来说就是每个层都会接受前面所有层作为额外的输入。 图3为ResNet网络的残差连接机制作为对比图4为DenseNet的密集连接机制。可以看到ResNet是每个层与前面的某层一般是2~4层短路连接在一起连接方式是通过元素相加。而在DenseNet中每个层都会与前面所有层在channel维度上链接concat在一起即元素叠加并作为下一层的输入。 对于一个L层的网络DenseNet共包含个连接相比ResNet这是一种密集连接。而且DenseNet是直接concat来自不同层的特征图这可以实现特征重用提升效率这一特点是DenseNet与ResNet最主要的区别。
2.1 标准神经网络 图2 标准的神经网络传播过程 图2是一个标准的神经网络传播过程示意图输入和输出的公式是其中 是一个组合函数通常包括BN、ReLu、Pooling、Conv等操作是第l层的输入的特征图来自于l-1层的输出,是第l层的输出的特征图。
2.2 ResNet 图3 ResNet网络的短路连接机制代表元素级相加操作 图3是ResNet的网络连接机制由图可知是跨层相加输入和输出的公式是 2.3 DenseNet 图4 DenseNet网络的密集连接机制其中C代表层级的concat操作 图4为DenseNet的连接机制采用跨通道的concat的形式连接会连接前面所有层作为输入输入和输出的公式是。这里要注意所有层的输入都来源于前面所有层在channel维度的concat以下动图形象表示这一操作。 图5 DenseNet前向过程 3 网络结构 网络的具体实现细节如图6所示。 图6 DenseNet的网络结构 CNN网络一般要经过Pooling或者stride1的Conv来降低特征图的大小而DenseNet的密集连接方式需要特征图大小保持一致。为了解决这个问题DenseNet网络中使用DenseBlockTransition的结构其中DenseBlock是包含很多层的模块每个层的特征图大小相同层与层之间采用密集连接方式。而Transition层是连接两个相邻的DenseBlock并且通过Pooling使特征图大小降低。图7给出了DenseNet的网络结构它共包含4个DenseBlock各个DenseBlock之间通过Transition层连接在一起。 图7 使用DenseBlockTransition的DenseNet网络 在DenseBlock中各个层的特征图大小一致可以在channel维度上连接。DenseBlock中的非线性组合函数的是BNReLU3*3Conv的结构如图8所示。另外与ResNet不同所有DenseBlock中各个层卷积之后均输出k个特征图即得到的特征图的channel数为或者说采用k个卷积核。在DenseNet称为growth rate这是一个超参数。一般情况下使用较小的比如12就可以得到较佳的性能。假定输入层的特征图的channel数为那么层输入的channel数为因此随着层数的增加尽管设定的较小DenseBlock的输入会非常多不过这是由于特征重用所造成的每个层仅有个特征是自己独有的。 图8 DenseBlock中的非线性转换结构 由于后面层的输入会非常大DenseBlock内部采用bottleneck层来减少计算量主要是原有的结构中增加1*1Conv如图9所示即BNReLU1*1ConvBNReLU3*3Conv称为DenseNet-B结构。其中1*1Conv得到个特征图它起到的作用是降低特征数量从而提升计算效率。 图9 使用bottleneck层的DenseBlock结构 对于Trasition层它主要是连接两个相邻的DenseBlock并且降低特征图大小。Transition层包括一个1*1的卷积和2*2的AvgPooling结构为BNReLU1*1Conv2*2AvgPooling。另外Transition层可以起到压缩模型的作用。假定Transition层的上接DenseBlock得到特征图channels数为Transition层可以产生个特征通过卷积层其中是压缩系数compression rate。当时特征个数经过Transition层没有变化即无压缩而当压缩系数小于1时这种结构称为DenseNet-C文中使用。对于使用bootleneck层的DenseBlock结构和压缩系数小于1的Transition组合机构称为DenseNet-BC。 对于ImageNet数据集图片输入大小为224*224网络结构采用包含4个DenseBlock的DenseNet-BC其首先是一个stride2的7*7卷积层然后是一个stride2的3*3MaxPooling层后面才进入DenseBlock。ImageNet数据集所采用的网络配置如表1所示 表1 ImageNet数据集上所采用的DenseNet结构 4 效果对比 图10 在CIFA-10数据集上ResNet vs DenseNet 5 使用Pytroch实现DenseNet121 图11 DenseNet121网络结构图 图11为DenseNet121的具体网络结构它与表1中的DenseNet121相对应。左边是整个DenseNet121的网络结构其中粉色为DenseBlock最右侧为其详细结构灰色为Transition中间为其详细结构。
5.1 前期工作
5.1.1 开发环境 电脑系统ubuntu16.04 编译器Jupter Lab 语言环境Python 3.7 深度学习环境pytorch 5.1.2 设置GPU 如果设备上支持GPU就使用GPU否则注释掉这部分代码。
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets
import os, PIL, pathlib, warningswarnings.filterwarnings(ignore)
device torch.device(cuda if torch.cuda.is_available() else cpu)print(device)
5.1.3 导入数据
import os,PIL,random,pathlibdata_dir_str ../data/bird_photos
data_dir pathlib.Path(data_dir_str)
print(data_dir:, data_dir, \n)data_paths list(data_dir.glob(*))
classNames [str(path).split(/)[-1] for path in data_paths]
print(classNames:, classNames , \n)train_transforms transforms.Compose([transforms.Resize([224, 224]), # resize输入图片transforms.ToTensor(), # 将PIL Image或numpy.ndarray转换成tensortransforms.Normalize(mean[0.485, 0.456, 0.406],std[0.229, 0.224, 0.225]) # 从数据集中随机抽样计算得到
])total_data datasets.ImageFolder(data_dir_str, transformtrain_transforms)
print(total_data)
print(total_data.class_to_idx) 结果输出如图 5.1.4 划分数据集
train_size int(0.8 * len(total_data))
test_size len(total_data) - train_size
train_dataset, test_dataset torch.utils.data.random_split(total_data, [train_size, test_size])
print(train_dataset, test_dataset)batch_size 4
train_dl torch.utils.data.DataLoader(train_dataset, batch_sizebatch_size,shuffleTrue,num_workers1,pin_memoryFalse)
test_dl torch.utils.data.DataLoader(test_dataset, batch_sizebatch_size,shuffleTrue,num_workers1,pin_memoryFalse)for X, y in test_dl:print(Shape of X [N, C, H, W]:, X.shape)print(Shape of y:, y.shape, y.dtype)break 结果输出如图 5.2 搭建DenseNet121
5.2.1 DenseBlock中的Bottleneck
import torch
from torch import nnclass _DenseLayer(nn.Sequential):DenseBlock的基本单元使用bottleneckdef __init__(self, num_input_features, growth_rate, bn_size, drop_rate):super(_DenseLayer, self).__init__()self.add_module(norm1, nn.BatchNorm2d(num_input_features))self.add_module(relu1, nn.ReLU(inplaceTrue))self.add_module(conv1, nn.Conv2d(num_input_features, bn_size*growth_rate,kernel_size1, stride1, biasFalse))self.add_module(norm2, nn.BatchNorm2d(bn_size*growth_rate))self.add_module(relu2, nn.ReLU(inplaceTrue))self.add_module(conv2, nn.Conv2d(bn_size*growth_rate, growth_rate,kernel_size3, stride1, padding1, biasFalse))self.drop_rate drop_ratedef forward(self, x):new_features super(_DenseLayer, self).forward(x)if self.drop_rate 0:new_features F.dropout(new_features, pself.drop_rate, trainingself.training)return torch.cat([x, new_features], 1)
5.2.2 DenseBlock层
class _DenseBlock(nn.Sequential):def __init__(self, num_layer, num_input_features, bn_size, growth_rate, drop_rate):super(_DenseBlock, self).__init__()for i in range(num_layer):layer _DenseLayer(num_input_featuresi*growth_rate, growth_rate, bn_size, drop_rate)self.add_module(denselayer%d % (i1,), layer)
5.2.3 Transition层
class _Transition(nn.Sequential):def __init__(self, num_input_features, num_output_features):super(_Transition, self).__init__()self.add_module(norm, nn.BatchNorm2d(num_input_features))self.add_module(relu, nn.ReLU(inplaceTrue))self.add_module(conv, nn.Conv2d(num_input_features, num_output_features,kernel_size1, stride1, biasFalse))self.add_module(pool, nn.AvgPool2d(2, stride2))
5.2.4 DenseNet-BC
import torch.nn.functional as F#from collections import OrderedDict
import collectionstry:from collections import OrderedDict
except ImportError:OrderedDict dictclass DenseNet(nn.Module):DenseNet-BC modeldef __init__(self, growth_rate32, block_config(6, 12, 24, 16), num_init_features64,bn_size4, compression_rate0.5, drop_rate0, num_classes4):growth_rate:(int) number of filters used in DenseLayer, k in the paperblock_config:(list of 4 ints) number of layers in each DenseBlocknum_init_features:(int) number of filters in the first Conv2dbn_size:(int) the factor using in the bottleneck layercompression_rate:(float) the compression rate used in Trasition Layerdrop_rate:(float) the drop rate after each DenseLayernum_classes:(int) number of classes for classificationsuper(DenseNet, self).__init__()# first Conv2dself.features nn.Sequential(OrderedDict([(conv0, nn.Conv2d(3, num_init_features, kernel_size7, stride2, padding3, biasFalse)),(norm0, nn.BatchNorm2d(num_init_features)),(relu0, nn.ReLU(inplaceTrue)),(pool0, nn.MaxPool2d(3, stride2, padding1))]))# DenseBlocknum_features num_init_featuresfor i,num_layers in enumerate(block_config):block _DenseBlock(num_layers, num_features, bn_size, growth_rate, drop_rate)self.features.add_module(denseblock%d % (i 1), block)num_features num_layers*growth_rateif i ! len(block_config) - 1:transition _Transition(num_features, int(num_features*compression_rate))self.features.add_module(transition%d % (i1), transition)num_features int(num_features * compression_rate)# final bnreluself.features.add_module(norm5, nn.BatchNorm2d(num_features))self.features.add_module(relu5, nn.ReLU(inplaceTrue))# classification layerself.classifier nn.Linear(num_features, num_classes)# params initializationfor m in self.modules():if isinstance(m, nn.Conv2d):nn.init.kaiming_normal_(m.weight)elif isinstance(m, nn.BatchNorm2d):nn.init.constant_(m.bias, 0)nn.init.constant_(m.weight, 1)elif isinstance(m, nn.Linear):nn.init.constant_(m.bias, 0)def forward(self, x):features self.features(x)out F.avg_pool2d(features, 7, stride1).view(features.size(0), -1)out self.classifier(out)return out
5.2.5 DenseNet121
import redef densenet121(pretrainedFalse, **kwargs):# DenseNet121model DenseNet(num_init_features64, growth_rate32, block_config(6,12,24,16), ** kwargs)if pretrained:# . are no longer in module names, but pervious _DenseLayer# has keys norm.1,relu.1,conv.1,norm.2,relu.2,conv.2.# They are also in the checkpoints in model_urls.This pattern is used# to find find such keys.pattern re.compile(r^(.*denselayer\d\.(?:norm|relu\conv))\.((?:[12])\.(?:weight|bias|running_mean|running_var))$)state_dir model_zoo.load_url(model_urls[densenet121])for key in list(state_dict.key()):res pattern.match(key)if res:new_key res.group(1) res.group(2)state_dict[new_key] state_dict[key]del state_dict[key]model.load_state_dict(state_dict)return modelmodel densenet121().to(device)
model 结果输出如下由于结果太长只展示最前面和最后面 中间省略 5.2.6 查看模型详情
# 统计模型参数量以及其他指标
import torchsummary as summary
summary.summary(model, (3, 224, 224)) 结果输出如下由于结果太长只展示最前面和最后面 中间省略 5.3 训练模型
5.3.1 编写训练函数
# 训练循环
def train(dataloader, model, loss_fn, optimizer):size len(dataloader.dataset) # 训练集的大小num_batches len(dataloader) # 批次数目, (size/batch_size向上取整)train_loss, train_acc 0, 0 # 初始化训练损失和正确率for X, y in dataloader: # 获取图片及其标签X, y X.to(device), y.to(device)# 计算预测误差pred model(X) # 网络输出loss loss_fn(pred, y) # 计算网络输出pred和真实值y之间的差距y为真实值计算二者差值即为损失# 反向传播optimizer.zero_grad() # grad属性归零loss.backward() # 反向传播optimizer.step() # 每一步自动更新# 记录acc与losstrain_acc (pred.argmax(1) y).type(torch.float).sum().item()train_loss loss.item()train_acc / sizetrain_loss / num_batchesreturn train_acc, train_loss
5.3.2 编写测试函数
def test(dataloader, model, loss_fn):size len(dataloader.dataset) # 训练集的大小num_batches len(dataloader) # 批次数目, (size/batch_size向上取整)test_loss, test_acc 0, 0 # 初始化测试损失和正确率# 当不进行训练时停止梯度更新节省计算内存消耗# with torch.no_grad():for imgs, target in dataloader: # 获取图片及其标签with torch.no_grad():imgs, target imgs.to(device), target.to(device)# 计算误差tartget_pred model(imgs) # 网络输出loss loss_fn(tartget_pred, target) # 计算网络输出和真实值之间的差距targets为真实值计算二者差值即为损失# 记录acc与losstest_loss loss.item()test_acc (tartget_pred.argmax(1) target).type(torch.float).sum().item()test_acc / sizetest_loss / num_batchesreturn test_acc, test_loss
5.3.3 正式训练
import copyoptimizer torch.optim.Adam(model.parameters(), lr 1e-4)
loss_fn nn.CrossEntropyLoss() #创建损失函数epochs 40train_loss []
train_acc []
test_loss []
test_acc []best_acc 0 #设置一个最佳准确率作为最佳模型的判别指标if hasattr(torch.cuda, empty_cache):torch.cuda.empty_cache()for epoch in range(epochs):model.train()epoch_train_acc, epoch_train_loss train(train_dl, model, loss_fn, optimizer)#scheduler.step() #更新学习率调用官方动态学习率接口时使用model.eval()epoch_test_acc, epoch_test_loss test(test_dl, model, loss_fn)#保存最佳模型到best_modelif epoch_test_acc best_acc:best_acc epoch_test_accbest_model copy.deepcopy(model)train_acc.append(epoch_train_acc)train_loss.append(epoch_train_loss)test_acc.append(epoch_test_acc)test_loss.append(epoch_test_loss)#获取当前的学习率lr optimizer.state_dict()[param_groups][0][lr]template (Epoch: {:2d}. Train_acc: {:.1f}%, Train_loss: {:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr: {:.2E})print(template.format(epoch1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss, lr))PATH ./J3_best_model.pth
torch.save(model.state_dict(), PATH)print(Done) 结果输出如下 5.4 结果可视化
import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings(ignore) #忽略警告信息
plt.rcParams[font.sans-serif] [SimHei] # 用来正常显示中文标签
plt.rcParams[axes.unicode_minus] False # 用来正常显示负号
plt.rcParams[figure.dpi] 100 #分辨率epochs_range range(epochs)plt.figure(figsize(12, 3))
plt.subplot(1, 2, 1)plt.plot(epochs_range, train_acc, labelTraining Accuracy)
plt.plot(epochs_range, test_acc, labelTest Accuracy)
plt.legend(loclower right)
plt.title(Training and Validation Accuracy)plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, labelTraining Loss)
plt.plot(epochs_range, test_loss, labelTest Loss)
plt.legend(locupper right)
plt.title(Training and Validation Loss)
plt.show() 结果输出如下 6 使用Tensorflow实现DenseNet121
6.1 前期工作
6.1.1 开发环境 电脑系统ubuntu16.04 编译器Jupter Lab 语言环境Python 3.7 深度学习环境tensorflow 6.1.2 设置GPU 如果设备上支持GPU就使用GPU否则注释掉这部分代码。
import tensorflow as tfgpus tf.config.list_physical_devices(GPU)if gpus:tf.config.experimental.set_memory_growth(gpus[0], True) # 设置GPU显存用量按需使用tf.config.set_visible_devices([gpus[0]], GPU)
6.1.2 导入数据
import matplotlib.pyplot as plt
# 支持中文
plt.rcParams[font.sans-serif] [SimHei] # 用来正常显示中文标签
plt.rcParams[axes.unicode_minus] False # 用来正常显示负号import os, PIL, pathlib
import numpy as npfrom tensorflow import keras
from tensorflow.keras import layers,modelsdata_dir ../data/bird_photos
data_dir pathlib.Path(data_dir)image_count len(list(data_dir.glob(*/*)))
print(图片总数为, image_count)
6.1.3 加载数据
batch_size 8
img_height 224
img_width 224train_ds tf.keras.preprocessing.image_dataset_from_directory(data_dir,validation_split0.2,subsettraining,seed123,image_size(img_height, img_width),batch_sizebatch_size)val_ds tf.keras.preprocessing.image_dataset_from_directory(data_dir,validation_split0.2,subsetvalidation,seed123,image_size(img_height, img_width),batch_sizebatch_size)class_Names train_ds.class_names
print(class_Names:,class_Names) 输出结果如下 6.1.4 可视化数据
plt.figure(figsize(10, 5)) # 图形的宽为10高为5
plt.suptitle(imshow data)for images,labels in train_ds.take(1):for i in range(8):ax plt.subplot(2, 4, i1)plt.imshow(images[i].numpy().astype(uint8))plt.title(class_Names[labels[i]])plt.axis(off) 输出结果如下 6.1.5 检查数据
for image_batch, lables_batch in train_ds:print(image_batch.shape)print(lables_batch.shape)break 输出结果如下 6.1.6 配置数据集
AUTOTUNE tf.data.AUTOTUNEtrain_ds train_ds.cache().shuffle(1000).prefetch(buffer_sizeAUTOTUNE)
val_ds val_ds.cache().prefetch(buffer_sizeAUTOTUNE)
6.2 搭建DenseNet121
6.2.1 DenseNet121
import tensorflow as tf
import tensorflow.keras.layers as layers
from tensorflow.keras import regularizers
# from tensorflow.keras.models import Modelfrom tensorflow.keras.layers import Input,Activation,BatchNormalization,Flatten
from tensorflow.keras.layers import Dense,Conv2D,MaxPooling2D,ZeroPadding2D,AveragePooling2D
from tensorflow.keras.models import Modeldef regularized_padded_conv2d(*args, **kwargs):带标准化的卷积return layers.Conv2D(*args, **kwargs,paddingsame, kernel_regularizerregularizers.l2(5e-5), bias_regularizerregularizers.l2(5e-5),kernel_initializerglorot_normal)def DenseLayer(x, growth_rate, bn_size, drop_rate, layerName):new_features layers.BatchNormalization(namelayerName_norm1)(x)new_features layers.Activation(relu, namelayerName_relu1)(new_features)new_features regularized_padded_conv2d(filtersbn_size*growth_rate, kernel_size1, strides1, use_biasFalse, namelayerName_conv1)(new_features)new_features layers.BatchNormalization(namelayerName_norm2)(new_features)new_features layers.Activation(relu, namelayerName_relu2)(new_features)new_features regularized_padded_conv2d(filtersgrowth_rate, kernel_size3, strides1, use_biasFalse, namelayerName_conv2)(new_features)if drop_rate 0:new_features layers.Dropout(ratedrop_rate)(new_features)return layers.concatenate([x, new_features], axis-1)def DenseBlock(x, num_layer, bn_size, growth_rate, drop_rate, blockName):for i in range(num_layer):x DenseLayer(x, growth_rategrowth_rate, bn_sizebn_size, drop_ratedrop_rate, layerNameblockName_str(i1))return xdef Transition(x, num_output_features, blockName):x layers.BatchNormalization(nameblockName_norm)(x)x layers.Activation(relu, nameblockName_relu)(x)x regularized_padded_conv2d(filtersnum_output_features, kernel_size1, strides1, use_biasFalse, nameblockName_conv)(x)x layers.AveragePooling2D(pool_size2, strides2, paddingsame, nameblockName_pool)(x)return xdef densenet121(input_shape[224,224,3], growth_rate32, block_config(6, 12, 24, 16), num_init_features64,bn_size4, compression_rate0.5, drop_rate0, num_classes4, classifier_activationsoftmax):img_input Input(shapeinput_shape)# first Conv2dx regularized_padded_conv2d(filtersnum_init_features, kernel_size7, strides2, use_biasFalse, namepre_conv)(img_input)x layers.BatchNormalization(namepre_norm)(x)x layers.Activation(relu, namepre_relu)(x)x layers.MaxPool2D(pool_size3, strides2, paddingsame)(x)# DenseBlocknum_features num_init_featuresfor i,num_layer in enumerate(block_config):x DenseBlock(x, num_layernum_layer, bn_sizebn_size, growth_rategrowth_rate, drop_ratedrop_rate, blockNameDenseBlock_str(i1))num_features num_layer*growth_rateif i ! len(block_config) - 1:num_features int(num_features * compression_rate)x Transition(x, num_output_featuresnum_features, blockNameTransBlock_ str(i1))# final bnrelux layers.BatchNormalization(namenorm5)(x)x layers.Activation(relu, namerelu5)(x)x layers.AveragePooling2D(pool_size7, strides1, namepool5)(x) #GlobalAveragePooling2D# classification layerx Dense(num_classes, activationclassifier_activation, nameclassifier)(x)model Model(img_input, x, namedensenet121)# # 加载预训练模型# model.load_weights(resnet50_weights_tf_dim_ordering_tf_kernels.h5)return model6.2.2 查看模型详情
model densenet121()
model.summary() 结果如图所示由于内容较长只截取前后部分内容 中间部分省略 6.3 训练模型
# 设置优化器
opt tf.keras.optimizers.Adam(learning_rate1e-6)
model.compile(optimizeradam,losssparse_categorical_crossentropy,metrics[accuracy])epochs 40
history model.fit(train_ds,validation_dataval_ds,epochsepochs) 结果如下图所示 6.4 模型评估
acc history.history[accuracy]
val_acc history.history[val_accuracy]loss history.history[loss]
val_loss history.history[val_loss]epochs_range range(epochs)plt.figure(figsize(12, 4))
plt.subplot(1, 2, 1)
plt.suptitle(DenseNet test)plt.plot(epochs_range, acc, labelTraining Accuracy)
plt.plot(epochs_range, val_acc, labelValidation Accuracy)
plt.legend(loclower right)
plt.title(Training and Validation Accuracy)plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, labelTraining Loss)
plt.plot(epochs_range, val_loss, labelValidation loss)
plt.legend(locupper right)
plt.title(Training and Validation loss)
plt.show() 结果如下图所示 结合训练时的输出结果和模型评估图可以看出训练的效果不理想修改了learing_rate效果也不明显后续继续尝试和分析。
