学习笔记|Pytorch使用教程10(模型容器与AlexNet创建)

最新推荐文章于 2023-02-14 20:16:08 发布

NotFound1911

最新推荐文章于 2023-02-14 20:16:08 发布

阅读量1.2k

点赞数 2

分类专栏： Pytorch 自学文章标签： Pytorch 学习笔记

本文链接：https://blog.csdn.net/qq_24739717/article/details/102789030

版权

自学同时被 2 个专栏收录

78 篇文章 17 订阅

订阅专栏

Pytorch

39 篇文章 24 订阅

订阅专栏

学习笔记|Pytorch使用教程10

本学习笔记主要摘自“深度之眼”，做一个总结，方便查阅。
使用Pytorch版本为1.2。

模型容器（Containers）
AlexNet构建

一.模型容器（Containers）

在这里插入图片描述

1.nn.Sequential 是 nn.module 的容器，用于按顺序包装一组网络层

顺序性：各网络层之间严格按照顺序构建
自带forward()：自带的forward里，通过for循环依次执行前向传播运算

测试代码：

import torch
import torchvision
import torch.nn as nn
from collections import OrderedDict


# ============================ Sequential
class LeNetSequential(nn.Module):
    def __init__(self, classes):
        super(LeNetSequential, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 6, 5),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(6, 16, 5),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),)

        self.classifier = nn.Sequential(
            nn.Linear(16*5*5, 120),
            nn.ReLU(),
            nn.Linear(120, 84),
            nn.ReLU(),
            nn.Linear(84, classes),)

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size()[0], -1)
        x = self.classifier(x)
        return x
net = LeNetSequential(classes=2)
fake_img = torch.randn((4, 3, 32, 32), dtype=torch.float32)
output = net(fake_img)
print(net)
print(output)

在 net = LeNetSequential(classes=2) 设置断点。在 container.py 中找到 Sequential ：

class Sequential(Module):
    r"""A sequential container.
    Modules will be added to it in the order they are passed in the constructor.
    Alternatively, an ordered dict of modules can also be passed in.

    To make it easier to understand, here is a small example::

        # Example of using Sequential
        model = nn.Sequential(
                  nn.Conv2d(1,20,5),
                  nn.ReLU(),
                  nn.Conv2d(20,64,5),
                  nn.ReLU()
                )

        # Example of using Sequential with OrderedDict
        model = nn.Sequential(OrderedDict([
                  ('conv1', nn.Conv2d(1,20,5)),
                  ('relu1', nn.ReLU()),
                  ('conv2', nn.Conv2d(20,64,5)),
                  ('relu2', nn.ReLU())
                ]))
    """

    def __init__(self, *args):
        super(Sequential, self).__init__()
        if len(args) == 1 and isinstance(args[0], OrderedDict):
            for key, module in args[0].items():
                self.add_module(key, module)
        else:
            for idx, module in enumerate(args):
                self.add_module(str(idx), module)

    def _get_item_by_idx(self, iterator, idx):
        """Get the idx-th item of the iterator"""
        size = len(self)
        idx = operator.index(idx)
        if not -size <= idx < size:
            raise IndexError('index {} is out of range'.format(idx))
        idx %= size
        return next(islice(iterator, idx, None))

    def __getitem__(self, idx):
        if isinstance(idx, slice):
            return self.__class__(OrderedDict(list(self._modules.items())[idx]))
        else:
            return self._get_item_by_idx(self._modules.values(), idx)

    def __setitem__(self, idx, module):
        key = self._get_item_by_idx(self._modules.keys(), idx)
        return setattr(self, key, module)

    def __delitem__(self, idx):
        if isinstance(idx, slice):
            for key in list(self._modules.keys())[idx]:
                delattr(self, key)
        else:
            key = self._get_item_by_idx(self._modules.keys(), idx)
            delattr(self, key)

    def __len__(self):
        return len(self._modules)

    def __dir__(self):
        keys = super(Sequential, self).__dir__()
        keys = [key for key in keys if not key.isdigit()]
        return keys

    def forward(self, input):
        for module in self._modules.values():
            input = module(input)
        return input

先判断是否是有序字典，本例程不是有序字典，所有通过for循环添加：
在这里插入图片描述
使用 self.add_module 方法添加。

依次添加进去：

当完成一个 Sequential，所有modules都被添加进去：

在 output = net(fake_img) 处设置断点，查看 forward 是如何实现的：

在__call__函数中实现 self.forward 函数，进入（step into）该语句：
在这里插入图片描述
在下一句中，继续进入(step into):

    def __getattr__(self, name):
        if '_parameters' in self.__dict__:
            _parameters = self.__dict__['_parameters']
            if name in _parameters:
                return _parameters[name]
        if '_buffers' in self.__dict__:
            _buffers = self.__dict__['_buffers']
            if name in _buffers:
                return _buffers[name]
        if '_modules' in self.__dict__:
            modules = self.__dict__['_modules']
            if name in modules:
                return modules[name]
        raise AttributeError("'{}' object has no attribute '{}'".format(
            type(self).__name__, name))

self.features 是 Sequential ，Sequential 继承 module，所有仍然会跳转到 module.py 的 __call__函数中：
在这里插入图片描述
继续在该处进入（step into）

来到 container.py 中的 forward 函数：

进行单步调试，不难发现是通过for 循环依次计算：

下一层的前向传播类似，现在查看整个网络结构：

这里的网络层在Sequential中是没有名字的，都是通过序号去索引的，如果层数特别深，不方便。下面使用另外一种Sequential的方法。使用有序字典构建整个网络。
测试代码：

class LeNetSequentialOrderDict(nn.Module):
    def __init__(self, classes):
        super(LeNetSequentialOrderDict, self).__init__()

        self.features = nn.Sequential(OrderedDict({
            'conv1': nn.Conv2d(3, 6, 5),
            'relu1': nn.ReLU(inplace=True),
            'pool1': nn.MaxPool2d(kernel_size=2, stride=2),

            'conv2': nn.Conv2d(6, 16, 5),
            'relu2': nn.ReLU(inplace=True),
            'pool2': nn.MaxPool2d(kernel_size=2, stride=2),
        }))

        self.classifier = nn.Sequential(OrderedDict({
            'fc1': nn.Linear(16*5*5, 120),
            'relu3': nn.ReLU(),

            'fc2': nn.Linear(120, 84),
            'relu4': nn.ReLU(inplace=True),

            'fc3': nn.Linear(84, classes),
        }))

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size()[0], -1)
        x = self.classifier(x)
        return x


net = LeNetSequentialOrderDict(classes=2)
fake_img = torch.randn((4, 3, 32, 32), dtype=torch.float32)
output = net(fake_img)
print(net)
print(output)

和上面类似，不过在这里是有序字典了：
在这里插入图片描述

不断通过for循环构建整个网络：

2.nn.ModuleList 是nn.module 的容器，用于包装一组网络层，以迭代方式调用主要方法：

append()：在ModuleList后面添加网络层
extend()：拼接两个ModuleList
insert()：指定在ModuleList中位置插入网络层

测试代码：

# ============================ ModuleList

class ModuleList(nn.Module):
    def __init__(self):
        super(ModuleList, self).__init__()
        self.linears = nn.ModuleList([nn.Linear(10, 10) for i in range(20)])

    def forward(self, x):
        for i, linear in enumerate(self.linears):
            x = linear(x)
        return x


net = ModuleList()
print(net)
fake_data = torch.ones((10, 10))
output = net(fake_data)
print(output)

在该处设置断点：
在这里插入图片描述
进入该语句，不断拼接modules：

查看 net 属性：

3.nn.ModuleDict是 nn.module 的容器，用于包装一组网络层，以索引方式调用网络层主要方法：

clear()：清空ModuleDict
items()：返回可以迭代的键值对（key-value pairs）
keys()：返回字典的键（key）
values()：返回字典的值（value）
pop()：返回一对键值，并从字典中删除

测试代码：

# ============================ ModuleDict
        

class ModuleDict(nn.Module):
    def __init__(self):
        super(ModuleDict, self).__init__()
        self.choices = nn.ModuleDict({
            'conv': nn.Conv2d(10, 10, 3),
            'pool': nn.MaxPool2d(3)
        })

        self.activations = nn.ModuleDict({
            'relu': nn.ReLU(),
            'prelu': nn.PReLU()
        })

    def forward(self, x, choice, act):
        x = self.choices[choice](x)
        x = self.activations[act](x)
        return x


net = ModuleDict()
fake_img = torch.randn((4, 10, 32, 32))
output = net(fake_img, 'conv', 'prelu')
print(output)

输出：
在这里插入图片描述
发现有负数，可以使用 relu 函数，全部为正。output = net(fake_img, ‘conv’, ‘relu’)

二.AlexNet构建

在这里插入图片描述

测试代码：

alexnet = torchvision.models.AlexNet()

进入这条语句(step into):

class AlexNet(nn.Module):

    def __init__(self, num_classes=1000):
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            nn.Conv2d(64, 192, kernel_size=5, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
            nn.Conv2d(192, 384, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(384, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),
        )
        self.avgpool = nn.AdaptiveAvgPool2d((6, 6))
        self.classifier = nn.Sequential(
            nn.Dropout(),
            nn.Linear(256 * 6 * 6, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        return x

NotFound1911

关注

2
点赞
踩
10

收藏

觉得还不错? 一键收藏
4
评论
学习笔记|Pytorch使用教程10(模型容器与AlexNet创建)

学习笔记|Pytorch使用教程10本学习笔记主要摘自“深度之眼”，做一个总结，方便查阅。使用Pytorch版本为1.2。模型容器（Containers）AlexNet构建一.模型容器（Containers）nn.Sequential 是 nn.module 的容器，用于按顺序包装一组网络层顺序性：各网络层之间严格按照顺序构建自带forward()：自带的forward里...
复制链接

扫一扫