pytorch逐行搭建CNN系列（二）VGG16

已于 2023-03-27 13:37:29 修改
阅读量576 收藏 8
点赞数
文章标签： cnn pytorch 深度学习 卷积神经网络 计算机视觉
于 2023-03-21 11:51:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nszzzzdr/article/details/129683463
版权

一 推陈出新

  • 采用连续的3x3的卷积核代替AlexNet中的较大卷积核（11x11，7x7，5x5），2 个 3x3 的卷积核叠加，它们的感受野等同于 1 个 5x5 的卷积核，3 个 3x3 的卷积核叠加后，它们的感受野等同于 1 个 7x7 的效果，所以使用3x3卷积核堆叠的形式，既增加了网络层数又减少了参数量。
  • 引入了1x1卷积核，实现了在保持feature map 尺寸不变（即不损失分辨率）的前提下，大幅增加非线性表达能力，加深了网络层数。同时，可以进行卷积核通道数的降维和升维。

二 渐入佳境

首先请明确，该网络共有16层（13个卷积层 + 3个全连接），如下图所示：

该图
[注]上图是从百度图片中截取的，我们总是站在巨人的肩膀上，才会有更多的时间去约会，感谢这位作者！

接下来对每一层进行梳理：
在这里插入图片描述
【注】我还在亏……躺平了。上表的参数核实了几遍，但也不保证准确无误。抱歉！

利用summary()函数打印网络结构和参数
在这里插入图片描述

block-1

	1-0 卷积层
			输入图像：224*224*3
					【图像的长*宽*通道数】
			卷 积 核：
					 尺寸信息：3*3*3 
					 		【滑动窗口/卷积核的长*宽*通道数，其中通道数默认与上一层的输入通道数一致】
					 数量： 64
					 	 【一般结合GPU硬件的配置，按照16的倍数递增】
			步    长：stride= 1
			填 充 值：padding = 1
			输出特征图：224*224*64
					 【特征图尺寸计算公式：（图像尺寸-卷积核尺寸 + 2*填充值)/步长+1】
					 【即 （224-3 + 2*1)/1+1 = 224】
					 【64 为通道数，由该卷积层的卷积核数量决定 】
			参数量：(3x3x3+1)x64=1792
 				     【3x3x3为卷积核，1为偏置参数，64为卷积核个数】
					 
	1-1 激活函数
			ReLU

———————————————————————————————————————————

	2-0 卷积层
			输入特征图：224*224*64
			卷 积 核：
					 尺寸信息：3*3*64
					 数量： 64
			步    长：stride= 1
			填 充 值：padding = 1
			输出特征图：224*224*64
					 【即 （224-3 + 2*1)/1+1 = 224 】
			参数量：(3x3x64+1)x64=36928
					 
	2-1 激活函数
			ReLU
					 
	2-2 池化层
			输入特征图：224*224*64
			池 化 核：3*3*1
			步    长： stride = 2
			填 充 值： padding = 0
			输出特征图：112*112*64
					 【即 （224-2 + 2*0)/2+1 = 112】

———————————————————————————————————————————
block-2

	 3-0 卷积层
			输入特征图：112*112*64
			卷 积 核：
					 尺寸信息：3*3*64
					 数量：128
			步    长：stride= 1
			填 充 值：padding = 1
			输出特征图：112*112*128
					 【即 （112-3+ 2*1)/1+1 = 112】
			参数量：(3x3x64+1)x128=73856
		
	 3-1 激活函数
			ReLU

———————————————————————————————————————————

	 4-0 卷积层
			输入特征图：112*112*128
			卷 积 核：
					 尺寸信息：3*3*128
					 数量：128
			步    长：stride= 1
			填 充 值：padding = 1
			输出特征图：112*112*128
					 【即 （112-3+ 2*1)/1+1 = 112】
			参数量：(3x3x128+1)x128=7147584
		
	 4-1 激活函数
			ReLU
			
	 4-2 池化层
			输入特征图：112*112*128
			池 化 核：3*3*1
			步    长： stride = 2
			填 充 值： padding = 0
			输出特征图：56*56*128
					 【即 （112-2+ 2*0)/2+1 = 56】

———————————————————————————————————————————
block-3

	 5-0 卷积层
			输入特征图：56*56*128
			卷 积 核：
					 尺寸信息：3*3*128
					 数量： 256
			步    长：stride= 1
			填 充 值：padding = 1
			输出特征图：56*56*256
					 【即 （56-3+ 2*1)/1+1 = 56 】
			参数量：(3x3x128+1)x256=295168
		
	 5-1 激活函数
			ReLU

———————————————————————————————————————————

	 6-0 卷积层
			输入特征图：56*56*256
			卷 积 核：
					 尺寸信息：3*3*256
					 数量： 256
			步    长：stride= 1
			填 充 值：padding = 1
			输出特征图：56*56*256
					 【即 （56-3+ 2*1)/1+1 = 56 】
			参数量：(3x3x256+1)x256=589824
		
	 6-1 激活函数
			ReLU

———————————————————————————————————————————

	 7-0 卷积层
			输入特征图：56*56*256
			卷 积 核：
					 尺寸信息：3*3*256
					 数量： 256
			步    长：stride= 1
			填 充 值：padding = 1
			输出特征图：56*56*256
					 【即 （56-3+ 2*1)/1+1 = 56 】
			参数量：(3x3x256+1)x256=589824
		
	 7-1 激活函数
			ReLU

	 7-2 池化层
			输入特征图：56*56*256
			池 化 核：3*3*1
			步    长： stride = 2
			填 充 值： padding = 0
			输出特征图：28*28*256
					 【即 （56-2 + 2*0)/2+1 = 28】

———————————————————————————————————————————
block-4

	 8-0 卷积层
			输入特征图：28*28*256
			卷 积 核：
					 尺寸信息：3*3*256
					 数量： 512
			步    长：stride= 1
			填 充 值：padding = 1
			输出特征图：28*28*512
					 【即 （28-3+ 2*1)/1+1 = 28 】
			参数量：(3x3x256+1)x512=1179648
		
	 8-1 激活函数
			ReLU

———————————————————————————————————————————

	 9-0 卷积层
			输入特征图：28*28*512
			卷 积 核：
					 尺寸信息：3*3*512
					 数量： 512
			步    长：stride= 1
			填 充 值：padding = 1
			输出特征图：28*28*512
					 【即 （28-3+ 2*1)/1+1 = 28】
			参数量：(3x3x512+1)x512=2359808
		
	 9-1 激活函数
			ReLU

———————————————————————————————————————————

	 10-0 卷积层
			输入特征图：28*28*512
			卷 积 核：
					 尺寸信息：3*3*512
					 数量：512
			步    长：stride= 1
			填 充 值：padding = 1
			输出特征图：28*28*512
					 【即 （28-3+ 2*1)/1+1 = 28 】
			参数量：(3x3x512+1)x512=2359808
		
	 10-1 激活函数
			ReLU			
				
	 10-2 池化层
			输入特征图：28*28*512
			池 化 核：3*3*1
			步    长： stride = 2
			填 充 值： padding = 0
			输出特征图：14*14*512
					 【即 （28-2 + 2*0)/2+1 = 14 】

———————————————————————————————————————————
block-5

	 11-0 卷积层
			输入特征图：14*14*512
			卷 积 核：
					 尺寸信息：3*3*512
					 数量： 512
			步    长：stride= 1
			填 充 值：padding = 1
			输出特征图：14*14*512
					 【即 （14-3+ 2*1)/1+1 = 14 】
			参数量：(3x3x512+1)x512=2359808
		
	 11-1 激活函数
			ReLU

———————————————————————————————————————————

	 12-0 卷积层
			输入特征图：14*14*512
			卷 积 核：
					 尺寸信息：3*3*512
					 数量： 512
			步    长：stride= 1
			填 充 值：padding = 1
			输出特征图：14*14*512
					 【即 （14-3+ 2*1)/1+1 = 14】
			参数量：(3x3x512+1)x512=2359808
		
	 12-1 激活函数
			ReLU

———————————————————————————————————————————

	 13-0 卷积层
			输入特征图：14*14*512
			卷 积 核：
					 尺寸信息：3*3*512
					 数量：512
			步    长：stride= 1
			填 充 值：padding = 1
			输出特征图：14*14*512
					 【即 （14-3+ 2*1)/1+1 = 14】
			参数量：(3x3x512+1)x512=2359808
		
	 13-1 激活函数
			ReLU			
				
	 13-2 池化层
			输入特征图：14*14*512
			池 化 核：3*3*1
			步    长： stride = 2
			填 充 值： padding = 0
			输出特征图：7*7*512
					 【即 （14-2 + 2*1)/2+1 = 7 】

———————————————————————————————————————————

	 14-0 全连接层
			输入特征图：7*7*512
			卷 积 核：
					 尺寸信息：7*7*512
					 数量： 4096
			步    长：stride= 0
			填 充 值：padding = 0
			输出特征图：1*1*4096
					 【即 （7-7+ 2*0)/1+1 = 1 】
			参数量：(7x7x512+1)x4096=102764544

	 14-1 激活函数
			ReLU

———————————————————————————————————————————

	 15-0 全连接层
			输入特征图：1*1*4096
			参数量：(4096+1)x4096=16781312

	 15-1 激活函数
			ReLU

———————————————————————————————————————————

	 16-0 输出层
			输入特征图：1*1*4096
			参数量：1000x4096=4096000

	 16-1 分类映射
			Softmax：将输入映射为0-1之间的实数，并且归一化保证和为1，因此多分类的概率之和也刚好为1。也就是说，分类问题是一个非黑即白的场景，要么是A，要么是B，要么是C，但是我们想知道更多的信息，于是通过softmax函数输出是A的概率（假设是0.88），是B的概率（假设是0.08），是C的概率（假设是0.01）。	[注]上图是从百度图片中截取的，感谢这位作者！

———————————————————————————————————————————

三 千里之行 始于手巧代码

1 CIAFR10_数据集加载

import torchvision
import torchvision.transforms as transforms


batchSize = 128  # 该参数根据计算机性能可修改

normalize = transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]) # 将图像的像素值归一化到[-1,1]之间

#  Compose将多个transforms的操作整合在一起
data_transform =  transforms.Compose([
									 transforms.Resize((224,224)),
									 transforms.ToTensor(),
									 normalize()])
									 
trainset = torchvision.datasets.CIFAR10(root='./Cifar-10',
 										train=True, download=True, transform=data_transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batchSize, shuffle=True)

testset = torchvision.datasets.CIFAR10(root='./Cifar-10', 
										train=False, download=True, transform=data_transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=batchSize, shuffle=False)

2 模型搭建

  • 初阶代码
import torch
import torch.nn as nn
import torch.functional as F
from torchsummary import summary

class VGG16(nn.Module):
    def __init__(self, in_channels =1, num_classes=1000):
        super(VGG16,self).__init__()


        # block_1
        self.c1=nn.Conv2d(in_channels=in_channels,out_channels=64,kernel_size=3,stride=1,padding=1)  
        self.a1=nn.ReLU(inplace=True)

        self.c2=nn.Conv2d(64,64,3,stride=1,padding=1)
        self.a2=nn.ReLU(inplace=True)
        self.p2=nn.MaxPool2d(kernel_size=2,stride=2,padding = 0)   
       

        # block_2
        self.c3=nn.Conv2d(64,128,3,stride=1,padding=1)
        self.a3=nn.ReLU(inplace=True)

        self.c4=nn.Conv2d(128,128,3,stride=1,padding=1)
        self.a4=nn.ReLU(inplace=True)
        self.p4=nn.MaxPool2d(kernel_size=2,stride=2,padding = 0)   


        # block_3
        self.c5=nn.Conv2d(128,256,3,stride=1,padding=1)
        self.a5=nn.ReLU(inplace=True)

        self.c6=nn.Conv2d(256,256,3,stride=1,padding=1)
        self.a6=nn.ReLU(inplace=True)

        self.c7=nn.Conv2d(256,256,3,stride=1,padding=1)
        self.a7=nn.ReLU(inplace=True)
        self.p7=nn.MaxPool2d(kernel_size=2,stride=2,padding = 0)


        # block_4
        self.c8=nn.Conv2d(256,512,3,stride=1,padding=1)
        self.a8=nn.ReLU(inplace=True)

        self.c9=nn.Conv2d(512,512,3,stride=1,padding=1)
        self.a9=nn.ReLU(inplace=True)

        self.c10=nn.Conv2d(512,512,3,stride=1,padding=1)
        self.a10=nn.ReLU(inplace=True)
        self.p10=nn.MaxPool2d(kernel_size=2,stride=2,padding = 0)


        # block_5
        self.c11=nn.Conv2d(512,512,3,stride=1,padding=1)
        self.a11=nn.ReLU(inplace=True)

        self.c12=nn.Conv2d(512,512,3,stride=1,padding=1)
        self.a12=nn.ReLU(inplace=True)

        self.c13=nn.Conv2d(512,512,3,stride=1,padding=1)
        self.a13=nn.ReLU(inplace=True)
        self.p13=nn.MaxPool2d(kernel_size=2,stride=2,padding = 0)


        self.fc1_d=nn.Dropout(p=0.5)
        self.fc1=nn.Linear(512*7*7,4096)
        self.fc1_a=nn.ReLU(inplace=True)

        self.fc2_d=nn.Dropout(p=0.5)
        self.fc2=nn.Linear(4096,4096)
        self.fc2_a=nn.ReLU(inplace=True)

        self.fc3=nn.Linear(4096,num_classes)


    def forward(self,x):
        x = self.c1(x)
        x = self.a1(x)
        x = self.c2(x)
        x = self.a2(x)
        x = self.p2(x)

        x = self.c3(x)
        x = self.a3(x)
        x = self.c4(x)
        x = self.a4(x)
        x = self.p4(x)

        x = self.c5(x)
        x = self.a5(x)
        x = self.c6(x)
        x = self.a6(x)
        x = self.c7(x)
        x = self.a7(x)
        x = self.p7(x)

        x = self.c8(x)
        x = self.a8(x)
        x = self.c9(x)
        x = self.a9(x)
        x = self.c10(x)
        x = self.a10(x)
        x = self.p10(x)


        x = self.c11(x)
        x = self.a11(x)
        x = self.c12(x)
        x = self.a12(x)
        x = self.c13(x)
        x = self.a13(x)
        x = self.p13(x)

        x=torch.flatten(x,start_dim=1)
        
        x = self.fc1_d(x)
        x = self.fc1(x)
        x = self.fc1_a(x)

        x = self.fc2_d(x)
        x = self.fc2(x)
        x = self.fc2_a(x)

        x=self.fc3(x)
        return  x

# 打印模型结构
model =VGG16(in_channels = 3, num_classes = 10)
summary(model, input_size=(3, 224, 224))
  • 高阶代码
from pyexpat import features
import torch.nn as nn
import torch



# VGG网络结构根据不同深度有四个版本，VGG11/13/16/19
# 我们试图在搭建网络的时候能够总结多种版本的VGG网络结构规律，用最少的代码行实现公共结构的复现，从而实现装B的梦想。
# VGG分为两个部分：一是特征提取网络，二是映射分类网络。

# 定义VGG类
class VGG(nn.Module):
	# 两个参数：features和num_classes
    def __init__(self, features, num_classes=1000):
        super(VGG, self).__init__()
		# 特征提取网络：包含卷积运算+激活函数+池化操作
        self.features = features	
        
        # 映射分类网络：包含Dropout+全连接层+激活函数	
        # 这部分层数较少，可直接罗列。
        # 以指定的运算传递顺序添加到序列容器nn.Sequential()中，在前向传播时自动调用forward()方法，无需再定义。
        self.classifier = nn.Sequential(	
            nn.Dropout(p=0.5),
            nn.Linear(512*7*7, 4096),
            nn.ReLU(True),
            nn.Dropout(p=0.5),
            nn.Linear(4096, 4096),
            nn.ReLU(True),
            nn.Linear(4096, num_classes)
        )
        
	# 定义网络结构的运算传递顺序/关系
    def forward(self, x):
        x = self.features(x)
        x = torch.flatten(x, start_dim=1)
        x = self.classifier(x)
        return x


# 定义VGG不同结构的配置列表，json格式{字典}，依照顺序，依次抽不同网络中的重要参数
# 观察发现，区别在于卷积核：不同层的个数有所不同
# 依照顺序，数字表示卷积核个数（等价于输入/输出特征图的通道数），'M'表示最大池化层
model_names = {
    'vgg11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],											
    'vgg13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],									
    'vgg16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],					
    'vgg19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'], 
}


# 定义特征提取网络函数
# 传入参数有两个：int类型的in_channels、列表类型的 model_name
def make_features( in_channels, model_name ): 
    model_name = model_name
    # 定义一个用于存储特征提取网络层的列表
    layers = []
    in_channels = in_channels	
    # 有序遍历配置列表
    for v in model_name:
        # 以池化操作为界限
        # 当配置列表中出现'M'时，向特征提取网络层中增加一层池化
        if v == "M":
            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
        # 否则，向特征提取网络层中增加一层卷积运算+激活函数
        # 并更新通道数，因为当前层的feature输出通道=下一层feature的输入通道
        else:
            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
            layers += [conv2d, nn.ReLU(True)]
            in_channels = v
    # 将特征提取网络层的列表添加到序列容器nn.Sequential()中
    return nn.Sequential(*layers)  


# 到此为止,我们装B成功,相比初阶代码，我们少敲了2/3的代码。！
if __name__ == '__main__':
     in_channels = 3
     model_name = model_names["vgg16"]
     model = VGG(make_features(in_channels, model_name), num_classes=10)
     print(model)

3 模型训练

from torch.optim import lr_scheduler
from tqdm import tqdm


# 优先调用 GPU
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# 超参数设置
n_epochs = 100
in_channels = 3
num_classes = 10
learning_rate = 0.0001  #学习率，优化器迭代的步长
momentum = 0.9 # 动量因子，用来矫正优化率，可选参数

# 实例化模型
model = VGG16(in_channels = in_channels, num_classes = num_classes)
model = model.to(device)

# 定义损失函数（交叉熵损失）
criterion = torch.nn.CrossEntropyLoss()

# 定义优化器(随机梯度下降法)
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, momentum = momentum)

# 动态调整学习率：每隔10轮变为原来的0.5。
# 其中StepLR()用于调整学习率，一般情况下会设置随着epoch的增大而逐渐减小，从而达到更好的训练效果。
lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.5)

# 开始训练模型
for epoch in range(n_epochs):
        running_loss = 0.0
        running_correct = 0
        print("Epoch {}/{}".format(epoch, n_epochs))
        print("-"*10)
        # 读取数据
        # for data in tqdm(trainloader): # 可自动生成进度条
        for data in trainloader:
            X_train, y_train = data
            X_train, y_train = X_train.cuda(), y_train.cuda()

            # 计算训练值
            outputs = model(X_train)
            
		    # torch.max(input, dim)函数会返回两个tensor，第一个tensor是每行的最大值；第二个tensor是每行最大值的索引
            _,pred = torch.max(outputs.data, 1)
            
            # 计算观测值（label）与训练值的损失函数
            loss = criterion(outputs, y_train)
            
            ###————————————————————————————————————————————————————————————

			# 反向传播部分
			
			# 梯度归零
            optimizer.zero_grad()
            # 反向传播，计算当前梯度
            loss.backward()
            # 根据梯度更新网络参数
            optimizer.step()
            #  item()得到元素张量的元素值
            running_loss += loss.data.item()
            running_correct += torch.sum(pred == y_train.data)

		# 验证模型
        testing_correct = 0
        for data in testloader:
            X_test, y_test = data
            X_test, y_test = X_test.cuda(), y_test.cuda()
			# eval()：如果模型中有Batch Normalization和Dropout，则不启用，以防改变权值
            # model.eval()
            # 进行预测
            outputs = model(X_test)
            _, pred = torch.max(outputs.data, 1)
            testing_correct += torch.sum(pred == y_test.data)
            
        print("Loss is:{:.4f}, Train Accuracy is:{:.4f}%, Test Accuracy is:{:.4f}".format(torch.true_divide(running_loss, len(trainset)),
                                                                                          torch.true_divide(100*running_correct, len(trainset)),
                                                                                          torch.true_divide(100*testing_correct, len(testset))))
    torch.save(model.state_dict(), "model_parameter.pkl")

4 模型预测
5 完整代码

  • 初阶代码
import torch
import torch.nn as nn
import torch.functional as F
import torchvision
import torchvision.transforms as transforms
import tqdm
from torch.optim import lr_scheduler
from torchsummary import summary

class VGG16(nn.Module):
    def __init__(self, in_channels =1, num_classes=1000):
        super(VGG16,self).__init__()


        # block_1
        self.c1=nn.Conv2d(in_channels=in_channels,out_channels=64,kernel_size=3,stride=1,padding=1)  
        self.a1=nn.ReLU(inplace=True)

        self.c2=nn.Conv2d(64,64,3,stride=1,padding=1)
        self.a2=nn.ReLU(inplace=True)
        self.p2=nn.MaxPool2d(kernel_size=2,stride=2,padding = 0)   
       

        # block_2
        self.c3=nn.Conv2d(64,128,3,stride=1,padding=1)
        self.a3=nn.ReLU(inplace=True)

        self.c4=nn.Conv2d(128,128,3,stride=1,padding=1)
        self.a4=nn.ReLU(inplace=True)
        self.p4=nn.MaxPool2d(kernel_size=2,stride=2,padding = 0)   


        # block_3
        self.c5=nn.Conv2d(128,256,3,stride=1,padding=1)
        self.a5=nn.ReLU(inplace=True)

        self.c6=nn.Conv2d(256,256,3,stride=1,padding=1)
        self.a6=nn.ReLU(inplace=True)

        self.c7=nn.Conv2d(256,256,3,stride=1,padding=1)
        self.a7=nn.ReLU(inplace=True)
        self.p7=nn.MaxPool2d(kernel_size=2,stride=2,padding = 0)


        # block_4
        self.c8=nn.Conv2d(256,512,3,stride=1,padding=1)
        self.a8=nn.ReLU(inplace=True)

        self.c9=nn.Conv2d(512,512,3,stride=1,padding=1)
        self.a9=nn.ReLU(inplace=True)

        self.c10=nn.Conv2d(512,512,3,stride=1,padding=1)
        self.a10=nn.ReLU(inplace=True)
        self.p10=nn.MaxPool2d(kernel_size=2,stride=2,padding = 0)


        # block_5
        self.c11=nn.Conv2d(512,512,3,stride=1,padding=1)
        self.a11=nn.ReLU(inplace=True)

        self.c12=nn.Conv2d(512,512,3,stride=1,padding=1)
        self.a12=nn.ReLU(inplace=True)

        self.c13=nn.Conv2d(512,512,3,stride=1,padding=1)
        self.a13=nn.ReLU(inplace=True)
        self.p13=nn.MaxPool2d(kernel_size=2,stride=2,padding = 0)


        # self.fc1_d=nn.Dropout(p=0.5)
        self.fc1=nn.Linear(512*7*7,4096)
        self.fc1_a=nn.ReLU(inplace=True)

        # self.fc2_d=nn.Dropout(p=0.5)
        self.fc2=nn.Linear(4096,4096)
        self.fc2_a=nn.ReLU(inplace=True)

        self.fc3=nn.Linear(4096,num_classes)


    def forward(self,x):
        x = self.c1(x)
        x = self.a1(x)
        x = self.c2(x)
        x = self.a2(x)
        x = self.p2(x)

        x = self.c3(x)
        x = self.a3(x)
        x = self.c4(x)
        x = self.a4(x)
        x = self.p4(x)

        x = self.c5(x)
        x = self.a5(x)
        x = self.c6(x)
        x = self.a6(x)
        x = self.c7(x)
        x = self.a7(x)
        x = self.p7(x)

        x = self.c8(x)
        x = self.a8(x)
        x = self.c9(x)
        x = self.a9(x)
        x = self.c10(x)
        x = self.a10(x)
        x = self.p10(x)


        x = self.c11(x)
        x = self.a11(x)
        x = self.c12(x)
        x = self.a12(x)
        x = self.c13(x)
        x = self.a13(x)
        x = self.p13(x)


        x=torch.flatten(x,start_dim=1)
        


        x = self.fc1(x)
        x = self.fc1_a(x)


        x = self.fc2(x)
        x = self.fc2_a(x)

        x=self.fc3(x)
        return  x


if __name__ == '__main__':

    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

    batchSize = 128  
    normalize = transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]) 
    data_transform =  transforms.Compose([
									     transforms.Resize((224,224)),
									     transforms.ToTensor(),
									     normalize()])
									 
    trainset = torchvision.datasets.CIFAR10(root='./Cifar-10',
 										    train=True, download=True, transform=data_transform)
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=batchSize, shuffle=True)

    testset = torchvision.datasets.CIFAR10(root='./Cifar-10', 
										    train=False, download=True, transform=data_transform)
    testloader = torch.utils.data.DataLoader(testset, batch_size=batchSize, shuffle=False)

  
    model = VGG16(in_channels = 3, num_classes = 10).to(device)

    n_epochs = 40
    num_classes = 10
    learning_rate = 0.0001
    momentum = 0.9 

    criterion = torch.nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
    lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.5)

    for epoch in range(n_epochs):
        print("Epoch {}/{}".format(epoch, n_epochs))
        print("-"*10)
       
        running_loss = 0.0
        running_correct = 0
        for data in trainloader:
            X_train, y_train = data
            X_train, y_train = X_train.cuda(), y_train.cuda()
            outputs = model(X_train)
            loss = criterion(outputs, y_train)
            _,pred = torch.max(outputs.data, 1)

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            running_loss += loss.data.item()
            running_correct += torch.sum(pred == y_train.data)


        testing_correct = 0
        for data in testloader:
            X_test, y_test = data
            X_test, y_test = X_test.cuda(), y_test.cuda()
            outputs = model(X_test)
            _, pred = torch.max(outputs.data, 1)
            testing_correct += torch.sum(pred == y_test.data)

        print("Loss is:{:.4f}, Train Accuracy is:{:.4f}%, Test Accuracy is:{:.4f}".format(torch.true_divide(running_loss, len(trainset)),
                                                                                          torch.true_divide(100*running_correct, len(trainset)),
                                                                                          torch.true_divide(100*testing_correct, len(testset))))
    torch.save(model.state_dict(), "model_parameter.pkl")
  • 高阶代码
import torch
import torch.nn as nn
import torch.functional as F
import torchvision
import torchvision.transforms as transforms
import tqdm
from torch.optim import lr_scheduler
from torchsummary import summary


class VGG(nn.Module):
    def __init__(self, features, num_classes=1000):
        super(VGG, self).__init__()
        self.features = features			
        self.classifier = nn.Sequential(	
            nn.Dropout(p=0.5),
            nn.Linear(512*7*7, 2048),
            nn.ReLU(True),
            nn.Dropout(p=0.5),
            nn.Linear(2048, 2048),
            nn.ReLU(True),
            nn.Linear(2048, num_classes)
        )
        
    def forward(self, x):
        x = self.features(x)
        x = torch.flatten(x, start_dim=1)
        x = self.classifier(x)
        return x

model_names = {
    'vgg11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],											
    'vgg13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],									
    'vgg16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],					
    'vgg19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'], 
}


def make_features( in_channels, model_name): 
    model_name = model_name
    layers = []
    in_channels = in_channels	
    for v in model_name:
        
        if v == "M":
            layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
            
       
        else:
            conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
            layers += [conv2d, nn.ReLU(True)]
            in_channels = v
    
    return nn.Sequential(*layers)  




if __name__ == '__main__':
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    batchSize = 64
    normalize = transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]) 
    data_transform =  transforms.Compose([
									     transforms.Resize((224,224)),
									     transforms.ToTensor(),
									     normalize()])
									 
    trainset = torchvision.datasets.CIFAR10(root='./Cifar-10',
 										    train=True, download=True, transform=data_transform)
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=batchSize, shuffle=True)

    testset = torchvision.datasets.CIFAR10(root='./Cifar-10', 
										    train=False, download=True, transform=data_transform)
    testloader = torch.utils.data.DataLoader(testset, batch_size=batchSize, shuffle=False)

  
    in_channels = 3
    model_name = model_names["vgg16"]
    model = VGG(make_features(in_channels, model_name), num_classes=10)

    n_epochs = 40
    num_classes = 10
    learning_rate = 0.0001
    momentum = 0.9 

    criterion = torch.nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
    lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.5)

    for epoch in range(n_epochs):
        print("Epoch {}/{}".format(epoch, n_epochs))
        print("-"*10)
       
        running_loss = 0.0
        running_correct = 0
        for data in trainloader:
            X_train, y_train = data
            X_train, y_train = X_train.cuda(), y_train.cuda()
            outputs = model(X_train)
            loss = criterion(outputs, y_train)
            _,pred = torch.max(outputs.data, 1)

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            running_loss += loss.data.item()
            running_correct += torch.sum(pred == y_train.data)

        testing_correct = 0
        for data in testloader:
            X_test, y_test = data
            X_test, y_test = X_test.cuda(), y_test.cuda()
            outputs = model(X_test)
            _, pred = torch.max(outputs.data, 1)
            testing_correct += torch.sum(pred == y_test.data)

        print("Loss is:{:.4f}, Train Accuracy is:{:.4f}%, Test Accuracy is:{:.4f}".format(torch.true_divide(running_loss, len(trainset)),
                                                                                          torch.true_divide(100*running_correct, len(trainset)),
                                                                                          torch.true_divide(100*testing_correct, len(testset))))
    torch.save(model.state_dict(), "model_parameter.pkl")
努力当总裁的郭琛予
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
【使用Pytorch实现VGG16网络模型】
vcsir的专栏
07-30 7269
VGG-Network是K.Simonyan和A.Zisserman在论文“VeryDeepConvolutionalNetworksforLarge-ScaleImageRecognition”中提出的卷积神经网络模型。该架构在ImageNet中实现了92.7%的top-5测试准确率，该网络拥有超过1400万张属于1000个类别的图像。•模型的输入是固定大小的224×224224×224RGB图像•预处理是从每个像素中减去训练集RGB值的平均值。......
pytorch实现VGG16网络
方悔读书迟
07-27 6997
import torch import torch.nn as nn class VGG16(nn.Module): def __init__(self, nums): super(VGG16, self).__init__() self.nums = nums vgg = [] # 第一个卷积部分 # 112, 112, 64 vgg.append(nn.Conv2d(in_channels=3,.
Pytorch使用VGG16模型进行预测猫狗二分类
qq_43649937的博客
07-31 3450
pytorch python
VGG-16算法-Pytorch实现人脸识别
最新发布
qq_57815235的博客
05-31 295
它主要使用3x3的卷积核和2x2的最大池化层，通过堆叠卷积层和池化层来构建深层网络在VGG网络中，所有的卷积层都使用了相同大小的卷积核（3x3）和相同的步长。VGG网络在多个卷积层和池化层后，包含了三个全连接层。迁移学习适用于数据量不足的情况。在迁移学习中，在大规模数据集上预训练的模型仅需少量的调整即可适应新任务。VGG网络简洁且深层的架构有效捕捉图像的复杂特征。我尝试了对模型的不同层进行微调，理解到每一层网络如何影响最终的学习效果。
【深度学习】Pytorch实现VGG16
H2WO4的博客
08-27 890
注意第一个全连接层的输入参数的大小为前一层的特征图通道数*特征图长*特征图宽，这个值会因为输入图片的大小变化而改变，可通过如下代码计算得到。运行结果如下，可见通道数为512，特征图大小为7*7。实例化模型并通过summary查看模型架构。导入所需库，定义数据。
PyTorch之VGG16网络结构详解以及源码解读
qq_34600424的博客
01-15 1万+
论文：Very Deep Convolutional Networks for Large-Scale Image Recognition 简单介绍 **意义：**证明了增加小卷积核的个数以及网络深度可以提高分类结果的正确率。 **预处理：**各通道减去RGB在训练集上的均值。 特点： 1）使用小的卷积核（3 × 3）叠加的形式代替大的卷积核（5 × 5 or 7 × 7） 2）卷积层不会改变layer大小，而是通过max pooling减小layer大小 3）网络层数比较深 优点： 1）网络结构简洁：
PyTorch预训练和微调：以VGG16为例
阿正的梦工坊
07-12 1497
加载vgg16预训练模型，进行CIFAR10图片分类
Faster R-CNN基于pytorch的原理
zm147451753的博客
03-27 1492
相关资料以及下载 代码地址：https://github.com/ruotianluo/pytorch-faster-rcnn.git 原理参考：https://blog.csdn.net/zm147451753/article/details/88218619 代码编译和运行 代码使用方法，暂时没找到win系统下的方法，为此，我安装了unbuntu，还是蛮好用的。 代码的编译运行...
【pytorch学习笔记】pytorch搭建VGG16网络+FashionMnist数据集
是安澜啊
05-01 1816
目录 VGG网络介绍 pytorch搭建VGG网络 附加知识 参考 VGG网络介绍 论文：《Very Deep Convolutional Networks for Large-ScaleImage Recognition》 论文地址：https://arxiv.org/abs/1409.1556 VGG ⽹络可以分为两部分：第⼀部分主要由卷积层和汇聚层组成，第⼆部分由全连接层组成。 VGG网络有多种不同的配置，但是VGG块数量都是5，VGG块中的卷积层的数量不同或者f...
一文读懂VGG网络
阿木寺的博客
08-06 2万+
《Very Deep Convolutional Networks for Large-Scale Image Recognition》 arXiv：https://arxiv.org/abs/1409.1556 intro：ICLR 2015 homepage：http://www.robots.ox.ac.uk/~vgg/research/very_deep/ 前言 VGG是Ox...
经典卷积神经网络——VGG16
Lightismore的博客
04-30 2万+
VGG16前言一、VGG发展历程二、VGG网络模型三、VGG16代码详解1.VGG网络架构2.VGG16网络验证2.读取数据，进行数据增强3.训练模型，测试准确率四、VGG缺点 前言 我们都知道Alexnet是卷积神经网络的开山之作，但是由于卷积核太大，移动步长大，无填充，所以14年提出的VGG网络解决了这一问题 一、VGG发展历程 VGG网络由牛津大学在2014年ImageNet挑战赛本地和分类追踪分别获得了第一名和第二名。研究卷积网络深度对其影响在大规模图像识别设置中的准确性，主要贡献是全面评估网络
利用PyTorch实现VGG16教程
12-17
我就废话不多说了，大家还是直接看代码吧~ import torch import torch.nn as nn import torch.nn.functional as F class VGG16(nn.Module): def __init__(self): super(VGG16, self).__init__() # 3 * 224 * 224 self.conv1_1 = nn.Conv2d(3, 64, 3) # 64 * 222 * 222 self.conv1_2 = nn.Conv2d(64, 64, 3, padding=(1, 1)) # 64 * 2
pytorch入门学习：加载模型（torchvision.models）
山上有只羊M
10-18 2万+
前言 PyTorch框架中有一个非常重要且好用的包：torchvision，该包主要由3个子包组成，分别是：torchvision.datasets、torchvision.models、torchvision.transforms。这3个子包的具体介绍可以参考官网：http://pytorch.org/docs/master/torchvision/index.html。具体代码可以参考gith...
pytorch一步一步在VGG16上训练自己的数据集
hnu_zzt的博客
12-19 3万+
准备数据集及加载，ImageFolder 在很多机器学习或者深度学习的任务中，往往我们要提供自己的图片。也就是说我们的数据集不是预先处理好的，像mnist，cifar10等它已经给你处理好了，更多的是原始的图片。比如我们以猫狗分类为例。在data文件下，有两个分别为train和val的文件夹。然后train下是cat和dog两个文件夹，里面存的是自己的图片数据，val文件夹同train。这样我们的...
VGG16学习笔记
dianshu1593的博客
03-07 747
转载自：http://deanhan.com/2018/07/26/vgg16/ 摘要 本文对图片分类任务中经典的深度学习模型VGG16进行了简要介绍，分析了其结构，并讨论了其优缺点。调用Keras中已有的VGG16模型测试其分类性能，结果表明VGG16对三幅测试图片均能正确分类。 前言 VGG是由Simonyan 和Zisserman在文献《Very Deep Convo...
手把手教你搭建卷积神经网络（CNN）
热门推荐
u013093426的博客
07-20 7万+
本文是基于吴恩达老师的《深度学习》第四课第一周习题所做，如果本文在某些知识点上描述得不够透彻的可以参见相关章节的具体讲解，同时极力推荐各位有志从事计算机视觉的朋友观看一下吴恩达老师的《深度学习》课程。 1.卷积神经网络构成 总的来说，卷积神经网络与神经网络的区别是增加了若干个卷积层，而卷积层又可细分为卷积（CONV）和池化（POOL）两部分操作（这两个重要概念稍后会简单的介绍，如果对CNN的基...
深度学习卷积神经网络——经典网络VGG-16网络的搭建与实现
loveliuzz的博客
01-23 4万+
一、VGG-16网络框架介绍 VGGNet是牛津大学计算机视觉组（Visual Geometry Group）和Google DeepMind公司的研究员一起研发的深度卷积神经网络。 VGGNet探索了卷积神经网络的深度与其性能之间的关系，通过反复堆叠3*3的小型卷积核和2*2的最大池化层， VGGNet成功地构筑了16~19层深的卷积神经网络。VGGNet相比之前state-of-
Pytorch学习笔记（I）——预训练模型（五）：VGG16网络结构
lockonlxf的博客
05-21 3266
VGG( (features): Sequential( (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (1): ReLU(inplace) (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1...
pytorch VGG16预训练分类模型识别Cat
qq_18127085的博客
12-11 1929
import torch import torch.nn.functional as F import torchvision.transforms import torchvision.models as models import PIL.Image as Image import numpy as np image = Image.open('D:/torch/VGG16/cat.jpg') print(image.size, image.format, image.mode) crop_obj.
用pytorch搭建vgg16模型
08-25
我可以提供一些关于如何使用PyTorch搭建VGG16模型的指导。首先，你需要创建一个VGG16模型，可以使用PyTorch实现。其次，你需要定义模型的架构，如层数，激活函数，池化层等。紧接着，你需要使用PyTorch定义一个优化器，用于更新模型的参数。最后，你需要使用训练数据进行训练，并在验证集上进行测试，以确定模型的准确率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

努力当总裁的郭琛予

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值