精华内容
下载资源
问答
  • PyTorch——二维卷积

    2021-03-07 12:39:00
    虽然卷积层得名于卷积(convolution)运算,但我们通常在卷积层中使用更加直观互相关(cross-correlation)运算。在二卷积层中,个二输入数组和个二维核(kernel)数组通过互相关运算输出个二数组。 ...

    参考链接

    1. https://tangshusen.me/Dive-into-DL-PyTorch/#/chapter05_CNN/5.1_conv-layer

    二维互相关计算

    虽然卷积层得名于卷积(convolution)运算,但我们通常在卷积层中使用更加直观的互相关(cross-correlation)运算。在二维卷积层中,一个二维输入数组和一个二维核(kernel)数组通过互相关运算输出一个二维数组。

    def corr2d(X, K):
        h, w = K.shape
        Y = torch.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1))
        for i in range(Y.shape[0]):
            for j in range(Y.shape[1]):
                Y[i, j] = (X[i: i + h, j: j + w] * K).sum()
        return Y
    

    二维卷积层

    二维卷积层将输入和卷积核做互相关运算,并加上一个标量偏差来得到输出。卷积层的模型参数包括了卷积核和标量偏差。在训练模型的时候,通常我们先对卷积核随机初始化,然后不断迭代卷积核和偏差。

    class Conv2D(nn.Module):
        def __init__(self, kernel_size):
            super(Conv2D, self).__init__()
            self.weight = nn.Parameter(torch.randn(kernel_size))
            self.bias = nn.Parameter(torch.randn(1))
    
        def forward(self, x):
            return corr2d(x, self.weight) + self.bias
    

    通过数据学习卷积核

    我们首先构造一个卷积层,其卷积核将被初始化成随机数组。接下来在每一次迭代中,我们使用平方误差来比较Y和卷积层的输出,然后计算梯度来更新权重。

    # 构造一个核数组形状是(1, 2)的二维卷积层
    conv2d = Conv2D(kernel_size=(1, 2))
    
    step = 20
    lr = 0.01
    for i in range(step):
        Y_hat = conv2d(X)
        l = ((Y_hat - Y) ** 2).sum()
        l.backward()
    
        # 梯度下降
        conv2d.weight.data -= lr * conv2d.weight.grad
        conv2d.bias.data -= lr * conv2d.bias.grad
    
        # 梯度清0
        conv2d.weight.grad.fill_(0)
        conv2d.bias.grad.fill_(0)
        if (i + 1) % 5 == 0:
            print('Step %d, loss %.3f' % (i + 1, l.item()))
    
    
    展开全文
  • 所谓的一维卷积,也就是卷积核是一维的。原理和2D Conv类似,只不过1D Conv的卷积核移动方向只有一个。 而且每组卷积核个数也等于输入人间的通道数。 实际操作中,以点云文件为例:包含nx3的数据,进行卷积前...
    • 所谓的一维卷积,也就是卷积核是一维的。原理和2D Conv类似,只不过1D Conv的卷积核移动方向只有一个,从滑动窗口的直观角度来看,多通道一维卷积核在数据长度方向上滑动

    • 而且每卷积核个数也等于输入数据的通道数。

    • 设定多少的输出通道,就会有多少卷积核

    • 实际操作中,以点云文件为例:包含nx3的数据,进行卷积前首先要交换样本个数与通道。

    • ##代码备份##

    import torch
    import torch.nn as nn
    from numpy import *
    
    
    # Args:
    #         in_channels (int): Number of channels in the input image  {输入通道数}
    #         out_channels (int): Number of channels produced by the convolution  {输出通道}
    #         kernel_size (int or tuple): Size of the convolving kernel
    #         stride (int or tuple, optional): Stride of the convolution. Default: 1
    #         padding (int or tuple, optional): Zero-padding added to both sides of
    #             the input. Default: 0
    #         padding_mode (string, optional): ``'zeros'``, ``'reflect'``,
    #             ``'replicate'`` or ``'circular'``. Default: ``'zeros'``
    #         dilation (int or tuple, optional): Spacing between kernel
    #             elements. Default: 1
    #         groups (int, optional): Number of blocked connections from input
    #             channels to output channels. Default: 1
    #         bias (bool, optional): If ``True``, adds a learnable bias to the
    #             output. Default: ``True``
    #
    
    conv1 = nn.Conv1d(3, 2, 2, 1)  # in, out, k_size, stride
    
    a = torch.ones(1, 5, 3)  # b_size, n, 3  # 点云格式
    a = a.permute(0, 2, 1)
    # a = torch.ones(3)
    print('a:\n', a)
    
    b = conv1(a)
    print('b:\n', b)
    print(b.shape)  # b_size, ch, length
    
    
    
    展开全文
  • 我们接下来需要用CIFAR-10数据集进行分类,步骤如下:使用torchvision 加载并预处理CIFAR-10数据集定义网络定义...10数据加载及预处理CIFAR-10是个常用彩色图片数据集,它有 10 个类别,分别是airplane、auto...

    我们接下来需要用CIFAR-10数据集进行分类,步骤如下:使用torchvision 加载并预处理CIFAR-10数据集

    定义网络

    定义损失函数和优化器

    训练网络并更新网络参数

    测试网络

    注意:文章末尾含有项目jupyter notebook实战教程下载可供大家课后实战操作

    一、CIFAR-10数据加载及预处理

    CIFAR-10 是一个常用的彩色图片数据集,它有 10 个类别,分别是 airplane、automobile、bird、cat、deer、dog、frog、horse、ship和 truck。每张图片都是 3*32*32 ,也就是 三通道彩色图片,分辨率 32*32。

    import torchvision as tv

    import torchvision.transforms as transforms

    from torchvision.transforms import ToPILImage

    import torch as t

    #可以把Tensor转化为Image,方便可视化

    show = ToPILImage()

    #先伪造一个图片的Tensor,用ToPILImage显示

    fake_img = t.randn(3, 32, 32)

    #显示图片

    show(fake_img)

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13importtorchvisionastv

    importtorchvision.transformsastransforms

    fromtorchvision.transformsimportToPILImage

    importtorchast

    #可以把Tensor转化为Image,方便可视化

    show=ToPILImage()

    #先伪造一个图片的Tensor,用ToPILImage显示

    fake_img=t.randn(3,32,32)

    #显示图片

    show(fake_img)

    第一次运行torchvision会自动下载CIFAR-10数据集,大约163M。这里我将数据直接放到项目 data文件夹 中。

    cifar_dataset = tv.datasets.CIFAR10(root=\'data\',

    train=True,

    download=True

    )

    imgdata, label = cifar_dataset[90]

    print(\'label: \', label)

    print(\'imgdata的类型:\',type(imgdata))

    imgdata

    1

    2

    3

    4

    5

    6

    7

    8

    9cifar_dataset=tv.datasets.CIFAR10(root=\'data\',

    train=True,

    download=True

    )

    imgdata,label=cifar_dataset[90]

    print(\'label:\',label)

    print(\'imgdata的类型:\',type(imgdata))

    imgdata

    运行结果

    Files already downloaded and verified

    label: 2

    imgdata的类型:

    1

    2

    3Filesalreadydownloadedandverified

    label:2

    imgdata的类型:

    注意,数据集中的照片数据是以 PIL.Image.Image类 形式存储的,在我们加载数据时,要注意将其转化为 Tensor类。

    def dataloader(train):

    transformer = transforms.Compose([

    transforms.ToTensor(),

    transforms.Normalize(mean=(0.5, 0.5, 0.5),

    std = (0.5, 0.5, 0.5))

    ])

    cifar_dataset = tv.datasets.CIFAR10(root=\'data\', #下载的数据集所在的位置

    train=train, #是否为训练集。

    download=True, #设置为True,不用再重新下载数据

    transform=transformer

    )

    loader = t.utils.data.DataLoader(

    cifar_dataset,

    batch_size=4,

    shuffle=True, #打乱顺序

    num_workers=2 #worker数为2

    )

    return loader

    classes=(\'plane\', \'car\', \'bird\', \'cat\', \'deer\', \'dog\', \'frog\', \'horse\', \'ship\', \'truck\')

    #训练集和测试集的加载器

    trainloader = dataloader(train=True)

    testloader = dataloader(train=False)

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28defdataloader(train):

    transformer=transforms.Compose([

    transforms.ToTensor(),

    transforms.Normalize(mean=(0.5,0.5,0.5),

    std=(0.5,0.5,0.5))

    ])

    cifar_dataset=tv.datasets.CIFAR10(root=\'data\',#下载的数据集所在的位置

    train=train,#是否为训练集。

    download=True,#设置为True,不用再重新下载数据

    transform=transformer

    )

    loader=t.utils.data.DataLoader(

    cifar_dataset,

    batch_size=4,

    shuffle=True,#打乱顺序

    num_workers=2#worker数为2

    )

    returnloader

    classes=(\'plane\',\'car\',\'bird\',\'cat\',\'deer\',\'dog\',\'frog\',\'horse\',\'ship\',\'truck\')

    #训练集和测试集的加载器

    trainloader=dataloader(train=True)

    testloader=dataloader(train=False)

    运行结果

    Files already downloaded and verified

    Files already downloaded and verified

    1

    2Filesalreadydownloadedandverified

    Filesalreadydownloadedandverified

    DataLoader是一个可迭代的对象,它将dataset返回的每一条数据样本拼接成一个batch,并提供多线程加速优化和数据打乱等操作。当程序对 cirfar_dataset 的所有数据遍历完一遍, 对Dataloader也完成了一次迭代。

    dataiter = iter(trainloader)

    #返回四张照片及其label

    images, labels = dataiter.next()

    #打印多张照片

    show(tv.utils.make_grid(images))

    1

    2

    3

    4

    5

    6

    7dataiter=iter(trainloader)

    #返回四张照片及其label

    images,labels=dataiter.next()

    #打印多张照片

    show(tv.utils.make_grid(images))

    二、定义网络

    最早的卷积神经网络LeNet为例,学习卷积神经网络。

    2.1 第一个convolutions层

    图中显示是单通道照片,但是由于我们的数据集中的照片是三通道照片。所以

    该层输入的是 三通道图片,图片长宽均为32,那么通过kernel_size=5的卷积核卷积后的尺寸为(32-5+1)=28

    同时要注意,第一个convolution中,图片由 三通道变为6通道, 所以在此卷积过程中,in_channels=3, out_channels=6

    nn.Conv2d(in_channels=3,

    out_channels=6,

    kernel_size=5)

    1

    2

    3nn.Conv2d(in_channels=3,

    out_channels=6,

    kernel_size=5)

    2.2 第一subsampling层

    该层输入数据是6通道,输出还为6通道,但是图片的长宽从28变为14,我们可以使用池化层来实现尺寸缩小一倍。这里我们使用MaxPool2d(2, 2)

    nn.MaxPool2d(kernel_size=2,

    stride=2)

    1

    2nn.MaxPool2d(kernel_size=2,

    stride=2)

    2.3 第二个convolutions层

    该层输入的是6通道数据,输出为16通道数据,且图片长宽从14变为10。这里我们使用

    nn.Conv2d(in_channels=6,

    out_channels=16,

    kernel_size=5)

    1

    2

    3nn.Conv2d(in_channels=6,

    out_channels=16,

    kernel_size=5)

    2.4 全连接层作用

    在此之前的卷积层和池化层都属于特征工程层,用于从数据中抽取特征。而之后的多个全连接层,功能类似于机器学习中的模型,用于学习特征数据中的规律,并输出预测结果。

    2.5 第一全连接层full connection

    第二个convolutions层输出的 数据形状为 (16, 5, 5) 的数组,是一个三维数据。

    而在全连接层中,我们需要将其 展平为一个一维数据(样子类似于列表,长度为16\*5\*5)

    nn.Linear(in_features=16*5*5,

    out_features=120) #根据图中,该输出为120

    1

    2nn.Linear(in_features=16*5*5,

    out_features=120)#根据图中,该输出为120

    2.6 第二全连接层

    该层的输入是一维数组,长度为120,输出为一维数组,长度为84.

    nn.Linear(in_features=120,

    out_features=84) #根据图中,该输出为84

    1

    2nn.Linear(in_features=120,

    out_features=84)#根据图中,该输出为84

    2.7 第三全连接层

    该层的输入是一维数组,长度为84,输出为一维数组,长度为10,该层网络定义如下

    nn.Linear(in_features=84,

    out_features=10) #根据图中,该输出为10

    1

    2nn.Linear(in_features=84,

    out_features=10)#根据图中,该输出为10

    注意:

    这里的长度10的列表,可以看做输出的label序列。例如理想情况下

    output = [1, 0, 0, 0, 0, 0, 0 ,0, 0 ,0]

    1output=[1,0,0,0,0,0,0,0,0,0]

    该output表示 input数据 经过该神经网络运算得到的 预测结果 显示的类别是 第一类

    同理,理想情况下

    output2 = [0, 1, 0, 0, 0, 0, 0 ,0, 0 ,0]

    1output2=[0,1,0,0,0,0,0,0,0,0]

    该output2表示 input数据 经过该神经网络运算得到的 预测结果 显示的类别是 第二类

    根据前面对LeNet网络的解读,现在我们用pytorch来定义LeNet网络结构

    import torch

    import torch.nn as nn

    class LeNet(nn.Module):

    def __init__(self):

    #Net继承nn.Module类,这里初始化调用Module中的一些方法和属性

    nn.Module.__init__(self)

    #定义特征工程网络层,用于从输入数据中进行抽象提取特征

    self.feature_engineering = nn.Sequential(

    nn.Conv2d(in_channels=3,

    out_channels=6,

    kernel_size=5),

    #kernel_size=2, stride=2,正好可以将图片长宽尺寸缩小为原来的一半

    nn.MaxPool2d(kernel_size=2,

    stride=2),

    nn.Conv2d(in_channels=6,

    out_channels=16,

    kernel_size=5),

    nn.MaxPool2d(kernel_size=2,

    stride=2)

    )

    #分类器层,将self.feature_engineering中的输出的数据进行拟合

    self.classifier = nn.Sequential(

    nn.Linear(in_features=16*5*5,

    out_features=120),

    nn.Linear(in_features=120,

    out_features=84),

    nn.Linear(in_features=84,

    out_features=10),

    )

    def forward(self, x):

    #在Net中改写nn.Module中的forward方法。

    #这里定义的forward不是调用,我们可以理解成数据流的方向,给net输入数据inpput会按照forward提示的流程进行处理和操作并输出数据

    x = self.feature_engineering(x)

    x = x.view(-1, 16*5*5)

    x = self.classifier(x)

    return x

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53importtorch

    importtorch.nnasnn

    classLeNet(nn.Module):

    def__init__(self):

    #Net继承nn.Module类,这里初始化调用Module中的一些方法和属性

    nn.Module.__init__(self)

    #定义特征工程网络层,用于从输入数据中进行抽象提取特征

    self.feature_engineering=nn.Sequential(

    nn.Conv2d(in_channels=3,

    out_channels=6,

    kernel_size=5),

    #kernel_size=2, stride=2,正好可以将图片长宽尺寸缩小为原来的一半

    nn.MaxPool2d(kernel_size=2,

    stride=2),

    nn.Conv2d(in_channels=6,

    out_channels=16,

    kernel_size=5),

    nn.MaxPool2d(kernel_size=2,

    stride=2)

    )

    #分类器层,将self.feature_engineering中的输出的数据进行拟合

    self.classifier=nn.Sequential(

    nn.Linear(in_features=16*5*5,

    out_features=120),

    nn.Linear(in_features=120,

    out_features=84),

    nn.Linear(in_features=84,

    out_features=10),

    )

    defforward(self,x):

    #在Net中改写nn.Module中的forward方法。

    #这里定义的forward不是调用,我们可以理解成数据流的方向,给net输入数据inpput会按照forward提示的流程进行处理和操作并输出数据

    x=self.feature_engineering(x)

    x=x.view(-1,16*5*5)

    x=self.classifier(x)

    returnx

    实例化神经网络LeNet

    net = LeNet()

    net

    1

    2net=LeNet()

    net

    运行结果

    LeNet(

    (feature_engineering): Sequential(

    (0): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))

    (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)

    (2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))

    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)

    )

    (classifier): Sequential(

    (0): Linear(in_features=400, out_features=120, bias=True)

    (1): Linear(in_features=120, out_features=84, bias=True)

    (2): Linear(in_features=84, out_features=10, bias=True)

    )

    )

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13LeNet(

    (feature_engineering):Sequential(

    (0):Conv2d(3,6,kernel_size=(5,5),stride=(1,1))

    (1):MaxPool2d(kernel_size=2,stride=2,padding=0,dilation=1,ceil_mode=False)

    (2):Conv2d(6,16,kernel_size=(5,5),stride=(1,1))

    (3):MaxPool2d(kernel_size=2,stride=2,padding=0,dilation=1,ceil_mode=False)

    )

    (classifier):Sequential(

    (0):Linear(in_features=400,out_features=120,bias=True)

    (1):Linear(in_features=120,out_features=84,bias=True)

    (2):Linear(in_features=84,out_features=10,bias=True)

    )

    )

    我们随机传入一批照片(batch_size=4) ,将其输入给net,看输出的结果是什么情况。

    注意:

    pytorch中输入的数据必须是batch数据(批数据)

    dataiter = iter(trainloader)

    #返回四张照片及其label

    images, labels = dataiter.next()

    outputs = net(images)

    outputs

    1

    2

    3

    4

    5

    6

    7

    8dataiter=iter(trainloader)

    #返回四张照片及其label

    images,labels=dataiter.next()

    outputs=net(images)

    outputs

    运行结果

    tensor([[ 0.1963, 0.0203, 0.0887, -0.0789, -0.0027, -0.0429, -0.1119, 0.0080,

    0.0007, -0.0901],

    [ 0.2260, 0.0246, 0.0498, -0.0188, 0.0207, -0.0541, -0.0943, 0.0431,

    -0.0204, -0.1023],

    [ 0.2168, 0.0280, 0.0463, -0.0055, -0.0017, -0.0504, -0.0897, 0.0385,

    -0.0229, -0.1030],

    [ 0.2025, 0.0579, 0.0527, -0.0038, -0.0300, -0.0474, -0.0952, 0.0698,

    -0.0145, -0.0620]], grad_fn=)

    1

    2

    3

    4

    5

    6

    7

    8tensor([[0.1963,0.0203,0.0887,-0.0789,-0.0027,-0.0429,-0.1119,0.0080,

    0.0007,-0.0901],

    [0.2260,0.0246,0.0498,-0.0188,0.0207,-0.0541,-0.0943,0.0431,

    -0.0204,-0.1023],

    [0.2168,0.0280,0.0463,-0.0055,-0.0017,-0.0504,-0.0897,0.0385,

    -0.0229,-0.1030],

    [0.2025,0.0579,0.0527,-0.0038,-0.0300,-0.0474,-0.0952,0.0698,

    -0.0145,-0.0620]],grad_fn=)

    t.max(input, dim)input:传入的tensor

    dim: tensor的方向。dim=1表示按照行方向计算最大值

    t.max(outputs, dim=1)

    1t.max(outputs,dim=1)

    运行结果

    (tensor([0.1963, 0.2260, 0.2168, 0.2025], grad_fn=),

    tensor([0, 0, 0, 0]))

    1

    2(tensor([0.1963,0.2260,0.2168,0.2025],grad_fn=),

    tensor([0,0,0,0]))

    上述的操作,找到了outputs中四个最大的值,及其对应的index(该index可以理解为label)

    三、定义损失函数和优化器

    神经网络强大之处就在于 反向传播,通过比较 预测结果 与 真实结果, 修整网络参数。

    这里的 比较 就是 损失函数,而 修整网络参数 就是 优化器。

    这样充分利用了每个训练数据,使得网络的拟合和预测能力大大提高。

    from torch import optim

    #定义交叉熵损失函数

    criterion = nn.CrossEntropyLoss()

    #随机梯度下降SGD优化器

    optimizer = optim.SGD(params = net.parameters(),

    lr = 0.001)

    1

    2

    3

    4

    5

    6

    7

    8fromtorchimportoptim

    #定义交叉熵损失函数

    criterion=nn.CrossEntropyLoss()

    #随机梯度下降SGD优化器

    optimizer=optim.SGD(params=net.parameters(),

    lr=0.001)

    四、训练网络

    所有网络的训练的流程都是类似的,不断执行(轮):给网络输入数据

    前向传播+反向传播

    更新网络参数

    遍历完一遍数据集称为一个epoch,这里我们进行 2个epoch 轮次的训练。

    epochs = 10

    average_loss_series = []

    for epoch in range(epochs):

    running_loss = 0.0

    for i, data in enumerate(trainloader):

    inputs, labels = data

    #inputs, labels = Variable(inputs), Variable(labels)

    #梯度清零

    optimizer.zero_grad()

    #forward+backward

    outputs = net(inputs)

    #对比预测结果和labels,计算loss

    loss = criterion(outputs, labels)

    #反向传播

    loss.backward()

    #更新参数

    optimizer.step()

    #打印log

    running_loss += loss.item()

    if i % 2000 == 1999: #每2000个batch打印一次训练状态

    average_loss = running_loss/2000

    print("[{0},{1}] loss: {2}".format(epoch+1, i+1, average_loss))

    average_loss_series.append(average_loss)

    running_loss = 0.0

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34epochs=10

    average_loss_series=[]

    forepochinrange(epochs):

    running_loss=0.0

    fori,datainenumerate(trainloader):

    inputs,labels=data

    #inputs, labels = Variable(inputs), Variable(labels)

    #梯度清零

    optimizer.zero_grad()

    #forward+backward

    outputs=net(inputs)

    #对比预测结果和labels,计算loss

    loss=criterion(outputs,labels)

    #反向传播

    loss.backward()

    #更新参数

    optimizer.step()

    #打印log

    running_loss+=loss.item()

    ifi%2000==1999:#每2000个batch打印一次训练状态

    average_loss=running_loss/2000

    print("[{0},{1}] loss:  {2}".format(epoch+1,i+1,average_loss))

    average_loss_series.append(average_loss)

    running_loss=0.0

    运行结果

    [1,2000] loss: 2.284719424366951

    [1,4000] loss: 2.1300598658323286

    [1,6000] loss: 2.0143098856806754

    [1,8000] loss: 1.9478365245759488

    [1,10000] loss: 1.9135449583530426

    [1,12000] loss: 1.8653237966001033

    [2,2000] loss: 1.8014366626143457

    [2,4000] loss: 1.737443323969841

    [2,6000] loss: 1.6933535016775132

    [2,8000] loss: 1.6476907352507115

    [2,10000] loss: 1.6234023304879666

    [2,12000] loss: 1.5863604183495044

    [3,2000] loss: 1.5544855180978776

    [3,4000] loss: 1.539060534775257

    [3,6000] loss: 1.5500386973917484

    [3,8000] loss: 1.5407403408288955

    [3,10000] loss: 1.493699783280492

    [3,12000] loss: 1.4957395897060632

    [4,2000] loss: 1.4730096785128117

    [4,4000] loss: 1.4749664356559515

    [4,6000] loss: 1.4479290856420994

    [4,8000] loss: 1.445657522082329

    [4,10000] loss: 1.4586472637057304

    [4,12000] loss: 1.4320134285390378

    [5,2000] loss: 1.406113230422139

    [5,4000] loss: 1.4196837954670192

    [5,6000] loss: 1.3951636335104705

    [5,8000] loss: 1.3933502195328473

    [5,10000] loss: 1.3908299638181925

    [5,12000] loss: 1.3908768535405398

    [6,2000] loss: 1.3397984126955271

    [6,4000] loss: 1.3737898395806551

    [6,6000] loss: 1.360704499706626

    [6,8000] loss: 1.3652801268100738

    [6,10000] loss: 1.334371616870165

    [6,12000] loss: 1.312294240474701

    [7,2000] loss: 1.3097571679353714

    [7,4000] loss: 1.3236577164530754

    [7,6000] loss: 1.310647354334593

    [7,8000] loss: 1.3016219032108785

    [7,10000] loss: 1.2931814943552018

    [7,12000] loss: 1.2910259604007006

    [8,2000] loss: 1.2796987656354903

    [8,4000] loss: 1.2650054657310248

    [8,6000] loss: 1.2713083022236824

    [8,8000] loss: 1.258927255064249

    [8,10000] loss: 1.275728213787079

    [8,12000] loss: 1.2612977192252874

    [9,2000] loss: 1.2273035216629504

    [9,4000] loss: 1.25000972096622

    [9,6000] loss: 1.2236297953873874

    [9,8000] loss: 1.2251979489773512

    [9,10000] loss: 1.2623697004914283

    [9,12000] loss: 1.2501848887503146

    [10,2000] loss: 1.2257770787626505

    [10,4000] loss: 1.2277075409144163

    [10,6000] loss: 1.2050671626776457

    [10,8000] loss: 1.2159633481949568

    [10,10000] loss: 1.210464821562171

    [10,12000] loss: 1.2225491935014725

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60[1,2000]loss:2.284719424366951

    [1,4000]loss:2.1300598658323286

    [1,6000]loss:2.0143098856806754

    [1,8000]loss:1.9478365245759488

    [1,10000]loss:1.9135449583530426

    [1,12000]loss:1.8653237966001033

    [2,2000]loss:1.8014366626143457

    [2,4000]loss:1.737443323969841

    [2,6000]loss:1.6933535016775132

    [2,8000]loss:1.6476907352507115

    [2,10000]loss:1.6234023304879666

    [2,12000]loss:1.5863604183495044

    [3,2000]loss:1.5544855180978776

    [3,4000]loss:1.539060534775257

    [3,6000]loss:1.5500386973917484

    [3,8000]loss:1.5407403408288955

    [3,10000]loss:1.493699783280492

    [3,12000]loss:1.4957395897060632

    [4,2000]loss:1.4730096785128117

    [4,4000]loss:1.4749664356559515

    [4,6000]loss:1.4479290856420994

    [4,8000]loss:1.445657522082329

    [4,10000]loss:1.4586472637057304

    [4,12000]loss:1.4320134285390378

    [5,2000]loss:1.406113230422139

    [5,4000]loss:1.4196837954670192

    [5,6000]loss:1.3951636335104705

    [5,8000]loss:1.3933502195328473

    [5,10000]loss:1.3908299638181925

    [5,12000]loss:1.3908768535405398

    [6,2000]loss:1.3397984126955271

    [6,4000]loss:1.3737898395806551

    [6,6000]loss:1.360704499706626

    [6,8000]loss:1.3652801268100738

    [6,10000]loss:1.334371616870165

    [6,12000]loss:1.312294240474701

    [7,2000]loss:1.3097571679353714

    [7,4000]loss:1.3236577164530754

    [7,6000]loss:1.310647354334593

    [7,8000]loss:1.3016219032108785

    [7,10000]loss:1.2931814943552018

    [7,12000]loss:1.2910259604007006

    [8,2000]loss:1.2796987656354903

    [8,4000]loss:1.2650054657310248

    [8,6000]loss:1.2713083022236824

    [8,8000]loss:1.258927255064249

    [8,10000]loss:1.275728213787079

    [8,12000]loss:1.2612977192252874

    [9,2000]loss:1.2273035216629504

    [9,4000]loss:1.25000972096622

    [9,6000]loss:1.2236297953873874

    [9,8000]loss:1.2251979489773512

    [9,10000]loss:1.2623697004914283

    [9,12000]loss:1.2501848887503146

    [10,2000]loss:1.2257770787626505

    [10,4000]loss:1.2277075409144163

    [10,6000]loss:1.2050671626776457

    [10,8000]loss:1.2159633481949568

    [10,10000]loss:1.210464821562171

    [10,12000]loss:1.2225491935014725

    五、测试网络

    5.1 打印误差曲线

    %matplotlib inline

    import matplotlib.pyplot as plt

    x = range(0, 60)

    plt.figure()

    plt.plot(x, average_loss_series)

    1

    2

    3

    4

    5

    6

    7%matplotlibinline

    importmatplotlib.pyplotasplt

    x=range(0,60)

    plt.figure()

    plt.plot(x,average_loss_series)

    5.2 查看训练的准确率

    我们使用测试集检验训练的神经网络的性能。

    def correct_rate(net, testloader):

    correct = 0

    total = 0

    for data in testloader:

    images, labels = data

    outputs = net(images)

    _, predicted = t.max(outputs.data, 1)

    total += labels.size(0)

    correct += (predicted==labels).sum()

    return 100*correct/total

    correct = correct_rate(net, testloader)

    print('10000张测试集中准确率为: {}%'.format(correct))

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15defcorrect_rate(net,testloader):

    correct=0

    total=0

    fordataintestloader:

    images,labels=data

    outputs=net(images)

    _,predicted=t.max(outputs.data,1)

    total+=labels.size(0)

    correct+=(predicted==labels).sum()

    return100*correct/total

    correct=correct_rate(net,testloader)

    print('10000张测试集中准确率为: {}%'.format(correct))

    运行结果

    10000张测试集中准确率为: 57%

    110000张测试集中准确率为:57%

    数据集一共有10种照片,且每种照片数量相等。所以理论上,我们猜测对每一张照片的概率为10%。

    而通过我们神经网络LeNet预测的准确率达到 57%,证明网络确实学习到了规律。

    文章来源:公众号大邓和他的Python

    本站微信群、QQ群(三群号 726282629):

    展开全文
  • 一维卷积nn.Conv1d一般来说,一维卷积nn.Conv1d用于文本数据,只对宽度进行卷积,对高度不卷积。通常,输入大小为word_embedding_dim * max_length,其中,word_embedding_dim为词向量维度,max_length为句子...

    本文主要介绍PyTorch中的nn.Conv1dnn.Conv2d方法,并给出相应代码示例,加深理解。

    e209279d594adf6fb764c4c7bdb78d38.png

    一维卷积nn.Conv1d

    一般来说,一维卷积nn.Conv1d用于文本数据,只对宽度进行卷积,对高度不卷积。通常,输入大小为word_embedding_dim * max_length,其中,word_embedding_dim为词向量的维度,max_length为句子的最大长度。卷积核窗口在句子长度的方向上滑动,进行卷积操作。

    定义

    class torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

    主要参数说明:

    • in_channels:在文本应用中,即为词向量的维度

    • out_channels:卷积产生的通道数,有多少个out_channels,就需要多少个一维卷积(也就是卷积核的数量)

    • kernel_size:卷积核的尺寸;卷积核的第二个维度由in_channels决定,所以实际上卷积核的大小为kernel_size * in_channels

    • padding:对输入的每一条边,补充0的层数

    代码示例

    输入:批大小为32,句子的最大长度为35,词向量维度为256
    目标:句子分类,共2类

    938e798659baa0a44351a52d71b56303.png

    假设window_size = [3, 4, 5, 6],即共有四个卷积核,基于上述代码,具体计算过程如下:

    1. 原始输入大小为(32, 35, 256),经过permute(0, 2, 1)操作后,输入的大小变为(32, 256, 35)

    2. 使用1个卷积核进行卷积,可得到1个大小为32 x 100 x 1的输出,共4个卷积核,故共有4个大小为32 x 100 x 1的输出;

    3. 将上一步得到的4个结果在dim = 1上进行拼接,输出大小为32 x 400 x 1

    4. view操作后,输出大小变为32 x 400

    5. 全连接,最终输出大小为32 x 2,即分别预测为2类的概率大小。

    一维卷积过程图解

    Yoon Kim在2014年发表的论文Convolutional Neural Networks for Sentence Classification中,给出了一个非常形象的图,诠释了文本卷积模型的框架,如下所示。

    29f5ed119cece89d177758928197508b.png

    nn.Conv1d详细图解(使用多个卷积核)

    二维卷积nn.Conv2d

    一般来说,二维卷积nn.Conv2d用于图像数据,对宽度和高度都进行卷积。

    定义

    class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

    代码示例

    假设现有大小为32 x 32的图片样本,输入样本的channels为1,该图片可能属于10个类中的某一类。CNN框架定义如下: 

    网络整体结构:[conv + relu + pooling] * 2 + FC * 3
    原始输入样本的大小:32 x 32 x 1

    1. 第一次卷积:使用6个大小为5 x 5的卷积核,故卷积核的规模为(5 x 5) x 6;卷积操作的stride参数默认值为1 x 1,32 - 5 + 1 = 28,并且使用ReLU对第一次卷积后的结果进行非线性处理,输出大小为28 x 28 x 6

    2. 第一次卷积后池化kernel_size2 x 2,输出大小变为14 x 14 x 6

    3. 第二次卷积:使用16个卷积核,故卷积核的规模为(5 x 5 x 6) x 16;使用ReLU对第二次卷积后的结果进行非线性处理,14 - 5 + 1 = 10,故输出大小为10 x 10 x 16

    4. 第二次卷积后池化kernel_size同样为2 x 2,输出大小变为5 x 5 x 16

    5. 第一次全连接:将上一步得到的结果铺平成一维向量形式,5 x 5 x 16 = 400,即输入大小为400 x 1,W大小为120 x 400,输出大小为120 x 1

    6. 第二次全连接,W大小为84 x 120,输入大小为120 x 1,输出大小为84 x 1

    7. 第三次全连接:W大小为10 x 84,输入大小为84 x 1,输出大小为10 x 1,即分别预测为10类的概率值。

    c6e7064d2575cf249cb93e183090d21a.png

    nn.Conv2d详细图解

    注意

    1. 在PyTorch中,池化操作默认的stride大小与卷积核的大小一致;

    2. 如果池化核的大小为一个方阵,则仅需要指明一个数,即kernel_size参数为常数n,表示池化核大小为n x n

    出处:

    作者:一只椰子啊嘻嘻嘻
    链接:https://www.jianshu.com/p/45a26d278473
    来源:简书
    著作权归作者所有。仅供交流学习。

    展开全文
  • Pytorch中二维卷积nn.Conv2d理解

    千次阅读 2019-09-07 16:40:13
    目录函数定义例子第卷积 函数定义 class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True) 例子 以MNIST数据集手写数字识别为例,网络定义...
  • PyTorch——多通道卷积

    2021-03-07 13:21:54
    由于输入和卷积核各有cic_{i}ci​个通道,我们可以在各个通道上对输入数组和卷积核数组做互相关运算,再将这cic_{i}ci​个互相关运算输出按通道相加,得到个二数组。这就是含多个通道
  • 以3通道100行200列的一幅图像img为例,期望输出16通道卷积特征,卷积核为3行3列,则 (1)函数调用: conv =nn.Conv2d(3, 16, 3) out = conv(img) 其中,nn.Conv2d函数中 第一个参数表示输入图像的通道数 第二个...
  • 公众号关注“Python遇见机器学习”设为“星标”,第时间知晓最新干货~作者丨史开杰来源丨GiantPandaCV本文重点介绍了Pytorch卷积的实现,并为实现过程中可能出现问题给出解决方案。文末列出了相关代码,读者可...
  • 互相关运算 二互相关(cross-correlation)运算输入是个二输入数组和个二维核(kernel)数组,输出也是个二数组,其中核数组通常称为卷积核或过滤器(filter)。卷积尺寸通...
  • 卷积神经网络基础我们介绍卷积神经网络卷积层和池化层,并解释填充、步幅、输入通道和输出通道含义。import torch from torch.autograd import Variable a=Variable(torch.FloatTensor([[2.,4.]]),requires_grad...
  • pytorch 卷积 分组卷积 及其深度卷积

    千次阅读 2018-11-15 20:49:05
    先来看看pytorch维卷积的操作API                                           现在继续讲讲几个卷积是如何操作. 普通卷积 torch.nn.Conv2d(in_channels, out...
  • 卷积层将输入和卷积核做互相关运算,并加上个标量偏置来得到输出。卷积层模型参数包括卷积核和标量偏置。 import torch import torch.nn as nn def corr2d(X, K): H, W = X.shape h, w = K.shape Y =
  • 时间序列数据通常出现在不同领域,如经济、商业、工程和许多其他领域,并且可以有不同应用。使用机器学习进行时间序列... CNN应用于时间序列代表即TCN,又被称为因果卷积。TCN与RNNs相比,具有如下优势: ...
  • ​概述在PyTorch中构建自己的卷积神经网络(CNN)的实践教程我们将研究一个图像分类问题——CNN的一个经典和广泛使用的应用我们将以实用的格式介绍深度学习概念介绍我被神经网络的力量和能力所吸引。在机器学习和深度...
  • pytorch的卷积与池化

    2021-02-08 09:44:58
    前言 使用pytorch搭建TextCNN时,需要使用卷积层与池化层,以下对pytorch卷积及池化层...一维卷积是指卷积核张量是一维,其调用形式为: torch.nn.Conv1d(in_channels: int, out_channels: int, kernel_size:
  • 维卷积解读及其pytorch实现

    千次阅读 2020-07-31 00:09:10
    实验表明三维卷积深度神经网络是种能够同时模拟外观和运动良好特征学习器。 发现3x3x3在探索架构中效果最好。 在4个不同任务和6个不同基准上,这个模型所学习特征优于或接近目前最好方法。 探索...
  • 代码实现地址,其中包含一维,二维,三维动态卷积;分别可以用于实现eeg处理,正常图像处理,医疗图像中三维脑部处理等等(水漫金山)。https://github.com/kaijieshi7/Dynamic-convolution-Pytorch,大家...
  • 互相关(cross-correlation)运算输入是个二输入数组和个二维核(kernel)数组,输出也是个二数组,其中核数组通常称为卷积核或过滤器(filter)。卷积尺寸通常小于输入数组,
  •  对一维信号,通常采取方法有两种,第一,直接对其做一维卷积,第二,反映到时频图像上,这就变成了图像识别,此前一直都在利用keras搭建网络,最近学了pytroch搭建cnn方法,进行一下代码尝试。所用数据为...
  • (1)卷积运算(二维卷积) 以下是pytorch官网上API 第种情况 如上图所示,输入图片为4*4,卷积核为3*3,步长为1,零填充。 代码表示: 第二种情况 如上图所示,输入图片为5*5,卷积核为4*4,...
  • 本章代码:...1D/2D/3D 卷积卷积有一维卷积、二维卷积、三维卷积。一般情况下,卷积核在几个维度上滑动,就是几维卷积。比如在图片上卷积就是二维卷...
  • 在网上找资料过程中,发现并没有特别细致讲解分类图像和分类一维向量做法,导致我捅咕了有几天才弄明白,可能使我比较菜吧......现在在这里记录一下。 首先需要明确,前文我们已经讲解了包装数据集方法,...
  • torch.nn.Conv1d及一维卷积详解

    万次阅读 多人点赞 2019-11-06 16:25:09
    近日在搞wavenet,期间遇到了一维卷积,在这里对一维卷积以及其pytorch中的API进行总结,方便下次使用 之前对二维卷积是比较熟悉的,在初次接触一维卷积...下边首先看一个简单的一维卷积的例子(batchsize是1,也只...
  • 在CNN中,有个重要操作成为卷积,尤其是在图像处理中使用最多,这里是对torch中nn模块维卷积的介绍。 torch.nn.Conv2d()函数详解 这里是个计算公式,是比较复杂计算公式,正常话输出形状为图像和...
  • 卷积神经网络基础 本节我们...二互相关运算 二互相关(cross-correlation)运算输入是个二输入数组和个二维核(kernel)数组,输出也是个二数组,其中核数组通常称为卷积核或过滤器(filter)。卷积...
  • 本文为大家讲解了pytorch实现CNN卷积神经网络,供大家参考,具体内容如下我对卷积神经网络一些认识卷积...对一维信号,通常采取方法有两种,第一,直接对其做一维卷积,第二,反映到时频图像上,这就变成了图像...
  • 首先定义个初始化函数 假如我们想使用 nn.Conv1d (像class TrainNet(nn.Module):这样...为我们所用, #网络初始化 ...#设置我们想要参数 ...#使用1维卷积 net(data) elif isinstance(m, nn.Conv1d): m.weight.dat...
  • 互相关(cross-correlation)运算输入是个二输入数组和个二维核(kernel)数组,输出也是个二数组,其中核数组通常称为卷积核或过滤器(filter)。卷积尺寸通常小于输入数组,卷积核在输入数组...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 198
精华内容 79
关键字:

pytorch的一维卷积