精华内容
下载资源
问答
  • vgg16代码
    千次阅读
    2020-09-08 21:54:18
    from keras.applications.vgg16 import VGG16
    from keras.models import Sequential
    from keras.layers import Conv2D, MaxPooling2D, Activation, Dropout, Flatten, Dense
    from keras.optimizers import SGD
    from keras.preprocessing.image import ImageDataGenerator, img_to_array, load_img
    import numpy as np
    from keras.utils import  np_utils
    import cv2
    import pickle
    import matplotlib.pyplot as plt
    import tensorflow as tf
    from sklearn import svm
    from keras.datasets import mnist
    
    # 得到适合网络的数据
    (X_train_data, Y_train), (X_test_data, Y_test) = mnist.load_data()  # 下载数据
    X_train_data = X_train_data.astype('float32')  # uint8-->float32
    X_test_data = X_test_data.astype('float32')
    X_train_data /= 255  # 归一化到0~1区间
    X_test_data /= 255
    # (60000, 48, 48, 3)
    X_train = []
    # (10000, 48, 48, 3)
    X_test = []
    # 把(27, 27, 1)维的数据转化成(48, 48, 3)维的数据
    for i in range(X_train_data.shape[0]):
        X_train.append(cv2.cvtColor(cv2.resize(X_train_data[i], (48, 48)), cv2.COLOR_GRAY2RGB))
    for i in range(X_test_data.shape[0]):
        X_test.append(cv2.cvtColor(cv2.resize(X_test_data[i], (48, 48)), cv2.COLOR_GRAY2RGB))
    
    X_train = np.array(X_train)
    X_test = np.array(X_test)
    # 独热编码
    y_train = np_utils.to_categorical(Y_train, num_classes=10)
    y_test = np_utils.to_categorical(Y_test, num_classes=10)
    
    # 构建网络
    vgg16_model = VGG16(weights='imagenet', include_top=False, input_shape=(48, 48, 3))
    for layer in vgg16_model.layers:
        layer.trainable = False # 别去调整之前的卷积层的参数
    
    top_model = Sequential()
    top_model.add(Flatten(input_shape=vgg16_model.output_shape[1:]))
    top_model.add(Dense(512, activation='relu'))
    top_model.add(Dropout(0.4))
    top_model.add(Dense(10, activation='softmax'))
    
    model = Sequential()
    model.add(vgg16_model)
    model.add(top_model)
    sgd = SGD(learning_rate=0.05, decay=1e-5)
    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['acc'])
    model.fit(X_train, y_train, batch_size=128, epochs=1)#iterator times
    
    model.evaluate(X_test, y_test)
    更多相关内容
  • vgg16代码,最简单版本,容易看懂,易上手,按照论文敲的
  • VGG16_TF:简单实现VGG16

    2021-04-28 21:41:47
    学习Tensorflow,拿VGG16练练手,没有其他骚操作,只有数据集制作,训练及测试。 训练数据-17flowers,百度网盘链接: : 3nc4 VGG16.npy,百度网盘链接: : 4wvq create_tfrecords.py为生成tfrecords数据脚本 VGG16....
  • vgg16代码实现

    千次阅读 2021-07-15 18:36:57
    class deeplabv1(nn.Module): def __init__(self): super(deeplabv1, self).__init__() self.block1 = nn.Sequential( nn.Conv2d(3, 64, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(64, 64, kernel_...
    class deeplabv1(nn.Module):
        def __init__(self):
            super(deeplabv1, self).__init__()
            self.block1 = nn.Sequential(
                nn.Conv2d(3, 64, kernel_size=3, padding=1),
                nn.ReLU(),
                nn.Conv2d(64, 64, kernel_size=3, padding=1),
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2, stride=2)
            )
            self.block2 = nn.Sequential(
                nn.Conv2d(64, 128, kernel_size=3, padding=1),
                nn.ReLU(),
                nn.Conv2d(128, 128, kernel_size=3, padding=1),
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2, stride=2)
            )
            self.block3 = nn.Sequential(
                nn.Conv2d(128, 256, kernel_size=3, padding=1),
                nn.ReLU(),
                nn.Conv2d(256, 256, kernel_size=3, padding=1),
                nn.ReLU(),
                nn.Conv2d(256, 256, kernel_size=3, padding=1),
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2, stride=2),
            )
            self.block3 = nn.Sequential(
                nn.Conv2d(128, 256, kernel_size=3, padding=1),
                nn.ReLU(),
                nn.Conv2d(256, 256, kernel_size=3, padding=1),
                nn.ReLU(),
                nn.Conv2d(256, 256, kernel_size=3, padding=1),
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2, stride=2)
            )
            self.block4 = nn.Sequential(
                nn.Conv2d(256, 512, kernel_size=3, padding=1),
                nn.ReLU(),
                nn.Conv2d(512, 512, kernel_size=3, padding=1),
                nn.ReLU(),
                nn.Conv2d(512, 512, kernel_size=3, padding=1),
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2, stride=2),
            )
            self.block5 = nn.Sequential(
                nn.Conv2d(512, 512, kernel_size=3, padding=1),
                nn.ReLU(),
                nn.Conv2d(512, 512, kernel_size=3, padding=1),
                nn.ReLU(),
                nn.Conv2d(512, 512, kernel_size=3, padding=1),
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2, stride=2),
            )
            self.block6 = nn.Sequential(
                nn.Flatten(),
                nn.Linear(512 * 7 * 7, 4096),
                nn.ReLU(),
                nn.Dropout(p=0.5),
                nn.Linear(4096, 4096),
                nn.ReLU(),
                nn.Dropout(p=0.5),
                nn.Linear(4096, 1000),
                nn.Softmax(),
            )
    
        def forward(self, input):
            output = self.block1(input)
            output = self.block2(output)
            output = self.block3(output)
            output = self.block4(output)
            output = self.block5(output)
            # print(output.shape)
            output = self.block6(output)
            return output
    
    
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    x = torch.rand(1, 3, 224, 224).to(device)
    test = deeplabv1().to(device)
    print(test)
    output = test(x)
    print(output.shape)

    展开全文
  • VGG16层经典源代码

    2018-09-23 16:50:06
    最经典的VGG代码,是深度学习的基础,适合配合VGG代码一起阅读使用,非常适合深度学习初学者阅读学习深度学习框架构建规则。
  • tensorflow-vgg16代码

    2018-11-24 10:43:15
    忘了是哪本外国书的源代码了,只是当时看书的时候顺便Copy了作者给的代码
  • 在Vera中使用VGG16进行迁移学习 使用在ImageNet上训练的VGG16网络进行传输学习和准确性比较 为了比较它们,已经使用三种不同的方法进行了相同的任务。 任务:图像分类数据集:来自Kaggle的Dogs vs Cats数据集。 ...
  • vgg16_VGG16_

    2021-10-01 18:08:23
    opencv,python版本,vgg16程序,希望对大家有用。
  • VGG16预训练代码

    2019-03-18 22:29:47
    VGG16模型进行预训练,代码功能是对一组数据集进行5分类
  • VGG的主要贡献是全面评估网络的深度,使用3*3卷积滤波器来提取特征。解决了Alexnet容易忽略小部分的特征。目前常用的有VGG13\VGG16网络,本文实例部分以VGG16为例。

    目录

    一. VGG 网络模型

    二. 代码复现

    1. 网络搭建

    2.数据集制作(pkl)

    3.源码地址


    一. VGG 网络模型

             Alexnet是卷积神经网络的开山之作,但是由于卷积核太大,移动步长大,无填充,所以14年提出的VGG网络解决了这一问题。而且VGG网络结构简单,以 基础卷积和池化组成,非常适合用作CNN的入门学习。 通过卷积,池化 不断将图片 的尺寸减小, 维度升高, 提取特征。
            VGG的主要贡献是全面评估网络的深度,使用3*3卷积滤波器来提取特征。解决了Alexnet容易忽略小部分的特征。目前常用的有VGG13\VGG16网络,本文实例部分以VGG16为例。VGG模型如下:

            如图所示,一共列出了VGG11、VGG13、VGG16、VGG19等6种VGG模型, 以VGG16为例, 因为其具有16个网络层,主要注意的是这其中不包括pooling(池化层)如maxpool,avgpool等,本文以上图中的VGG16(第D列)为例进行讲解。

    二. 代码复现

    1. 网络搭建

            以上图中的(D列)VGG16为例, 构建模型, train.py训练代码如下,其中模型搭建如network = Sequential所示。

    import tensorflow as tf
    import numpy as np
    import os
    import cv2
    from tensorflow.keras import layers, optimizers, datasets, Sequential
    import sys
    from six.moves import cPickle
    
    # 调用 GPU
    gpu = tf.config.experimental.list_physical_devices('GPU')
    if len(gpu) > 0:
        tf.config.experimental.set_memory_growth(gpu[0], True)
    
    def main():
    
        ######第一步,train, test # 加载数据
        #  batchsize 指每次 用作训练样本数, 比如训练样本总数为10000, 其中 训练集 8000张  验证集2000
        #  Train_batchsize = 80 ,则说明将所有数据训练一轮需要 8000/80 = 100 步 (step = 100) 也称一轮训练迭代100次
        #  训练时 还有一个参数 epoch, 表示整个训练 需要轮几次, 如epoch = 100 , 则表示 需要将整个 数据集训练100轮
        #  则整个训练 需要 迭代 epoch * (8000/Train_batchsize) = 10000 次
        Train_batchsize = 80
        val_batchsize = 50
        
        # 加载 训练集 和 验证集, 
        # x -> 训练用图片数据  x_val -> 验证用图片数据  
        # y -> 训练用图片标签  y_val -> 验证用图片标签
        (x, y), (x_val, y_val) = Cap_load_data()
        
        # 将标签 进行维度 调整 [n, 1] => [n]
        y = tf.squeeze(y, axis=1)  # [n, 1] => [n]
        y_val = tf.squeeze(y_val, axis=1)  # [n, 1] => [n]
        
        # 将数据进行打乱,并进行切片
        train_db = tf.data.Dataset.from_tensor_slices((x, y))
        train_db = train_db.shuffle(1000).map(preprocess).batch(Train_batchsize).repeat()
        val_db = tf.data.Dataset.from_tensor_slices((x_val, y_val))
        val_db = val_db.shuffle(500).map(preprocess).batch(val_batchsize).repeat()
    
        # 验证存储的pkl数据是否和 实际图片的一致
        # print(x.shape,y.shape,x_val.shape,y_val.shape)
        # print(x[0,0,0,:])
        #
        # src = cv2.imread(r"XXX.jpg")
        # src = cv2.resize(src, (64, 64))
        # src = cv2.cvtColor(src, cv2.COLOR_BGR2RGB)  # 因为cv2.imread  opencv中默认颜色通道为BGR
        # print(src[0,0,:])
    
        ######第二步,创建模型
        # 卷积层取特征
        # maxpool层强化特征并且把图片尺寸减小一半
        # 这里如果还是两层conv2d就会无法收敛
        network = Sequential([    # 64x64
            layers.Conv2D(64, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
            layers.Conv2D(64, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
            layers.MaxPool2D([2, 2]),  #
    
            layers.Conv2D(128, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
            layers.Conv2D(128, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
            layers.MaxPool2D([2, 2]), #32x32,
            # layers.MaxPool2D([2, 2]),#16x16,
    
            layers.Conv2D(256, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
            layers.Conv2D(256, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
            layers.Conv2D(256, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
            layers.MaxPool2D([2, 2]),
    
            layers.Conv2D(512, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
            layers.Conv2D(512, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
            layers.Conv2D(512, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
            layers.MaxPool2D([2, 2]),
    
            layers.Conv2D(512, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
            layers.Conv2D(512, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
            layers.Conv2D(512, kernel_size=[3, 3], padding="same", activation=tf.nn.relu),
            layers.MaxPool2D([2, 2]),
    
            # 转换形状
            # layers.Reshape((-1, 512), input_shape=(-1, 1, 1, 512)), # 这里加一个 Reshape层就好啦
            layers.Flatten(),
            layers.Dense(256, activation=tf.nn.relu),
            layers.Dense(128, activation=tf.nn.relu),
            layers.Dense(1, activation=tf.nn.sigmoid),
        ])
    
        network.build(input_shape=[None, 64, 64, 3])
        network.summary()
    
        #####第三步,训练参数配置
        # 用 keras 的高层API直接训练
        # network.compile(
        #    optimizer=optimizers.Adam(lr=1e-4),
        #    loss=tf.losses.categorical_crossentropy, # MSE 是个对象, CategoricalCrossentropy 是个类
        #    metrics=['accuracy']
        # )
        # network.compile(optimizer='adam',
        #                 loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
        #                 metrics=['accuracy'])
        network.compile(optimizer='rmsprop',
                      loss=tf.losses.binary_crossentropy,
                      metrics=['accuracy'])
    
        #####第四步,训练
        network.fit(train_db, epochs=20, verbose=2, steps_per_epoch=x.shape[0]//Train_batchsize, validation_steps=x_val.shape[0]//val_batchsize, validation_data=val_db, validation_freq=1)
        # .fit的verbose 输出日志模式
    
        network.save('XXX.h5')
    
    
    def preprocess(x, y):   # 数据集处理  把data 和 label 都设置为float型
        x = tf.cast(x, dtype=tf.float32) / 255.
        y = tf.cast(y, dtype=tf.int32)
        return x, y
    
    def Cap_load_data():
        # path = r'XXXXX'
        path = r'XXXXXX' # Data1 在Data基础上加了更多的小电容
        fpath = os.path.join(path, 'train.pkl')
        x_train, y_train = load_batch(fpath)
        fpath = os.path.join(path, 'test.pkl')
        x_val, y_val = load_batch(fpath)
    
        y_train = np.reshape(y_train, (len(y_train), 1))  #标签
        y_val = np.reshape(y_val, (len(y_val), 1))
    
        # if K.image_data_format() == 'channels_last':
        #     x_train = x_train.transpose(0, 2, 3, 1)
        #     x_val = x_val.transpose(0, 2, 3, 1)
    
        return (x_train, y_train), (x_val, y_val)
    
    def load_batch(fpath):  # 使用cpick 读取文件
        # with open(fpath, 'rb') as f:
        #     if sys.version_info < (3,):
        #       d = cPickle.load(f)
        #     else:
        #       d = cPickle.load(f, encoding='bytes')
        #       # decode utf8
        #       d_decoded = {}
        #       for k, v in d.items():
        #         d_decoded[k.decode('utf8')] = v
        #       d = d_decoded
        with open(fpath, 'rb') as f:
            d = cPickle.load(f, encoding='bytes')
        data = d['data']
        labels = d['labels']
        data = data.reshape(data.shape[0], 64, 64, 3)
        return data, labels
    
    
    if __name__ == "__main__":
        main()

    2.数据集制作(pkl)

    import tensorflow as tf
    import numpy as np
    import cv2
    import os
    import sys
    from six.moves import cPickle
    
    def main():
        pklPath = r"XXX.pkl"
        input_size = (64, 64)
        data_oneDim = input_size[0] * input_size[1] * 3
        # 测试集图片的张数
        num_trainImage = 4000
        data = np.array([[0 for x in range(data_oneDim)] for y in range(num_trainImage)])
        # 就本数据集而言,二分类,正反样例各占50% , 所以每种类设置数量为 num_trainImage/2 标签
        label1 = [0 for x in range(int(num_trainImage/2))]
        label2 = [1 for x in range(int(num_trainImage/2))]
        label = np.array(label1 + label2)
    
    
        # 上下各2000张 每张64*64  3通道
        # 64*64*3 = 12288   4000*12288 的 numpy的uint8s数组
        ImageFile1 = r"XXX" + "\\"
        ImageNames1 = os.listdir(ImageFile1)
        i = 0
        for Name1 in ImageNames1:
            imagePath = ImageFile1 + Name1
            src = cv2.imread(imagePath)
            src = cv2.resize(src, (64, 64))
            src = cv2.cvtColor(src,cv2.COLOR_BGR2RGB)  # 因为cv2.imread  opencv中默认颜色通道为BGR
            # src_data = np.array([src[:,:,0],src[:,:,1],src[:,:,2]])
            src_data = np.array(src)
            src_data = src_data.reshape(12288)
            data[i] = src_data
            i = i + 1
            # print(src[0,:,0])      测试输出  转化后的src_data 第一行的 r 分量是否 和src一致
            # print(src_data[:64])
            # print(src.shape)
            # print(src_data.shape)
    
        ImageFile2 = r"XXX" + "\\"
        ImageNames2 = os.listdir(ImageFile2)
        for Name2 in ImageNames2:
            imagePath = ImageFile2 + Name2
            src = cv2.imread(imagePath)
            src = cv2.resize(src, input_size)
            src = cv2.cvtColor(src,cv2.COLOR_BGR2RGB)  # 因为cv2.imread  opencv中默认颜色通道为BGR
            # src_data = np.array([src[:,:,0],src[:,:,1],src[:,:,2]])
            src_data = np.array(src)
            src_data = src_data.reshape(data_oneDim)
            data[i] = src_data
            i = i + 1
    
        Cap_dict = { 'data': data , 'labels':label }
        print(Cap_dict['data'].shape)
    
        with open(pklPath,'wb') as f:
            cPickle.dump(Cap_dict,f)
    
    if __name__ == "__main__":
        main()

    3.源码地址

    https://github.com/mcuwangzaiacm/VGG16_tensorflow2.0
            

    展开全文
  • 2.内容:基于VGG16深度学习网络目标识别matlab仿真,输出识别混淆矩阵+代码仿真操作视频 3.用处:用于基于VGG16深度学习网络目标识别算法编程学习 4.指向人群:本硕博等教研学习使用 5.运行注意事项: 使用...
  • VGG16代码详解

    千次阅读 多人点赞 2020-06-07 09:23:17
    VGG16代码详解 小白第一篇源码阅读笔记,若有错误请多多指教。 本文除了对源码的顺序和注释进行了一点删改外,其他与源码一致 首先看入口,也就是当我要去创建一个VGG模型时,我会调用的那个函数: def vgg11...

    小白第一篇源码阅读笔记,理解一个十分简单的VGG网络源码,有助于新手入门pytorch,若有错误请多多指教。

    先上源码链接

    本文除了对源码的顺序和注释进行了一点删改外,其他与源码一致

    首先看入口,也就是当我要去创建一个VGG模型时,我会调用的那个函数:

    def vgg11(pretrained=False, progress=True, **kwargs):
        return _vgg('vgg11', 'A', False, pretrained, progress, **kwargs)
    
    def vgg11_bn(pretrained=False, progress=True, **kwargs):
        return _vgg('vgg11_bn', 'A', True, pretrained, progress, **kwargs)
    
    def vgg13(pretrained=False, progress=True, **kwargs):
        return _vgg('vgg13', 'B', False, pretrained, progress, **kwargs)
    
    def vgg13_bn(pretrained=False, progress=True, **kwargs):
        return _vgg('vgg13_bn', 'B', True, pretrained, progress, **kwargs)
    
    def vgg16(pretrained=False, progress=True, **kwargs):
        return _vgg('vgg16', 'D', False, pretrained, progress, **kwargs)
    
    def vgg16_bn(pretrained=False, progress=True, **kwargs):
        return _vgg('vgg16_bn', 'D', True, pretrained, progress, **kwargs)
    
    def vgg19(pretrained=False, progress=True, **kwargs):
        return _vgg('vgg19', 'E', False, pretrained, progress, **kwargs)
    
    def vgg19_bn(pretrained=False, progress=True, **kwargs):
        return _vgg('vgg19_bn', 'E', True, pretrained, progress, **kwargs)
    

    可以看到,就是以上的几个函数,从函数名应该可以看出模型的结构,比如需要的是vgg11,那就调用名称为vgg11的函数即可。vgg11_bn代表vgg11网络中会加入batch normalization,没错,是否使用bn居然不是用bool变量作为一个参数实现的,而是用不同的函数调用的,有点匪夷所思,若有朋友知道是为什么请告知一下。

    可以看到,上边所有的调用都使用了_vgg这个函数,那我们就来看看_vgg:

    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
    

    函数_vgg使用了一堆参数:

    • batch_norm控制着用不用bn(也就是上上个代码块中函数名带_bn的,batch_norm就为True,不带就为False)
    • pretrained控制着用不用预训练模型,可以看到在函数体中有两处使用了pretrained变量:
      (1)第一处使用让kwargs中的一个值“init_weights”变False,从名字可以猜出,这个语句的大概意思是“如果要预训练模型的话,那就别初始化了吧,我有上好的权重给你用”
      (2)第二处使用时可以看到执行了“load_state_dict_from_url”,url就是一个网址,联系到“pretrained”,意思就是如果要用预训练数据,那就根据网址下载预训练参数,然后再给到模型"model"里边。那么参数“arch”的作用就是从字典model_urls中取出一个网址,而bool变量“progress”是用来决定要不要展示下载进度条的,不是很重要。
      实际上,model_urls字典是在源码中给出的:
    model_urls = {
        'vgg11': 'https://download.pytorch.org/models/vgg11-bbd30ac9.pth',
        'vgg13': 'https://download.pytorch.org/models/vgg13-c768596a.pth',
        'vgg16': 'https://download.pytorch.org/models/vgg16-397923af.pth',
        'vgg19': 'https://download.pytorch.org/models/vgg19-dcbb9e9d.pth',
        'vgg11_bn': 'https://download.pytorch.org/models/vgg11_bn-6002323d.pth',
        'vgg13_bn': 'https://download.pytorch.org/models/vgg13_bn-abd245e5.pth',
        'vgg16_bn': 'https://download.pytorch.org/models/vgg16_bn-6c64b313.pth',
        'vgg19_bn': 'https://download.pytorch.org/models/vgg19_bn-c79401a0.pth',
    }
    

    然后剩下_vgg中间最关键的一句话,建模型:

    model = VGG(make_layers(cfgs[cfg], batch_norm=batch_norm), **kwargs)

    可以看到这个建模的过程实际上是一个创建VGG类的实例的过程,那么我们就需要看一下VGG这个类是怎么写的了:

    class VGG(nn.Module):
        def __init__(self, features, num_classes=1000, init_weights=True):
            super(VGG, self).__init__()
            self.features = features
            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)
            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):
                    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)
    

    __init__和forward函数可以一起看,网络主要结构很清晰,features–>avgpool–>classifier,forward中classifier前边用了一个flatten,说明classifier就是一个最后用来分类的全连接层,classifier在__init__中写得也很清晰,就不说了。avgpool是一个自适应均值池化层,也在__init__中写明,不谈。

    _initialize_weights函数在_init_函数中提到过,就是当超参数“init_weights”设置为True时就执行该函数,意思当然就是给建好的模型(features–>avgpool–>classifier)初始化参数的,怎么添加的参数读者可以自己去看

    那么关键是这个features,注意这个features不是指样本中的特征,而是由外部参数给定,是模型的一部分结构,要我的话我就盲猜它肯定也和classifier一样,是一个nn.Sequential,那么这个features到底长什么样?可以回到_vgg创建实例的那句话来看:

    model = VGG(make_layers(cfgs[cfg], batch_norm=batch_norm), **kwargs)

    在这里,传入的features是函数make_layers的返回值,这个make_layers函数源码也有定义:

    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)
    

    一看make_layers的返回值,哈!果然不出我所料,是一个nn.Sequential(其实我瞎扯的,这谁能猜出来),那么Sequential中必然是一个各种层组成的列表,那这个layers必然是个列表,于是抬头一看,发现果然在开头定义了layer=[],那么可以断定,这个make_layers函数就是循环往layer列表中加入各种层的操作,那么整个VGG网络最核心的部分应该就是这里没错了。

    那么先看make_layers参数cfg:

    make_layers(cfgs[cfg], batch_norm=batch_norm)

    从传参的方式来看,参数cfg来自于一个字典cfgs,源码中有:

    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'],
    }
    

    那么可以看出cfg这个参数实际上是一个列表,这个列表是数字和字母’M‘组成,那么回到make_layers函数体中,for v in cfg 语句循环cfg列表,根据列表中不同的值加入不同的层,那就应该很容易猜到,cfg中的值控制了整个features的结构,具体在什么样的取值下加入什么层就不详说了,读者可以自己去看。

    最后补上导包代码和一个限制导入范围的字典__all__,就讲完了VGG所有源码:

    import torch
    import torch.nn as nn
    from .utils import load_state_dict_from_url
    
    __all__ = [
        'VGG', 'vgg11', 'vgg11_bn', 'vgg13', 'vgg13_bn', 'vgg16', 'vgg16_bn',
        'vgg19_bn', 'vgg19',
    ]
    

    以上实际上就讲完了,可能至此读者还有点迷糊,因为我是从出口开始倒叙的,但如果我将整个生成过程讲述一遍一切将豁然开朗:

    1、函数make_layers根据cfgs中的列表生成一个名叫features的nn.Sequential
    3、函数_vgg拿着features去找类VGG实例化了一个model,组成了一个拥有features–>avgpool–>classifier结构的模型

    这就是VGG代码的主要结构,其他涉及什么参数初始化,是否使用预训练模型,是否使用bn都是一些其他的细节,读者可以自己品

    展开全文
  • VGG之所以经典,是因为VGG第一次将深度学习做得非常“深”,达到了16-19层。同时,它用了非常“小”的卷积核(3X3)。 VGG与AlexNet差不多,不同之处就在于网络层数变深了。下图VGG对原始VGG16做了一点变化,把后面...
  • vgg16的网络结构如下所示,16的含义就是说网络中有16个全连接层。 图1没有画出最后的卷积层。 结合这两张图来看,捋一下网络的结果和卷积的过程: 1.第一阶段: 假设输入图片大小为224 x 224 x 3(如图2),先经历...
  • deep learning经典模型的搭建,包括vgg16vgg19,resnet50,都使用python源代码,并有详细注释,可以显示模型结构,适合初学者入门了解
  • VGG16代码注释

    2021-11-18 15:42:53
    原版代码在这:神经网络学习小记录52——Pytorch搭建孪生神经网络(Siamese network)比较图片相似性 VGG注释: import torch import torch.nn as nn from torchvision.models.utils import load_state_dict_from_...
  • vgg16网络,直接训练预测,方便有效
  • Pytorch--VGG16模型代码

    千次阅读 2021-04-08 15:18:03
    import torch ...class VGG16(nn.Module): def __init__(self): super(VGG16, self).__init__() self.features = nn.Sequential( # conv1 nn.Conv2d(3, 64, 3, 1, 1), nn.BatchNorm2d(64, 0.9),
  • 卷积神经网络模型之——VGG-16网络结构与代码实现

    千次阅读 多人点赞 2022-07-01 21:57:11
    VGG在2014年由牛津大学Visual GeometryGroup提出,获得该年lmageNet竞赛中Localization Task(定位任务)第一名和 Classification Task (分类任务)第二名。VGG与AlexNet相比,它采用几个连续的3x3的卷积核代替AlexNe
  • 经典卷积神经网络——VGG16

    千次阅读 多人点赞 2022-04-30 08:16:02
    VGG16前言一、VGG发展历程二、VGG网络模型三、VGG16代码详解1.VGG网络架构2.VGG16网络验证2.读取数据,进行数据增强3.训练模型,测试准确率四、VGG缺点 前言 我们都知道Alexnet是卷积神经网络的开山之作,但是由于...
  • vgg16代码,最简单pytorch版本,容易看懂,易上手,按照论文敲的
  • Pytorch迁移学习训练VGG16和模型测试代码(采用华为云modelarts训练),训练猫狗分类模型
  • VGG实现详细代码,希望对初学者有帮助哦!
  • VGG16网络结构图及pytorch 代码实现

    千次阅读 2020-10-20 10:54:44
    1.网络结构图及对应输出结果 2.pytorch代码实现 import torch.nn as nn ...class VGG16(nn.Module): def __init__(self): super(VGG16, self).__init__() self.maxpool1 = nn.Sequential( nn.Conv2d(3, 64, ker
  • 主要介绍了Python通过VGG16模型实现图像风格转换操作,结合实例形式详细分析了Python使用VGG16模型实现图像风格转换的具体原理、操作步骤与实现方法,需要的朋友可以参考下
  • 利用vgg16进行的猫狗图像的分类,由于其在模型比普通的cnn的层更加复杂,所以分类效果较优。同时可根据结果添加dropout层避免出现的过拟合现象。训练和测试图像较大没有放上来,可私聊/评论后发送。
  • VGG16的实施除了代码本身的注释外,我还写了一篇文章,您可以在找到有关VGGNet的进一步说明。内容vgg16.py :带有vgg16.py的图形定义的类。 VGG16 Train.ipynb :笔记本,用于培训和测试VGG16的实现。 如果您在查看...
  • VGG16神经网络视频

    2021-01-08 10:53:18
    老师边讲课,边写代码
  • 自己学习vgg的部分代码以及vgg16 npy文件

空空如也

空空如也

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

vgg16代码

友情链接: Compiler.zip