angel鍖椾含鍟嗗満鍙屼汉闇插嚭瑙嗛-0871blog.com

google seo -> telegram: @ehseo6

">Newsnet 2022-10-02 23:04
  • home  >   /Adobe Photoshop CS2 v9.0.1 简体中文正式光盘版  >   angel鍖椾含鍟嗗満鍙屼汉闇插嚭瑙嗛
  • 闇插嚭绮夊>『网址:mxsty.cc』<变量>-m1x1s1t1y1-20221002   N

    Table Of Contents
    Table Of Contents

    涔愬北澶т經鑴氳毒闇插嚭>『网址:mxsty.cc』<变量>-m1x1s1t1y1-20221002   T

    让我们回顾一下在“多层感知机的简洁实现”一节中含单隐藏层的多层感知机的实现方法。我们首先构造Sequential实例,然后依次添加两个全连接层。其中第一层的输出大小为256,即隐藏层单元个数是256;第二层的输出大小为10,即输出层单元个数是10。我们在上一章的其他 节中也使用了Sequential类构造模型。这里我们介绍另外一种基于Block类的模型构造方法:它让模型构造更加灵活。

    4.1.1. 继承Block类来构造模型?

    Block类是nn模块里提供的一个模型构造类,我们可以继承它来定义我们想要的模型。下面继承Block类构造本节开头提到的多层感知机。这里定义的MLP类重载了Block类的__init__函数和forward函数。它们分别用于创建模型参数和定义前向计算。前向计算也即正向传播。

    In [1]:
    
    from mxnet import nd
    from mxnet.gluon import nn
    
    class MLP(nn.Block):
        # 声明带有模型参数的层,这里声明了两个全连接层
        def __init__(self, **kwargs):
            # 调用MLP父类Block的构造函数来进行必要的初始化。这样在构造实例时还可以指定其他函数
            # 参数,如“模型参数的访问、初始化和共享”一节将介绍的模型参数params
            super(MLP, self).__init__(**kwargs)
            self.hidden = nn.Dense(256, activation='relu')  # 隐藏层
            self.output = nn.Dense(10)  # 输出层
    
        # 定义模型的前向计算,即如何根据输入x计算返回所需要的模型输出
        def forward(self, x):
            return self.output(self.hidden(x))
    

    以上的MLP类中无须定义反向传播函数。系统将通过自动求梯度而自动生成反向传播所需的backward函数。

    我们可以实例化MLP类得到模型变量net。下面的代码初始化net并传入输入数据X做一次前向计算。其中,net(X)会调用MLP继承自Block类的__call__函数,这个函数将调用MLP类定义的forward函数来完成前向计算。

    In [2]:
    
    X = nd.random.uniform(shape=(2, 20))
    net = MLP()
    net.initialize()
    net(X)
    
    Out[2]:
    
    [[ 0.09543004  0.04614332 -0.00286654 -0.07790349 -0.05130243  0.02942037
       0.08696642 -0.0190793  -0.04122177  0.05088576]
     [ 0.0769287   0.03099705  0.00856576 -0.04467199 -0.06926839  0.09132434
       0.06786595 -0.06187842 -0.03436673  0.04234694]]
    <NDArray 2x10 @cpu(0)>
    

    注意,这里并没有将Block类命名为Layer(层)或者Model(模型)之类的名字,这是因为该类是一个可供自由组建的部件。它的子类既可以是一个层(如Gluon提供的Dense类),又可以是一个模型(如这里定义的MLP类),或者是模型的一个部分。我们下面通过两个例子来展示它的灵活性。

    4.1.2. Sequential类继承自Block?

    我们刚刚提到,Block类是一个通用的部件。事实上,Sequential类继承自Block类。当模型的前向计算为简单串联各个层的计算时,可以通过更加简单的方式定义模型。这正是Sequential类的目的:它提供add函数来逐一添加串联的Block子类实例,而模型的前向计算就是将这些实例按添加的顺序逐一计算。

    下面我们实现一个与Sequential类有相同功能的MySequential类。这或许可以帮助读者更加清晰地理解Sequential类的工作机制。

    In [3]:
    
    class MySequential(nn.Block):
        def __init__(self, **kwargs):
            super(MySequential, self).__init__(**kwargs)
    
        def add(self, block):
            # block是一个Block子类实例,假设它有一个独一无二的名字。我们将它保存在Block类的
            # 成员变量_children里,其类型是OrderedDict。当MySequential实例调用
            # initialize函数时,系统会自动对_children里所有成员初始化
            self._children[block.name] = block
    
        def forward(self, x):
            # OrderedDict保证会按照成员添加时的顺序遍历成员
            for block in self._children.values():
                x = block(x)
            return x
    

    我们用MySequential类来实现前面描述的MLP类,并使用随机初始化的模型做一次前向计算。

    In [4]:
    
    net = MySequential()
    net.add(nn.Dense(256, activation='relu'))
    net.add(nn.Dense(10))
    net.initialize()
    net(X)
    
    Out[4]:
    
    [[ 0.00362228  0.00633332  0.03201144 -0.01369375  0.10336449 -0.03508018
      -0.00032164 -0.01676023  0.06978628  0.01303309]
     [ 0.03871715  0.02608213  0.03544959 -0.02521311  0.11005433 -0.0143066
      -0.03052466 -0.03852827  0.06321152  0.0038594 ]]
    <NDArray 2x10 @cpu(0)>
    

    可以观察到这里MySequential类的使用跟“多层感知机的简洁实现”一节中Sequential类的使用没什么区别。

    4.1.3. 构造复杂的模型?

    虽然Sequential类可以使模型构造更加简单,且不需要定义forward函数,但直接继承Block类可以极大地拓展模型构造的灵活性。下面我们构造一个稍微复杂点的网络FancyMLP。在这个网络中,我们通过get_constant函数创建训练中不被迭代的参数,即常数参数。在前向计算中,除了使用创建的常数参数外,我们还使用NDArray的函数和Python的控制流,并多次调用相同的层。

    In [5]:
    
    class FancyMLP(nn.Block):
        def __init__(self, **kwargs):
            super(FancyMLP, self).__init__(**kwargs)
            # 使用get_constant创建的随机权重参数不会在训练中被迭代(即常数参数)
            self.rand_weight = self.params.get_constant(
                'rand_weight', nd.random.uniform(shape=(20, 20)))
            self.dense = nn.Dense(20, activation='relu')
    
        def forward(self, x):
            x = self.dense(x)
            # 使用创建的常数参数,以及NDArray的relu函数和dot函数
            x = nd.relu(nd.dot(x, self.rand_weight.data()) + 1)
            # 复用全连接层。等价于两个全连接层共享参数
            x = self.dense(x)
            # 控制流,这里我们需要调用asscalar函数来返回标量进行比较
            while x.norm().asscalar() > 1:
                x /= 2
            if x.norm().asscalar() < 0.8:
                x *= 10
            return x.sum()
    

    在这个FancyMLP模型中,我们使用了常数权重rand_weight(注意它不是模型参数)、做了矩阵乘法操作(nd.dot)并重复使用了相同的Dense层。下面我们来测试该模型的随机初始化和前向计算。

    In [6]:
    
    net = FancyMLP()
    net.initialize()
    net(X)
    
    Out[6]:
    
    [18.571953]
    <NDArray 1 @cpu(0)>
    

    因为FancyMLPSequential类都是Block类的子类,所以我们可以嵌套调用它们。

    In [7]:
    
    class NestMLP(nn.Block):
        def __init__(self, **kwargs):
            super(NestMLP, self).__init__(**kwargs)
            self.net = nn.Sequential()
            self.net.add(nn.Dense(64, activation='relu'),
                         nn.Dense(32, activation='relu'))
            self.dense = nn.Dense(16, activation='relu')
    
        def forward(self, x):
            return self.dense(self.net(x))
    
    net = nn.Sequential()
    net.add(NestMLP(), nn.Dense(20), FancyMLP())
    
    net.initialize()
    net(X)
    
    Out[7]:
    
    [24.86621]
    <NDArray 1 @cpu(0)>
    

    4.1.4. 小结?

    • 可以通过继承Block类来构造模型。
    • Sequential类继承自Block类。
    • 虽然Sequential类可以使模型构造更加简单,但直接继承Block类可以极大地拓展模型构造的灵活性。

    4.1.5. 练习?

    • 如果不在MLP类的__init__函数里调用父类的__init__函数,会出现什么样的错误信息?
    • 如果去掉FancyMLP类里面的asscalar函数,会有什么问题?
    • 如果将NestMLP类中通过Sequential实例定义的self.net改为self.net = [nn.Dense(64, activation='relu'), nn.Dense(32, activation='relu')],会有什么问题?

    4.1.6. 扫码直达讨论区?

    代理电竞陪玩工作室能做吗赚钱吗 百家乐 怎么下注 足球 想做代理 线上平台哪家好 反波胆 哪里能做代理
    环球彩票代理怎么开 开云体育网 体彩机构 足球计划卡 澳门六合彩 好买么
    捕鱼平台代理加盟 体育彩票刮刮乐怎么代理 电子专票代理 反波胆 代理怎么样 澳门足球服代理
    开云汽车代理加盟流程 彩票赚钱多的 竞速100选5容易吗 中国官方凤凰彩票实体代理平台 快三 买球