第三周作业:卷积神经网络(Part1)

Posted creami11

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了第三周作业:卷积神经网络(Part1)相关的知识,希望对你有一定的参考价值。

一、层和块

通过实例化nn.Sequential来构建我们的模型。下面的代码生成一个网络,其中包含一个具有256个单元和ReLU激活函数的全连接的隐藏层,然后是一个具有10个隐藏单元且不带激活函数的全连接的输出层。net(X)调用我们的模型来获得模型的输出。

import torch
from torch import nn
from torch.nn import functional as F

net = nn.Sequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))

X = torch.rand(2, 20)
net(X)

正向传播(forward)函数也非常简单:它将列表中的每个块连接在一起,将每个块的输出作为下一个块的输入。

1、自定义块

二、卷积层


卷积是一种有效提取图片特征的方法 。 一般用一个正方形卷积核,遍历图片上的每一个像素点。图片与卷积核重合区域内相对应的每一个像素值,乘卷积核内相对应点的权重,然后求和, 再加上偏置后,最后得到输出图片中的一个像素值。
图片分灰度图和彩色图,卷积核可以是单个也可以是多个,因此卷积操作分以下三种情况:
1、单通道输入,单卷积核

这里单通道指的是输入为灰度图,单卷积核值卷积核个数是1个

2、多通道输入,单卷积核

多数情况下,输入的图片是 RGB 三个颜色组成的彩色图,输入的图片包含了红、绿、蓝三层数据,卷积核的深度(通道数)应该等于输入图片的通道数,所以使用 3x3x3的卷积核,最后一个 3 表示匹配输入图像的 3 个通道,这样这个卷积核有三通道,每个通道都会随机生成 9 个待优化的参数,一共有 27 个待优化参数 w 和一个偏置 b。

卷积计算方法和单层卷积核相似,卷积核为了匹配红绿蓝三个颜色,把三层的卷积核套在三层的彩色图片上,重合的 27 个像素进行对应点的乘加运算,最后的结果再加上偏置项 b,求得输出图片中的一个值。

 3、多通道输入,多卷积核

(1)先取出一个卷积核与3通道的输入进行卷积,这个过程就和多通道输入,单卷积核一样,得到一个1通道的输出output1。同样再取出第二个卷积核进行同样的操作,得到第二个输出output2
(2)将相同size的output1与output2进行堆叠,就得到2通道的输出output。

图中输入X:[1,h,w,3]指的是:输入1张高h宽w的3通道图片。
卷积核W:[k,k,3,2]指的是:卷积核尺寸为3*3,通道数为3,个数为2。 

三、池化层

专门的网络层可以实现尺寸缩减功能。通过从局部相关的一组元素中进行采样或信息聚合,从而得到新的元素值。通常我们用到两种池化进行下采样:
(1)最大池化(Max Pooling),从局部相关元素集中选取最大的一个元素值。
(2)平均池化(Average Pooling),从局部相关元素集中计算平均值并返回。

全连接层

之所以叫全连接,是因为每个神经元与前后相邻层的每一个神经元都有连接关系。

 参数个数:(前层*后层+后层)

按照上图搭建的两层全连接网络,要训练分辨率仅仅是 28x28=784 的黑白图像,就有近 40 万个待优化的参数。现实生活中高分辨率的彩色图像,像素点更多,且为红绿蓝三通道信息。待优化的参数过多, 容易导致模型过拟合。为避免这种现象,实际应用中一般不会将原始图片直接喂入全连接网络。
在实际应用中,会先对原始图像进行卷积特征提取,把提取到的特征喂给全连接网络,再让全连接网络计算出分类评估值。
 

四、卷积神经网络LeNet

LeNet(LeNet-5)由两个部分组成: * 卷积编码器:由两个卷积层组成; * 全连接层密集块:由三个全连接层组成。

import torch
from torch import nn
from d2l import torch as d2l


class Reshape(torch.nn.Module):
    def forward(self, x):
        return x.view(-1, 1, 28, 28)

net = torch.nn.Sequential(
    Reshape(),
    nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Flatten(),
    nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(),
    nn.Linear(120, 84), nn.Sigmoid(),
    nn.Linear(84, 10))

stride步幅:卷积核经过输入特征图的采样间隔,不会重叠在一起

padding填充:在输入特征图的每一边添加一定数目的行列,使得输出的特征图的长、宽 = 输入的特征图的长、宽

kernel_size:窗口大小

Flatten():拉成一维向量

X = torch.rand(size=(1, 1, 28, 28), dtype=torch.float32)
for layer in net:
    X = layer(X)
    print(layer.__class__.__name__,'output shape: \\t',X.shape)

 训练模型

import torch
from torch import nn
from d2l import torch as d2l

batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)

class Reshape(torch.nn.Module):
    def forward(self, x):
        return x.view(-1, 1, 28, 28)

net = torch.nn.Sequential(
    Reshape(),
    nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Flatten(),
    nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(),
    nn.Linear(120, 84), nn.Sigmoid(),
    nn.Linear(84, 10))


def evaluate_accuracy_gpu(net, data_iter, device=None): 
    """使用GPU计算模型在数据集上的精度。"""
    if isinstance(net, torch.nn.Module):
        net.eval()  # 设置为评估模式
        if not device:
            device = next(iter(net.parameters())).device
    # 正确预测的数量,总预测的数量
    metric = d2l.Accumulator(2)
    for X, y in data_iter:
        if isinstance(X, list):
            # BERT微调所需的(之后将介绍)
            X = [x.to(device) for x in X]
        else:
            X = X.to(device)
        y = y.to(device)
        metric.add(d2l.accuracy(net(X), y), y.numel())
    return metric[0] / metric[1]

def train_ch6(net, train_iter, test_iter, num_epochs, lr, device):
    """用GPU训练模型(在第六章定义)。"""
    def init_weights(m):
        if type(m) == nn.Linear or type(m) == nn.Conv2d:
            nn.init.xavier_uniform_(m.weight)
    net.apply(init_weights)
    print('training on', device)
    net.to(device)
    optimizer = torch.optim.SGD(net.parameters(), lr=lr)
    loss = nn.CrossEntropyLoss()
    animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
                            legend=['train loss', 'train acc', 'test acc'])
    timer, num_batches = d2l.Timer(), len(train_iter)
    for epoch in range(num_epochs):
        # 训练损失之和,训练准确率之和,范例数
        metric = d2l.Accumulator(3)
        net.train()
        for i, (X, y) in enumerate(train_iter):
            timer.start()
            optimizer.zero_grad()
            X, y = X.to(device), y.to(device)
            y_hat = net(X)
            l = loss(y_hat, y)
            l.backward()
            optimizer.step()
            with torch.no_grad():
                metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])
            timer.stop()
            train_l = metric[0] / metric[2]
            train_acc = metric[1] / metric[2]
            if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1:
                animator.add(epoch + (i + 1) / num_batches,
                             (train_l, train_acc, None))
        test_acc = evaluate_accuracy_gpu(net, test_iter)
        animator.add(epoch + 1, (None, None, test_acc))
    print(f'loss {train_l:.3f}, train acc {train_acc:.3f}, '
          f'test acc {test_acc:.3f}')
    print(f'{metric[2] * num_epochs / timer.sum():.1f} examples/sec '
          f'on {str(device)}')
    
lr, num_epochs = 0.9, 10
train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

实例分析 “猫狗大战”

1、首先参考学习之前的代码,结合李沐老师课程中的LeNet-5网络进行了改进,进行简单的调整。

2、还需要增加输出在训练集和测试集上的acc图。

 3、因为时间开销过大,train和test数据集使用了原始数据集的一部分;最终实现效果不好,需要进一步改进网络。

4、对于LeNet整体的把握还有些问题,对于一些细节的处理没有完全理解。多学习几个实例,希望能有进步。

以上是关于第三周作业:卷积神经网络(Part1)的主要内容,如果未能解决你的问题,请参考以下文章

作业第三周作业

吴恩达深度学习工程师 04.卷积神经网络 第三周目标检测 基本的对象检测算法

第三周:卷积神经网络 part2

2017-2018-2《网络攻防实践》第三周作业

软件工程第3次作业 卷积神经网络

第三周网络攻防作业