精华内容
下载资源
问答
  • pytorch Vgg16笔记

    千次阅读 2019-10-30 16:51:54
    原本想直接跳过VGG,直接到PSEnet,但面试遇到很多使用VGG16的,于是静下心看看VGG网络到底是什么样的。 1 卷积核 又叫滤波器filter,在pytorch 卷积神经网络笔记,我已经写出了卷积计算的公式,但是卷积核的大小...

    原本想直接跳过VGG,直接到PSEnet,但面试遇到很多使用VGG16的,于是静下心看看VGG网络到底是什么样的。
    1 卷积核
    又叫滤波器filter,在pytorch 卷积神经网络笔记,我已经写出了卷积计算的公式,但是卷积核的大小是多少呢?先看看卷积神经网络VGG16这么简单,为什么没人能说清? ,这里说卷积核一般用3*3.可是为什么呢?为什么倾向于使用3*3 小卷积核堆叠代替大卷积核
    在实践中深度学习(05)–典型CNN结构(VGG13,16,19,3x3的卷积核在VGG16中应用的很好,后来才被ResNet等其他网络模型借鉴过去。

    • 像素八邻域信息
      数字图像处理入门(二)-邻域、连通性
      这里面又有三个概念4邻域、D领域、8领域、4连通、8连通,分别为下图所示:
      12345
      那么为什么3*3是最小的能够捕获像素八邻域信息的尺寸呢?
      为什么现在大家喜欢用3*3小卷积?
    • 感受野(Receptive Field)
      卷积神经网络中感受野的详细介绍,实际就是特征图feature map上的一个点对应输入图上的一个区域。
      两层3x3的卷积核卷积操作之后的感受野是5x5,P=0,S=1
      三层3x3卷积核操作之后的感受野是7x7,P=0,S=1
      feature map长宽计算公式,其中W为宽度,H为高度,P为填充大小,K为卷积核大小,S为步长
      W n + 1 = ( W n + 2 ∗ P − K ) / S + 1 W_{n+1}=(W_n+2*P-K)/S+1 Wn+1=(Wn+2PK)/S+1
      H n + 1 = ( H n + 2 ∗ P − K ) / S + 1 H_{n+1}=(H_n+2*P-K)/S+1 Hn+1=(Hn+2PK)/S+1
      根据这个公式就不难明白,两次卷积后,成为1个像素点,那么第一卷积后的feature map的维度必须是3x3,所以反推感受野是5x5.反推公式如下,从最后一层的感受野往前推
      R F i = ( R F i + 1 − 1 ) ∗ S + K ⟹ ( 1 − 1 ) ∗ 1 + 3 = 3 ⟹ ( 3 − 1 ) ∗ 1 + 3 = 5 RF_i=(RF_{i+1}-1)*S+K\Longrightarrow (1-1)*1+3=3\Longrightarrow (3-1)*1+3=5 RFi=(RFi+11)S+K(11)1+3=3(31)1+3=5
      注意池化后的特征图大小为
      W n + 1 = ( W n − F ) / S + 1 W_{n+1}=(W_n-F)/S+1 Wn+1=(WnF)/S+1
      H n + 1 = ( H n − F ) / S + 1 H_{n+1}=(H_n-F)/S+1 Hn+1=(HnF)/S+1
      2 VGG网络
      vgg论文
      利用PyTorch实现VGG16,VGG系列(Pytorch实现),对比这两篇文章,打印网络,发现两者有差异,其中一个在全连接曾做了dropout,而另一个没有做。有一篇文章写的较为优雅,这里做一下笔记分析一下:
      2.1 nn.Sequential
      这里在全链接层Fully Connected Layer使用了nn.Sequential,我们知道FC曾主要做分类的,这里建立一个顺序执行的模型,pytorch系列7 -----nn.Sequential讲解,在这个容器中可以通过索引来获取,当然也可以取别名,参照pytorch教程之nn.Sequential类详解——使用Sequential类来自定义顺序连接模型
    self.classifier = nn.Sequential(
                nn.Linear(512 * 7 * 7, 4096),
                nn.ReLU(True),
                nn.Dropout(),
                nn.Linear(4096, 4096),
                nn.ReLU(True),
                nn.Dropout(),
                nn.Linear(4096, num_classes),
            )
      # 下面是打印出来的顺序模型,前面的数字就是模型中层
      (classifier): Sequential(
        (0): Linear(in_features=25088, out_features=4096, bias=True)
        (1): ReLU(inplace=True)
        (2): Dropout(p=0.5, inplace=False)
        (3): Linear(in_features=4096, out_features=4096, bias=True)
        (4): ReLU(inplace=True)
        (5): Dropout(p=0.5, inplace=False)
        (6): Linear(in_features=4096, out_features=1000, bias=True)
      )
    

    2.2 make_layers
    在卷积层、池化层、RN层中在vgg的各个网络模型中有差异,于是将其中的参数提取出来,想用的时候只需要切换参数构建模型就很方便了。

    cfg = {
        'A': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
        'B': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
        'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
        'E': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
    }
    def make_layers(cfg, batch_norm=False):
        layers = []
        in_channels = 3
        for v in cfg:
            if v == 'M':
                layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
            else:
                conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
                if batch_norm:
                    layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
                else:
                    layers += [conv2d, nn.ReLU(inplace=True)]
                in_channels = v
        return nn.Sequential(*layers)
    def vgg13_bn(**kwargs):
        model = VGG(make_layers(cfg['B'], batch_norm=True), **kwargs)
        return model
    
    展开全文
  • Pytorch VGG16源码解读

    千次阅读 2020-04-11 16:57:53
    我感觉我已经和时代脱轨了,有的网络已经发布...一个完成的VGG16包含如下 # 摘抄自Pytorch源代码,应该不会侵权吧... # VGG类,输入特征层和类别个数,得到类别向量 class VGG(nn.Module): def __init__(sel...
    • 一个完成的VGG16包含如下
    # 摘抄自Pytorch源代码,应该不会侵权吧...
    
    # VGG类,输入特征层和类别个数,得到类别向量
    
    class VGG(nn.Module):
    
        def __init__(self, features, num_classes=1000, init_weights=True):
            super(VGG, self).__init__()
            self.features = features  # 从参数输入特征提取流程 也即一堆CNN等
            self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
            self.classifier = nn.Sequential(  # 定义分类器
                nn.Linear(512 * 7 * 7, 4096),
                nn.ReLU(True),
                nn.Dropout(),
                nn.Linear(4096, 4096),
                nn.ReLU(True),
                nn.Dropout(),
                nn.Linear(4096, num_classes),
            )
            if init_weights:
                self._initialize_weights()
    
        def forward(self, x):
            x = self.features(x)  # 把输入图像通过feature计算得到特征层
            x = self.avgpool(x)
            x = torch.flatten(x, 1)
            x = self.classifier(x)
            return x
    
        def _initialize_weights(self):
            for m in self.modules():
                if isinstance(m, nn.Conv2d):  # isinstance 检查m是哪一个类型
                    nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                    if m.bias is not None:
                        nn.init.constant_(m.bias, 0)
                elif isinstance(m, nn.BatchNorm2d):
                    nn.init.constant_(m.weight, 1)
                    nn.init.constant_(m.bias, 0)
                elif isinstance(m, nn.Linear):
                    nn.init.normal_(m.weight, 0, 0.01)
                    nn.init.constant_(m.bias, 0)
    
    '''
    比较关键的一层,从cfg构建特征提取网络
    '''
    def make_layers(cfg, batch_norm=False):
        layers = []
        in_channels = 3
        for v in cfg:
            if v == 'M':  # 最大池化层
                layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
            else: 
                conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
                if batch_norm:
                    layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
                else:
                    layers += [conv2d, nn.ReLU(inplace=True)]
                in_channels = v
        return nn.Sequential(*layers)
    
    
    
    # cfg 用字母作为字典索引,方便获得对应的列表  vgg16对应D 详见论文
    cfgs = {
        'A': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
        'B': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
        'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
        'E': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
    }
    
    '''
    _vgg的定义 通过读取cfg构建输入参数对应的网络
    如果要构建vgg16,输入参数:
    arch = 'vgg16'
    cfg = 'D'
    batch_norm = False
    '''
    
    def _vgg(arch, cfg, batch_norm, pretrained, progress, **kwargs):
        if pretrained:
            kwargs['init_weights'] = False
        model = VGG(make_layers(cfgs[cfg], batch_norm=batch_norm), **kwargs)
        if pretrained:  # 参数加载 这里我的保存在了默认路径
            state_dict = load_state_dict_from_url(model_urls[arch],
                                                  progress=progress)
            model.load_state_dict(state_dict)
        return model
    
    # models.vgg16  跳转到这个函数,用_vgg 构造出vgg16
    def vgg16(pretrained=False, progress=True, **kwargs):
        return _vgg('vgg16', 'D', False, pretrained, progress, **kwargs)
    
    
    // 从models加载一个vgg16 net    实例化?
    net = models.vgg16(pretrained=True) 
    
    

    以上代码,便构建了一个vgg16,训练和推理过程就和其他网络一样了

    • 参考
      Pytorch源码
    展开全文
  • pytorch vgg16 猫狗识别

    千次阅读 2019-07-24 20:17:58
    '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, ...

     

    第一次做猫狗识别的任务,遇到点问题记录一下:

    主要是数据集的问题:  下载完猫狗数据集后,打开有两个文件夹分别是train和test。这两个文件夹中并没有子文件夹。直接将其导入

    train_dataset = torchvision.datasets.ImageFolder(root='/home/qqsdqt/桌面/cat/data/train',transform=transform)

    出现了问题是:在文件夹中没有找到文件,真是大写的懵逼,明明是有照片的好不啦。

    后来查了查torchvision.datasets.ImageFolder  这个函数发现,这个函数应该读取文件夹,也就是说这个函数中的路径下的应该是文件夹,而不是直接是照片。将这个train下的文件分成dog和cat两个子文件夹。也就是说应该数下面这个样子滴!

    百度了一下ImageFolder函数的解释


     

    import torch
    import torch.nn as nn
    import torchvision
    from torch.utils.data import DataLoader
    from torch.autograd import Variable
    import matplotlib.pyplot as plt
    import torchvision.transforms as transforms
    
    cfg = {
        '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'],
    }
    
    
    
    class VGG(nn.Module):
    
        def __init__(self, vgg_name):
            super(VGG, self).__init__()
            self.conv=nn.Sequential(
                nn.AvgPool2d(8,7)
            )
            self.features = self._make_layers(cfg[vgg_name])
            self.classifier = nn.Linear(512, 2)
    
    
        def forward(self, x):
            out=self.conv(x)
            out = self.features(out)
            out = out.view(out.size(0), -1)
            out = self.classifier(out)
            return out
    
        def _make_layers(self, cfg):
            layers = []
            in_channels = 3
            for x in cfg:
                if x == 'M':
                    layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
                else:
                    layers += [nn.Conv2d(in_channels, x, kernel_size=3, padding=1),
                               nn.BatchNorm2d(x),
                               nn.ReLU(inplace=True)]
                    in_channels = x
            layers += [nn.AvgPool2d(kernel_size=1, stride=1)]
            return nn.Sequential(*layers)
    
    
    BARCH_SIZE=512
    LR=0.001
    EPOCH=20
    
    device= torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    
    normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    transform = transforms.Compose([
        transforms.Resize(size=(227, 227)),
        transforms.RandomRotation(20),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        normalize
    ])
    
    train_dataset = torchvision.datasets.ImageFolder(root='/home/zhouchenglong/cat/data/train',transform=transform)
    
    train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=512, shuffle=True)
    
    
    validation_dataset =torchvision.datasets. ImageFolder(root='/home/zhouchenglong/cat/data/test',
                                     transform=transform)
    
    
    test_loader = torch.utils.data.DataLoader(validation_dataset, batch_size=512, shuffle=True)
    
    
    
    
    
    vggNet = VGG('VGG16').to(device)
    criterion=nn.CrossEntropyLoss().to(device)
    opti=torch.optim.Adam(vggNet.parameters(),lr=LR)
    
    
    if __name__=='__main__':
        Accuracy_list = []
        Loss_list = []
        for epoch in range(EPOCH):
            sum_loss = 0.0
            correct1 = 0
    
            total1 = 0
            for i,(images,labels)in enumerate(train_loader):
                print(i)
                num_images=images.size(0)
                images=Variable(images.to(device))
                labels=Variable(labels.to(device))
    
                out=vggNet(images)
                _, predicted = torch.max(out.data, 1)
    
                total1 += labels.size(0)
                print('predict={},labels={}'.format(predicted.size(),labels.size()))
                correct1 += (predicted == labels).sum().item()
    
                loss=criterion(out,labels)
    
                sum_loss+=loss.item()
    
                opti.zero_grad()
                loss.backward()
                opti.step()
    
                if i % 10 == 9:
                    print('[%d, %d] loss: %.03f'
                          % (epoch + 1, i + 1, sum_loss / 100))
                    sum_loss = 0.0
            Accuracy_list.append(100.0 * correct1 / total1)
            print('accurary={}'.format(100.0 * correct1 / total1))
            Loss_list.append(loss.item())
    
        torch.save(vggNet, './alexNet.pth')
    
        x1 = range(0, EPOCH)
        x2 = range(0, EPOCH)
        y1 = Accuracy_list
        y2 = Loss_list
        plt.subplot(2, 1, 1)
        plt.plot(x1, y1, 'o-')
        plt.title('Train accuracy vs. epoches')
        plt.ylabel('Train accuracy')
        plt.subplot(2, 1, 2)
        plt.plot(x2, y2, '.-')
        plt.xlabel('Train loss vs. epoches')
        plt.ylabel('Train loss')
        plt.savefig("accuracy_epoch" + (str)(EPOCH) + ".png")
        plt.show()
    
    
    

    欢迎大家看我的另一篇博文pytorch alexNet 猫狗识别https://blog.csdn.net/qq_38191717/article/details/97160761

     

    展开全文
  • import torch import torch.nn as nn from torch.utils.data import dataset,dataloader,Dataset,DataLoader from torchvision import...from torchvision.models import vgg16 vgg = vgg16(pretrained=True) #固定...

     

    import torch
    import torch.nn as nn
    from torch.utils.data import dataset,dataloader,Dataset,DataLoader
    from torchvision import transforms
    from torchvision.datasets import ImageFolder
    from torchvision.models import vgg16
    
    vgg = vgg16(pretrained=True)
    #固定所有参数,requires_grad=False
    for param in vgg.parameters():
        param.requires_grad = False
    
    vgg.classifier[6] = nn.Sequential(nn.Linear(in_features=4096,out_features=22))
    
    for p in vgg.parameters():
        print(p)

    或者直接使用以下代码只更新最后一层参数:

    for param in model.classifier[6].parameters():
        param.requires_grad = True

     

    #resnet

    resnet = models.resnet50(pretrained=True)
    for param in resnet.parameters():      # 冻结参数
        param.requires_grad = False
    resnet.fc = nn.Linear(resnet.fc.in_features, 100)
    
    展开全文
  • pytorch VGG16预训练分类模型识别Cat

    千次阅读 2020-12-11 09:49:46
    import torch import torch.nn.functional as F import torchvision.transforms import torchvision.models ...image = Image.open('D:/torch/VGG16/cat.jpg') print(image.size, image.format, image.mode) crop_obj.
  • pytorch vgg16训练自己的数据

    千次阅读 2019-12-14 20:12:00
    net.load_state_dict(torch.load('./vgg16-397923af.pth')) net.classifier = nn.Sequential() self.features = net self.classifier = nn.Sequential( nn.Linear(512 * 7 * 7, 512), nn.ReLU(True), nn....
  • pytorch VGG.pdf

    2021-08-10 16:40:23
    pytorch VGG.pdf
  • pytorch vgg 网络

    2020-09-07 21:10:06
    pytorch vgg网络 vgg网络参数量计算 vgg网络显存占用
  • pytorch VGG

    2020-09-05 09:17:42
    相对alexn 增加了层数,filter变成3*3
  • pytorch Vgg源码阅读

    千次阅读 2019-03-16 22:27:29
    要实现VGG16,主要需要两个类 VGG VGG16 VGG16调用VGG 这两个类的实现在VGG.PY中实现 首先我们来看看VGG类的实现 class VGG(nn.Module): def __init__(self, features, num_classes=1000, init_weights=True): ...
  • 主要介绍了pytorch VGG11识别cifar10数据集(训练+预测单张输入图片操作),具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • input image: n features: 224 jump: 1 receptive size: 1 start: 0.5 conv1: n features: 224 jump: 1 receptive size: 3 start: 0.5 conv2: n features: 224 ... receptive size: 5 start:...
  • 使用pytorch实现猫狗大战一.简介二.理论三.实现四.总结 一.简介     猫狗大战其实是Kaggle公司(在墨尔本创立的) 于2013年举办的比赛,判断一张输入图像是“猫”还是“狗”,并分别用0,1标识出来。   AI研习社...
  • pytorch VGG网络特征可视化

    千次阅读 2021-04-13 18:44:42
    将通过VGG网络或其他网络得到的特征图feats进行可视化输出,其中feats.shape=[N, C, H, W] N为一组图片数, C为通道数, H为图片的高度, W为图片的宽度 代码说明: 代码命名为featsVisual.py 使用时 import ...
  • 主要介绍了利用PyTorch实现VGG16教程,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,155
精华内容 4,062
关键字:

pytorchvgg16