《动手学深度学习》Paddle 版源码-5.12章（DenseNet）

import paddleimport paddle.nn as nnimport numpy as npimport warnings
warnings.filterwarnings("ignore", category=Warning) # 过滤报警信息class BNConv(nn.Layer):
    def __init__(self, num_channels, num_filters):
        super(BNConv, self).__init__()
        model = [
            nn.BatchNorm2D(num_channels),
            nn.ReLU(),
            nn.Conv2D(num_channels, num_filters, 3, stride=1, padding=1)
        ]
        self.model = nn.Sequential(*model)    def forward(self, X):
        return self.model(X)

class DenseBlock(nn.Layer):
    def __init__(self, num_channels, num_layers, growth_rate):
        super(DenseBlock, self).__init__()
        self.dense_blocks = []        for i in range(num_layers):
            block = self.add_sublayer(str(i), BNConv(num_channels + i * growth_rate, growth_rate))
            self.dense_blocks.append(block)    def forward(self, X):
        for block in self.dense_blocks:
            X = paddle.concat([X, block(X)], axis=1)        return X

blk = DenseBlock(3, 2, 10)
X = paddle.to_tensor(np.random.uniform(-1., 1., [4, 3, 8, 8]).astype('float32'))
Y = blk(X)print(Y.shape)

class TransitionLayer(nn.Layer):
    def __init__(self, num_channels, num_filters):
        super(TransitionLayer, self).__init__()
        model = [
            nn.BatchNorm2D(num_channels),
            nn.ReLU(),
            nn.Conv2D(num_channels, num_filters, 1, stride=1),
            nn.AvgPool2D(kernel_size=2, stride=2)
        ]
        self.model = nn.Sequential(*model)    def forward(self, X):
        return self.model(X)

blk = TransitionLayer(23, 10)
Y2 = blk(Y)print(Y2.shape)

class DenseNet(nn.Layer):
    def __init__(self, num_classes=10):
        super(DenseNet, self).__init__()        # DenseNet首先使用同ResNet一样的单卷积层和最大池化层。
        model = [
            nn.Conv2D(1, 64, 7, stride=2, padding=3),
            nn.BatchNorm2D(64),
            nn.ReLU(),
            nn.MaxPool2D(kernel_size=3, stride=2, padding=1)
        ]        # 类似于ResNet接下来使用的4个残差块，DenseNet使用的是4个稠密块。
        # 同ResNet一样，我们可以设置每个稠密块使用多少个卷积层。
        # 这里我们设成4，从而与上一节的ResNet-18保持一致。
        # 稠密块里的卷积层通道数（即增长率）设为32，所以每个稠密块将增加128个通道。
        # ResNet里通过步幅为2的残差块在每个模块之间减小高和宽。这里我们则使用过渡层来减半高和宽，并减半通道数。
        num_channels, growth_rate = 64, 32  # num_channels为当前的通道数
        num_convs_in_dense_blocks = [4, 4, 4, 4]        for i, num_convs in enumerate(num_convs_in_dense_blocks):
            model += [DenseBlock(num_channels, num_convs, growth_rate)]            # 上一个稠密块的输出通道数
            num_channels += num_convs * growth_rate            # 在稠密块之间加入通道数减半的过渡层
            if i != len(num_convs_in_dense_blocks) - 1:
                model += [TransitionLayer(num_channels, num_channels // 2)]
                num_channels //= 2

        # 同ResNet一样，最后接上全局池化层和全连接层来输出。
        model += [
            nn.AdaptiveAvgPool2D(output_size=1),
            nn.Flatten(start_axis=1, stop_axis=-1),
            nn.Linear(num_channels, num_classes),
        ]
        self.model = nn.Sequential(*model)    def forward(self, X):
        Y = self.model(X)        return Y

dn = DenseNet(10)
X = paddle.to_tensor(np.random.uniform(-1., 1., [4, 1, 96, 96]).astype('float32'))
Y = dn(X)print(Y.shape)

import paddleimport paddle.vision.transforms as Tfrom paddle.vision.datasets import FashionMNIST# 数据集处理transform = T.Compose([
    T.Resize(96),
    T.Transpose(),
    T.Normalize([127.5], [127.5]),
])
train_dataset = FashionMNIST(mode='train', transform=transform)
val_dataset = FashionMNIST(mode='test', transform=transform)# 模型定义model = paddle.Model(DenseNet(10))# 设置训练模型所需的optimizer, loss, metricmodel.prepare(
    paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()),
    paddle.nn.CrossEntropyLoss(),
    paddle.metric.Accuracy(topk=(1, 5)))# 启动训练、评估model.fit(train_dataset, val_dataset, epochs=2, batch_size=64, log_freq=100)