精华内容
下载资源
问答
  • 二维互相关运算 mport torch import torch.nn as nn def corr2d(X, K): H, W = X.shape h, w = K.shape Y = torch.zeros(H - h + 1, W - w + 1) for i in range(Y.shape[0]): for j in range(Y.shape[1]): ...
  • 卷积神经网络(ConvolutionalNeuralNetwork,CNN)最初是为解决图像识别等问题设计的,CNN现在的应用已经不限于图像和视频,也可用于时间序列信号,比如音频信号和文本数据等。CNN作为一个深度学习架构被提出的最初...
  • 主要为大家详细介绍了pytorch实现CNN卷积神经网络,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 卷积神经网路CNN 所有的伟大,源于一个勇敢的开始! 1.神经网络基础 1.1神经网络模型介绍 神经网络(Neural Networks,NN)是一种模仿人类神经元之间信息传递的数学算法模型。本节将介绍3种经典的神经网络模型结构,...

    卷积神经网路CNN

    所有的伟大,源于一个勇敢的开始!

    1.神经网络基础
    1.1神经网络模型介绍
    神经网络(Neural Networks,NN)是一种模仿人类神经元之间信息传递的数学算法模型。本节将介绍3种经典的神经网络模型结构,分别是M-P神经元模型、感知机模型和多层感知机模型。
    1.1.1 M-P神经元模型
    1943年,心理学家沃伦·麦卡洛克(Warren McCulloch)和数理逻辑学家沃尔特·皮兹(Walter Pitts)建立了神经网络的数学模型,称为M-P模型(以二人的名字命名,又称M-P神经元模型)。
    M-P神经元模型
    A)M-P模型的工作原理:
    (1)模型接受N个输入。(x1, x2, … , xn)
    (2)将输入与权值参数(w1j,w2j,…,2nj)进行加权求和并经过激活函数(非线性变换,如Relu函数)激活。
    (3)将激活结果作为结果输出(yi)。

    但是由于M-P模型缺乏学习机制,故以M-P模型为基础,学者们开发出了后来的感知机模型。

    1.1.2 感知机模型
    感知机(Perceptron)模型是由美国心理学家弗兰克·罗森布拉特(Frank Rosenblatt)于1957年提出的一种具有单层计算单元的神经网络。
    感知机模型
    它由两层神经元组成,输入层接收外界信号,输出层是许多个并列的M-P神经元,这些M-P神经元被称为处理单元或计算单元。相较于M-P神经元模型,感知机模型其实就是输入、输出两层神经元之间的简单全连接。

    A)Rosenblatt教授给出了感知机模型的学习机制,其过程可以概括如下。
    (1)对权值参数进行初始化
    (2)将训练集的一个输入值传递到输入层,通过感知机计算输出值(0或1)
    (3)比较感知机计算的输出值和真实的输出值是否相同,若输出值小于期望值,则向输出值更大的方向增加相应的权重;若输出值大于期望值,则向输出值更小的方向减少相应的权重。
    (4)对训练集中下一个输入值重复步骤(2)和步骤(3),直到感知机计算不再出错。

    感知机运行原理感知机输入到输出函数
    其中,w 和 x 为感知机模型参数,w叫做权值或权值向量(控制输入信号的重要性), b 叫偏置(调节神经元被激活的容易程度), Sign 是符号函数(激活函数),即
    sign函数
    在感知机中,只有两种输出,其中,0代表“不传递信号”,1代表“传递信号”。当输入信号被送往神经元时,分别乘以各自的权重,然后加总,如果总和超过阈值,则f(x)的输出为1,否则为0。

    1.1.3 多层感知机模型
    多层感知机模型(Multilayer Perceptron,MLP),就是在输入层和输出层之间加入了若干 隐藏层,以形成能够将样本正确分类的凸域,使得神经网络对非线性情况的拟合程度大大增强。
    多层感知机
    上图也被称为全连接神经网络,全连接是指神经网络模型中相邻两层单元之间的连接方式,使用全连接方式时,网络当前层的单元与网络上一层的每个单元都存在连接。

    A)在多层感知机中,信号的传递:
    (1)input层的3个神经元接收输入信号,并将信号发送至Hidden_layer1的神经元。
    (2)Hidden_layer1神经元将信号发送至Hidden_layer2神经元。
    (3)Hidden_layer2神经元将信号发送至output层神经元,然后output层神经元给出最后的输出。

    2. 从神经网络到卷积神经网络(CNN)
    从上面知道神经网络的结构是这样的:
    在这里插入图片描述
    那卷积神经网络跟它是什么关系呢?
    其实卷积神经网络依旧是层级网络,只是层的功能和形式做了变化,可以说是传统神经网络的一个改进。比如下图中就多了许多传统神经网络没有的层次。
    在这里插入图片描述
    卷积神经网络的层级结构
    • 数据输入层/ Input layer
      • 卷积计算层/ CONV layer
      • ReLU激励层 / ReLU layer
      • 池化层 / Pooling layer
      • 全连接层 / FC layer
    A)数据输入层
    该层要做的处理主要是对原始图像数据进行预处理,其中包括:
    • 去均值:把输入数据各个维度都中心化为0,如下图所示,其目的就是把样本的中心拉回到坐标系原点上。
    • 归一化:幅度归一化到同样的范围,如下所示,即减少各维度数据取值范围的差异而带来的干扰,比如,我们有两个维度的特征A和B,A范围是0到10,而B范围是0到10000,如果直接使用这两个特征是有问题的,好的做法就是归一化,即A和B的数据都变为0到1的范围。
    • PCA/白化:用PCA降维;白化是对数据各个特征轴上的幅度归一化
    B)卷积计算层
    在这个卷积层,有两个关键操作:
      • 局部关联。每个神经元看做一个滤波器(filter)
      • 窗口(receptive field)滑动, filter对局部数据计算
    先介绍卷积层遇到的几个名词:
      • 感受视野( local receptive fields)
      • 深度/depth(解释见下图)
      • 步长/stride (窗口一次滑动的长度)
      • 填充值/zero-padding
    • 卷积核
    • 共享权值(shared weights)

    a)感受视野( local receptive fields)
    即感受上一层的部分特征。在卷积神经网络中,隐藏层中的神经元的感受视野比较小,只能看到上一次的部分特征,上一层的其他特征可以通过平移感受视野来得到同一层的其他神经元。
    b)深度(depth)
    在这里插入图片描述
    c)步长(stride)
    感受视野对输入的扫描间隔称为步长(stride)
    d)填充值/zero-padding
    当步长比较大时(stride>1),为了扫描到边缘的一些特征,感受视野可能会“出界”,这时需要对边界扩充(pad)。
    以下图为例子,比如有这么一个55的图片(一个格子一个像素),我们滑动窗口取22,步长取2,那么我们发现还剩下1个像素没法滑完,那怎么办呢?
    在这里插入图片描述
    那我们在原先的矩阵加了一层填充值,使得变成66的矩阵,那么窗口就可以刚好把所有像素遍历完。这就是填充值的作用。
    在这里插入图片描述
    e)卷积核
    感受视野中的权重矩阵
    f)共享权值
    权值共享这个词说全了就是整张图片在使用同一个卷积核内的参数,比如一个3
    3*1的卷积核,这个卷积核内9个的参数被整张图共享,而不会因为图像内位置的不同而改变卷积核内的权系数。
    图像处理中的类似边缘检测,滤波操作等等都是在做全局共享。

    卷积的计算(注意,下面蓝色矩阵周围有一圈灰色的框,那些就是上面所说到的填充值)
    在这里插入图片描述
    蓝色的矩阵(输入图像)对粉色的矩阵(filter)进行矩阵内积计算并将三个内积运算的结果与偏置值b相加(比如上面图的计算:2+(-2+1-2)+(1-2-2) + 1= 2 - 3 - 3 + 1 = -3),计算后的值就是绿框矩阵的一个元素。
    在这里插入图片描述

    下面的动态图形象地展示了卷积层的计算过程:在这里插入图片描述
    C)激励层
    把卷积层输出结果做非线性映射。
    在这里插入图片描述
    CNN采用的激励函数一般为ReLU(The Rectified Linear Unit/修正线性单元),它的特点是收敛快,求梯度简单,但较脆弱,图像如下。
    Relu函数
    注释:
    三个常用激活函数:Sigmoid(经验说明尽量不要用)、tanh和Relu
    其他激活函数:leaky relu、elu、crelu、selu、relu6、softplus、softsign等

    D)池化层
    池化层夹在连续的卷积层中间, 用于压缩数据和参数的量,减小过拟合。
    简而言之,如果输入是图像的话,那么池化层的最主要作用就是压缩图像。
    池化
    池化层用的方法有Max pooling 和 average pooling,而实际用的较多的是Max pooling。
    Max pooling
    对于每个22的窗口选出最大的数作为输出矩阵的相应元素的值,比如输入矩阵第一个22窗口中最大的数是6,那么输出矩阵的第一个元素就是6,如此类推。

    average pooling,以上图为例,输入矩阵第4个2*2窗口中总和为8,均值为2,那么输出矩阵的第四个元素就是2,如此类推。

    E)全连接层
    两层之间所有神经元都有权重连接,通常全连接层在卷积神经网络尾部。也就是跟传统的神经网络神经元的连接方式是一样的:
    在这里插入图片描述
    一般CNN结构依次为
      1. INPUT
      2. [[CONV -> RELU]*N -> POOL?]*M
      3. [FC -> RELU]*K
      4. FC

    卷积神经网络之典型CNN
      • LeNet,这是最早用于数字识别的CNN
      • AlexNet, 2012 ILSVRC比赛远超第2名的CNN,比
      • LeNet更深,用多层小卷积层叠加替换单大卷积层。
      • ZF Net, 2013 ILSVRC比赛冠军
      • GoogLeNet, 2014 ILSVRC比赛冠军
      • VGGNet, 2014 ILSVRC比赛中的模型,图像识别略差于GoogLeNet,但是在很多图像转化学习问题(比如object detection)上效果奇好

    3. 总结
    卷积网络在本质上是一种输入到输出的映射,它能够学习大量的输入与输出之间的映射关系,而不需要任何输入和输出之间的精确的数学表达式,只要用已知的模式对卷积网络加以训练,网络就具有输入输出对之间的映射能力。

    参考博客:
    1.https://www.cnblogs.com/skyfsm/p/6790245.html
    2.https://blog.csdn.net/asialee_bird/article/details/80459163

    展开全文
  • pytorch搭建CNN卷积神经网络详解

    千次阅读 2020-04-06 16:15:08
    个人觉得应该先写卷积操作的常见技术和公式操作,才能对卷积输入维度(结果),输出维度(结果)有更直观的了解吧。 简单介绍一下卷积的常用trick: Padding Striding 下方是输入输出公式(本人开始也很困惑,...
    • 个人觉得应该先写卷积操作的常见技术和公式操作,才能对卷积输入维度(结果),输出维度(结果)有更直观的了解吧。

    • 简单介绍一下卷积的常用trick:

      • Padding
      • Striding
    • 下方是输入输出公式(本人开始也很困惑,找到对应公式后,就十分明朗了):

      n:原始输入的维度 | f:卷积核的大小 | p:padding的大小| s:stride的大小

      • no padding: n - f + 1
      • padding: n +2p - f + 1
      • stride with padding : n + 2 p − f s + 1 \frac{n+2 p-f}{s} + 1 sn+2pf+1 (该公式包含了上述两种情况)

    🌵 ​接下来以手写数字集为例,搭建一个CNN神经网络

    1.导入需要使用的包并下载MNIST数据集

    • MNIST数据集:
      • 训练集:图片60000张,每张像素(28, 28), 灰度图所以没有通道数
      • 测试集:图片10000张,每张像素(28, 28)
    import torch
    import torch.nn as nn
    import torch.utils.data as Data
    import torchvision
    import matplotlib.pyplot as plt
    
    torch.manual_seed(1)   # 为了每次的实验结果一致
    # 设置超参数
    epoches = 2
    batch_size = 50
    learning_rate = 0.001
    
    # 训练集
    train_data = torchvision.datasets.MNIST(
        root="./mnist/",  # 训练数据保存路径
        train=True,       # True为下载训练数据集,False为下载测试数据集
        transform=torchvision.transforms.ToTensor(),  # 数据范围已从(0-255)压缩到(0,1)
        download=False,  # 是否需要下载
    )
    # 显示训练集中的第一张图片
    print(train_data.train_data.size())   # [60000,28,28]
    plt.imshow(train_data.train_data[0].numpy())
    plt.show()
    
    # 测试集
    test_data = torchvision.datasets.MNIST(root="./mnist/", train=False)
    print(test_data.test_data.size())    # [10000, 28, 28]
    test_x = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)/255
    test_y = test_data.test_labels
    
    # 将训练数据装入Loader中
    train_loader = train_loader = Data.DataLoader(dataset=train_data, batch_size=batch_size, shuffle=True, num_workers=3)
    

    2. 搭建CNN神经网络 重点!

    class CNN(nn.Module):
        def __init__(self):
            super(CNN, self).__init__()   # 继承__init__功能
            ## 第一层卷积
            self.conv1 = nn.Sequential(
                # 输入[1,28,28]
                nn.Conv2d(
                    in_channels=1,    # 输入图片的高度
                    out_channels=16,  # 输出图片的高度
                    kernel_size=5,    # 5x5的卷积核,相当于过滤器
                    stride=1,         # 卷积核在图上滑动,每隔一个扫一次
                    padding=2,        # 给图外边补上0
                ),
                # 经过卷积层 输出[16,28,28] 传入池化层
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2)   # 经过池化 输出[16,14,14] 传入下一个卷积
            )
            ## 第二层卷积
            self.conv2 = nn.Sequential(
                nn.Conv2d(
                    in_channels=16,    # 同上
                    out_channels=32,
                    kernel_size=5,
                    stride=1,
                    padding=2
                ),
                # 经过卷积 输出[32, 14, 14] 传入池化层
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2)  # 经过池化 输出[32,7,7] 传入输出层
            )
            ## 输出层
            self.output = nn.Linear(in_features=32*7*7, out_features=10)
    
        def forward(self, x):
            x = self.conv1(x)
            x = self.conv2(x)           # [batch, 32,7,7]
            x = x.view(x.size(0), -1)   # 保留batch, 将后面的乘到一起 [batch, 32*7*7]
            output = self.output(x)     # 输出[50,10]
            return output
    

    3. 实现CNN

    def main():
        # cnn 实例化
        cnn = CNN()
        print(cnn)
    
        # 定义优化器和损失函数
        optimizer = torch.optim.Adam(cnn.parameters(), lr=learning_rate)
        loss_function = nn.CrossEntropyLoss()
    
        # 开始训练
        for epoch in range(epoches):
            print("进行第{}个epoch".format(epoch))
            for step, (batch_x, batch_y) in enumerate(train_loader):
                output = cnn(batch_x)  # batch_x=[50,1,28,28]
                loss = loss_function(output, batch_y)
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()
    			# 为了实时显示准确率
                if step % 50 == 0:
                    test_output = cnn(test_x)
                    pred_y = torch.max(test_output, 1)[1].data.numpy()
                    accuracy = ((pred_y == test_y.data.numpy()).astype(int).sum()) / float(test_y.size(0))
                    print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy(), '| test accuracy: %.2f' % accuracy)
    
    
        test_output = cnn(test_x[:10])
        pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
        print(pred_y)
        print(test_y[:10])
    
    if __name__ == "__main__":
        main()
    
    • 实时结果

    在这里插入图片描述

    • 跑完后结果(准确率很高)

    在这里插入图片描述

    完整代码:

    """
        作者:Troublemaker
        功能:
        版本:
        日期:2020/4/5 19:57
        脚本:cnn.py
    """
    import torch
    import torch.nn as nn
    import torch.utils.data as Data
    import torchvision
    import matplotlib.pyplot as plt
    
    torch.manual_seed(1)
    # 设置超参数
    epoches = 2
    batch_size = 50
    learning_rate = 0.001
    
    # 搭建CNN
    class CNN(nn.Module):
        def __init__(self):
            super(CNN, self).__init__()   # 继承__init__功能
            ## 第一层卷积
            self.conv1 = nn.Sequential(
                # 输入[1,28,28]
                nn.Conv2d(
                    in_channels=1,    # 输入图片的高度
                    out_channels=16,  # 输出图片的高度
                    kernel_size=5,    # 5x5的卷积核,相当于过滤器
                    stride=1,         # 卷积核在图上滑动,每隔一个扫一次
                    padding=2,        # 给图外边补上0
                ),
                # 经过卷积层 输出[16,28,28] 传入池化层
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2)   # 经过池化 输出[16,14,14] 传入下一个卷积
            )
            ## 第二层卷积
            self.conv2 = nn.Sequential(
                nn.Conv2d(
                    in_channels=16,    # 同上
                    out_channels=32,
                    kernel_size=5,
                    stride=1,
                    padding=2
                ),
                # 经过卷积 输出[32, 14, 14] 传入池化层
                nn.ReLU(),
                nn.MaxPool2d(kernel_size=2)  # 经过池化 输出[32,7,7] 传入输出层
            )
            ## 输出层
            self.output = nn.Linear(in_features=32*7*7, out_features=10)
    
        def forward(self, x):
            x = self.conv1(x)
            x = self.conv2(x)           # [batch, 32,7,7]
            x = x.view(x.size(0), -1)   # 保留batch, 将后面的乘到一起 [batch, 32*7*7]
            output = self.output(x)     # 输出[50,10]
            return output
    
    
    # 下载MNist数据集
    train_data = torchvision.datasets.MNIST(
        root="./mnist/",  # 训练数据保存路径
        train=True,
        transform=torchvision.transforms.ToTensor(),  # 数据范围已从(0-255)压缩到(0,1)
        download=False,  # 是否需要下载
    )
    # print(train_data.train_data.size())   # [60000,28,28]
    # print(train_data.train_labels.size())  # [60000]
    # plt.imshow(train_data.train_data[0].numpy())
    # plt.show()
    
    test_data = torchvision.datasets.MNIST(root="./mnist/", train=False)
    print(test_data.test_data.size())    # [10000, 28, 28]
    # print(test_data.test_labels.size())  # [10000, 28, 28]
    test_x = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)[:2000]/255
    test_y = test_data.test_labels[:2000]
    
    # 装入Loader中
    train_loader = Data.DataLoader(dataset=train_data, batch_size=batch_size, shuffle=True, num_workers=3)
    
    
    def main():
        # cnn 实例化
        cnn = CNN()
        print(cnn)
    
        # 定义优化器和损失函数
        optimizer = torch.optim.Adam(cnn.parameters(), lr=learning_rate)
        loss_function = nn.CrossEntropyLoss()
    
        # 开始训练
        for epoch in range(epoches):
            print("进行第{}个epoch".format(epoch))
            for step, (batch_x, batch_y) in enumerate(train_loader):
                output = cnn(batch_x)  # batch_x=[50,1,28,28]
                # output = output[0]
                loss = loss_function(output, batch_y)
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()
    
                if step % 50 == 0:
                    test_output = cnn(test_x)  # [10000 ,10]
                    pred_y = torch.max(test_output, 1)[1].data.numpy()
                    # accuracy = sum(pred_y==test_y)/test_y.size(0)
                    accuracy = ((pred_y == test_y.data.numpy()).astype(int).sum()) / float(test_y.size(0))
                    print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy(), '| test accuracy: %.2f' % accuracy)
    
    
        test_output = cnn(test_x[:10])
        pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
        print(pred_y)
        print(test_y[:10])
    
    if __name__ == "__main__":
        main()
    
    展开全文
  • 卷积神经网络基础 卷积神经网络包括卷积层和池化层。 二维卷积层 最常见的是二维卷积层,常用于处理图像数据。 二维互相关运算 二维互相关(cross-correlation)运算的输入是一个二维输入数组和一个二维核(kernel)...
  • 卷积函数:一般只用来改变输入数据的维度,例如3维到16维。 Conv2d() Conv2d(in_channels:int,out_channels:int,kernel_size:Union[int,tuple],stride=1,padding=o): """ :param in_channels: 输入的维...

    先说一个小知识,助于理解代码中各个层之间维度是怎么变换的。

    卷积函数:一般只用来改变输入数据的维度,例如3维到16维。

    Conv2d()

    Conv2d(in_channels:int,out_channels:int,kernel_size:Union[int,tuple],stride=1,padding=o):   
    """   
    :param in_channels: 输入的维度    
    :param out_channels: 通过卷积核之后,要输出的维度    
    :param kernel_size: 卷积核大小    
    :param stride: 移动步长    
    :param padding: 四周添多少个零  
    """

    一个小例子:

    import torch
    import torch.nn
    # 定义一个16张照片,每个照片3个通道,大小是28*28
    x= torch.randn(16,3,32,32)
    # 改变照片的维度,从3维升到16维,卷积核大小是5
    conv= torch.nn.Conv2d(3,16,kernel_size=5,stride=1,padding=0)
    res=conv(x)
    
    print(res.shape)
    # torch.Size([16, 16, 28, 28])
    # 维度升到16维,因为卷积核大小是5,步长是1,所以照片的大小缩小了,变成28

    卷积神经网络实战之ResNet18:

    下面放一个ResNet18的一个示意图,

    ResNet18主要是在层与层之间,加入了一个短接层,可以每隔k个层,进行一次短接。网络层的层数不是 越深就越好。
    ResNet18就是,如果在原先的基础上再加上k层,如果有小优化,则保留,如果比原先结果还差,那就利用短接层,直接跳过。

    ResNet18的构造如下:

    ResNet18(
      (conv1): Sequential(
        (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(3, 3))
        (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (blk1): ResBlk(
        (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (extra): Sequential(
          (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2))
          (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (blk2): ResBlk(
        (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (extra): Sequential(
          (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2))
          (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (blk3): ResBlk(
        (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (extra): Sequential(
          (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2))
          (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (blk4): ResBlk(
        (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (extra): Sequential()
      )
      (outlayer): Linear(in_features=512, out_features=10, bias=True)
    )

    程序运行前,先启动visdom,如果没有配置好visdom环境的,先百度安装好visdom环境

    • 1.使用快捷键win+r,在输入框输出cmd,然后在命令行窗口里输入python -m visdom.server,启动visdom

    代码实战

    定义一个名为resnet.py的文件,代码如下

    import torch
    from    torch import  nn
    from torch.nn import functional as F
    
    # 定义两个卷积层 + 一个短接层
    class ResBlk(nn.Module):
        def __init__(self,ch_in,ch_out,stride=1):
            super(ResBlk, self).__init__()
    
            # 两个卷积层
            self.conv1=nn.Conv2d(ch_in,ch_out,kernel_size=3,stride=stride,padding=1)
            self.bn1=nn.BatchNorm2d(ch_out)
            self.conv2=nn.Conv2d(ch_out,ch_out,kernel_size=3,stride=1,padding=1)
            self.bn2=nn.BatchNorm2d(ch_out)
    
            # 短接层
            self.extra=nn.Sequential()
            if ch_out != ch_in:
                self.extra=nn.Sequential(
                    nn.Conv2d(ch_in,ch_out,kernel_size=1,stride=stride),
                    nn.BatchNorm2d(ch_out)
                )
        def forward(self,x):
            """
            :param x: [b,ch,h,w]
            :return:
            """
            out=F.relu(self.bn1(self.conv1(x)))
            out=self.bn2(self.conv2(out))
    
            # 短接层
            # element-wise add: [b,ch_in,h,w]=>[b,ch_out,h,w]
            out=self.extra(x)+out
            return out
    
    class ResNet18(nn.Module):
        def __init__(self):
            super(ResNet18, self).__init__()
    
            # 定义预处理层
            self.conv1=nn.Sequential(
                nn.Conv2d(3,64,kernel_size=3,stride=3,padding=0),
                nn.BatchNorm2d(64)
            )
    
            # 定义堆叠ResBlock层
            # followed 4 blocks
            # [b,64,h,w]-->[b,128,h,w]
            self.blk1=ResBlk(64,128,stride=2)
            # [b,128,h,w]-->[b,256,h,w]
            self.blk2=ResBlk(128,256,stride=2)
            # [b,256,h,w]-->[b,512,h,w]
            self.blk3=ResBlk(256,512,stride=2)
            # [b,512,h,w]-->[b,512,h,w]
            self.blk4=ResBlk(512,512,stride=2)
    
            # 定义全连接层
            self.outlayer=nn.Linear(512,10)
    
        def forward(self,x):
            """
            :param x:
            :return:
            """
            # 1.预处理层
            x=F.relu(self.conv1(x))
    
            # 2. 堆叠ResBlock层:channel会慢慢的增加,  长和宽会慢慢的减少
            # [b,64,h,w]-->[b,512,h,w]
            x=self.blk1(x)
            x=self.blk2(x)
            x=self.blk3(x)
            x=self.blk4(x)
    
            # print("after conv:",x.shape) # [b,512,2,2]
            # 不管原先什么后面两个维度是多少,都化成[1,1],
            # [b,512,1,1]
            x=F.adaptive_avg_pool2d(x,[1,1])
            # print("after pool2d:",x.shape) # [b,512,1,1]
    
            # 将[b,512,1,1]打平成[b,512*1*1]
            x=x.view(x.size(0),-1)
    
            # 3.放到全连接层,进行打平
            # [b,512]-->[b,10]
            x=self.outlayer(x)
    
            return x
    def main():
        blk=ResBlk(64,128,stride=2)
        temp=torch.randn(2,64,32,32)
        out=blk(temp)
        # print('block:',out.shape)
    
        x=torch.randn(2,3,32,32)
        model=ResNet()
        out=model(x)
        # print("resnet:",out.shape)
    
    if __name__ == '__main__':
        main()

    定义一个名为main.py的文件,代码如下

    import torch
    from torchvision import datasets
    from torchvision import transforms
    from torch.utils.data import DataLoader
    from torch import nn,optim
    from visdom import Visdom
    # from lenet5 import  Lenet5
    from resnet import ResNet18
    import time
    
    def main():
        batch_siz=32
        cifar_train = datasets.CIFAR10('cifar',True,transform=transforms.Compose([
            transforms.Resize((32,32)),
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                 std=[0.229, 0.224, 0.225])
        ]),download=True)
        cifar_train=DataLoader(cifar_train,batch_size=batch_siz,shuffle=True)
    
        cifar_test = datasets.CIFAR10('cifar',False,transform=transforms.Compose([
            transforms.Resize((32,32)),
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                 std=[0.229, 0.224, 0.225])
        ]),download=True)
        cifar_test=DataLoader(cifar_test,batch_size=batch_siz,shuffle=True)
    
        x,label = iter(cifar_train).next()
        print('x:',x.shape,'label:',label.shape)
    
        # 指定运行到cpu //GPU
        device=torch.device('cpu')
        # model = Lenet5().to(device)
        model = ResNet18().to(device)
    
        # 调用损失函数use Cross Entropy loss交叉熵
        # 分类问题使用CrossEntropyLoss比MSELoss更合适
        criteon = nn.CrossEntropyLoss().to(device)
        # 定义一个优化器
        optimizer=optim.Adam(model.parameters(),lr=1e-3)
        print(model)
    
        viz=Visdom()
        viz.line([0.],[0.],win="loss",opts=dict(title='Lenet5 Loss'))
        viz.line([0.],[0.],win="acc",opts=dict(title='Lenet5 Acc'))
    
        # 训练train
        for epoch in range(1000):
            # 变成train模式
            model.train()
            # barchidx:下标,x:[b,3,32,32],label:[b]
            str_time=time.time()
            for barchidx,(x,label) in enumerate(cifar_train):
                # 将x,label放在gpu上
                x,label=x.to(device),label.to(device)
                # logits:[b,10]
                # label:[b]
                logits = model(x)
                loss = criteon(logits,label)
    
                # viz.line([loss.item()],[barchidx],win='loss',update='append')
                # backprop
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()
                # print(barchidx)
            end_time=time.time()
            print('第 {} 次训练用时: {}'.format(epoch,(end_time-str_time)))
            viz.line([loss.item()],[epoch],win='loss',update='append')
            print(epoch,'loss:',loss.item())
    
    
            # 变成测试模式
            model.eval()
            with torch.no_grad():
                #  测试test
                # 正确的数目
                total_correct=0
                total_num=0
                for x,label in cifar_test:
                    # 将x,label放在gpu上
                    x,label=x.to(device),label.to(device)
                    # [b,10]
                    logits=model(x)
                    # [b]
                    pred=logits.argmax(dim=1)
                    # [b] = [b'] 统计相等个数
                    total_correct+=pred.eq(label).float().sum().item()
                    total_num+=x.size(0)
                acc=total_correct/total_num
                print(epoch,'acc:',acc)
                print("------------------------------")
    
                viz.line([acc],[epoch],win='acc',update='append')
                # viz.images(x.view(-1, 3, 32, 32), win='x')
    
    
    if __name__ == '__main__':
        main()

    测试结果

    ResNet跑起来太费劲了,需要用GPU跑,但是我的电脑不支持GPU,头都大了,用cpu跑二十多分钟学习一次,头都大了。

    展开全文
  • 卷积神经网络pytorch 介绍 (Introduction) PyTorch is a deep learning framework developed by Facebook’s AI Research lab (FAIR). Thanks to its C++ and CUDA backend, the N-dimensional arrays called ...

    卷积神经网络pytorch

    介绍 (Introduction)

    PyTorch is a deep learning framework developed by Facebook’s AI Research lab (FAIR). Thanks to its C++ and CUDA backend, the N-dimensional arrays called Tensors can be used in GPU as well.

    PyTorch是由Facebook的AI研究实验室(FAIR)开发的深度学习框架。 由于其C ++和CUDA后端,称为Tensors的N维数组也可以在GPU中使用。

    A Convolutional Neural Network (ConvNet/CNN) is a Deep Learning which takes an input image and assigns importance(weights and biases) to various features to help in distinguishing images.

    卷积神经网络(ConvNet / CNN)是一种深度学习,它接受输入图像并为各种功能分配重要性(权重和偏差),以帮助区分图像。

    Image for post
    Image by Author
    图片作者

    A Neural Network is broadly classified into 3 layers:

    神经网络大致分为三层:

    • Input Layer

      输入层
    • Hidden Layer (can consist of one or more such layers)

      隐藏层(可以包含一个或多个这样的层)
    • Output Layer

      输出层

    The Hidden layer can be further divided mainly into 2 layers-

    隐藏层主要可以进一步分为2层-

    • Convolution Layer: this extracts features from the given input images.

      卷积层:这将从给定的输入图像中提取特征。
    • Full Connected Dense Layers: it assigns importance to the features from the convolution layer to generate output.

      完全连接的密集层:它赋予卷积层要素以生成输出的重要性。

    A convolutional neural network process generally involves two steps-

    卷积神经网络过程通常包括两个步骤:

    • Forward Propagation: the weights and biases are randomly initialized and this generates the output at the end.

      正向传播:权重和偏差被随机初始化,并最终生成输出。
    • Back Propagation: the weights and biases are randomly initialized in the beginning and depending on the error, the values are updated. Forward propagation happens with these updated values again and again for newer outputs to minimize the error.+

      反向传播:权重和偏差在开始时就随机初始化,并根据误差来更新值。 对于这些更新的值,一次又一次地进行正向传播,以使更新的输出最小化误差。
    Image for post
    Photo by Fotis Fotopoulos on Unsplash
    Fotis Fotopoulos Unsplash

    Activation functions are mathematical equations assigned to each neuron in the neural network and determine whether it should be activated or not depending on its importance(weight) in the image.

    激活函数是分配给神经网络中每个神经元的数学方程式,并根据其在图像中的重要性(权重)确定是否应激活它。

    There are two types of activation functions:

    有两种类型的激活功能:

    • Linear Activation Functions: It takes the inputs, multiplied by the weights for each neuron, and creates an output signal proportional to the input. However, the problem with Linear Activation Functions is that it gives the output as a constant thus making it impossible for backpropagation to be used as there is no relation to the input. Further, it collapses all layers into a single layer thus turning the neural network into a single layer network.

      线性激活函数:它采用输入乘以每个神经元的权重,并生成与输入成比例的输出信号。 但是,线性激活函数的问题在于,它以恒定的形式给出输出,因此由于与输入无关,因此无法使用反向传播。 此外,它将所有层折叠成单层,从而将神经网络变成单层网络。
    • Non-Linear Activation Functions: These create complex mappings between the different layers which help in better learning modelling of data. Few of the non-linear activation functions are - sigmoid, tanh, softmax, ReLU (Rectified Linear Units), Leaky ReLU etc.

      非线性激活功能:这些功能在不同层之间创建复杂的映射,有助于更好地学习数据建模。 很少有非线性激活函数-S型,tanh,softmax,ReLU(整流线性单位),泄漏ReLU等。

    Enough theory, let’s get started.

    足够的理论,让我们开始吧。

    Github (Github)

    If you are familiar with Github, check out my repository for the code and dataset.

    如果您熟悉Github,请查看我的存储库中的代码和数据集。

    Image for post
    Photo by Chris Ried on Unsplash
    克里斯·里德 ( Chris Ried)Unsplash

    数据集 (Dataset)

    To train a model, the first order of business is to find a dataset. For the project, the dataset used is a modified version of the original dataset from Kaggle:

    要训​​练模型,首先要找到数据集。 对于项目,使用的数据集是Kaggle原始数据集的修改版本:

    Original dataset: https://www.kaggle.com/c/swdl2020/overview

    原始数据集: https : //www.kaggle.com/c/swdl2020/overview

    Customized dataset: https://drive.google.com/file/d/1KRqqs2hi2KagfGAcTdWQPQUZO6RX2VE6/view?usp=sharing

    自定义数据集: https : //drive.google.com/file/d/1KRqqs2hi2KagfGAcTdWQPQUZO6RX2VE6/view?usp=sharing

    There are 3 classes in the dataset corresponding to the three animals: Tiger, Hyena and Cheetah.

    数据集中有3个类别,分别对应于以下三种动物:老虎,鬣狗和猎豹。

    Image for post
    Image by author
    图片作者

    The dataset has already been divided into 2 folders namely training and validation. The training folder contains 2700 images — 900 each in separate folders and validation folder contains 300 images — 100 each in separate folders corresponding to each animal.

    数据集已经分为两个文件夹,即训练和验证。 训练文件夹包含2700张图像-在单独的文件夹中分别包含900张图像,而验证文件夹包含300张图像-在与每个动物相对应的单独文件夹中包含100张图像。

    导入库 (Importing the Libraries)

    If you have not yet installed the PyTorch library you use the following commands:

    如果尚未安装PyTorch库,请使用以下命令:

    If you are running on Anaconda, then once you are on the virtual environment, run the command-

    如果您在Anaconda上运行,那么在虚拟环境中后,请运行命令-

    conda install pytorch torchvision cudatoolkit=10.1 -c pytorch

    If you want to locally install it using pip, the following command will open a wheel file for download-

    如果您想使用pip在本地安装,则以下命令将打开一个wheel文件供下载-

    pip install torch==1.5.0+cu101 torchvision==0.6.0+cu101 -f

    了解数据集 (Understanding the Dataset)

    Once we have imported the required libraries, let’s import the dataset and understand it.

    导入所需的库后,让我们导入数据集并了解它。

    As we can see, there are a total of 3 classes, each representing a particular animal. data_dir is the path where the dataset is stored. If working in an online environment, then the dataset needs to be either uploaded onto the environment locally or saved onto the drive as in case of Google Colab. If you are working on a local environment, then insert your local dataset path here.

    如我们所见,总共有3个类别,每个类别代表一种特定的动物。 data_dir是数据集的存储路径。 如果在在线环境中工作,则数据集需要要么上载到本地环境中,要么像Google Colab一样保存到驱动器中。 如果您在本地环境中工作,请在此处插入本地数据集路径。

    Now let's convert the dataset into an N-Dimensional Tensor.

    现在,让我们将数据集转换为N维张量。

    Now the variable dataset is a tensor containing all the images for training. As stated, the size of the dataset is 2700.

    现在变量数据集是一个张量,其中包含所有要训练的图像。 如前所述,数据集的大小为2700。

    We shall now use the validation folder as the testing folder. The size of the test dataset is 300.

    现在,我们将使用验证文件夹作为测试文件夹。 测试数据集的大小为300。

    Now let’s check the dataset.

    现在让我们检查数据集。

    Each image is of the shape 3x400x400 indication 400x400 as the image dimensions and 3 denoted the colour channels RGB.

    每个图像的形状均为3x400x400,表示图像尺寸为400x400,3表示颜色通道RGB。

    Let us now display a few of the images in the dataset.

    现在让我们显示数据集中的一些图像。

    准备训练数据集 (Preparing the Dataset for Training)

    We shall now split the training set into two for training and validation.

    现在,我们将训练集分为两部分进行训练和验证。

    For this, we will use the random_split() function.

    为此,我们将使用random_split()函数。

    Let’s keep the batch size at 32 and load the data.

    让我们将批处理大小保持为32并加载数据。

    Let's look at the batch.

    让我们看看批处理。

    Now that we have finished with the preparations, let’s move onto the model.

    现在我们已经完成了准备工作,让我们进入模型。

    建立模型 (Building the Model)

    Over here, we use cross_entropy or log loss as the loss function. In the case of multiclass classification, the cross_entropy formula is:

    在这里,我们使用cross_entropy或log loss作为损失函数。 对于多类分类,cross_entropy公式为:

    Image for post

    Now let's check if a GPU is available and use it if available.

    现在,让我们检查GPU是否可用,如果可用,请使用它。

    GPU has been selected now. If ‘cuda’ is not available, then do check your settings if you working locally. If you are working on Kaggle, then ensure no other GPU sessions are active and that you haven’t used up the free monthly quota of 30 hours.

    现在已选择GPU。 如果“ cuda”不可用,请在本地工作时检查设置。 如果您使用的是Kaggle,请确保没有其他GPU会话处于活动状态,并且没有用完30个小时的免费每月配额。

    We shall now define the layers of the convolution network.

    现在我们将定义卷积网络的层。

    We have defined 3 hidden layers. For the activation function, we are using ReLU (Rectified Linear Units).

    我们定义了3个隐藏层。 对于激活功能,我们使用ReLU(整流线性单位)。

    Now that we have built a basic model, let’s try to fit it with various learning rates and epochs and check the accuracy.

    现在,我们已经建立了基本模型,让我们尝试将其与各种学习率和时期相适应,并检查准确性。

    Let us now analyze the model.

    现在让我们分析模型。

    And let us finally evaluate the model.

    最后让我们评估模型。

    As you can see, the accuracy is very low at just around 50.9%. This is because we haven’t added any convolution layers to the model yet.

    如您所见,准确性非常低,仅为50.9%。 这是因为我们尚未在模型中添加任何卷积层。

    Image for post
    Photo by Joshua Sortino on Unsplash
    Joshua SortinoUnsplash拍摄的照片

    Let us now build the convolution layers using Resnet-18.

    现在让我们使用Resnet-18构建卷积层。

    Resnet or Residual Network is a convolutional neural network having the powerful representational ability that makes it possible to train up to hundreds or even thousands of layers and still achieves compelling performance. We are going to use Resnet-18 which indicates the network is 18 layers deep.

    Resnet或残差网络是一种卷积神经网络,具有强大的表示能力,可以训练多达数百甚至数千个层,并且仍可实现出色的性能。 我们将使用Resnet-18,它指示网络深18层。

    Let us now define the convolution layers.

    现在让我们定义卷积层。

    We shall now use a pre-trained Resnet-18 model.

    现在,我们将使用预先训练的Resnet-18模型。

    Let us now see the output shape.

    现在让我们看一下输出形状。

    Check if GPU is available and assign it as the device.

    检查GPU是否可用并将其分配为设备。

    Confirm that the device type is GPU.

    确认设备类型为GPU。

    Load the data for training and testing.

    加载数据以进行培训和测试。

    Assign the model.

    分配模型。

    Let us now check the initial loss and accuracy.

    现在让我们检查初始损失和准确性。

    The accuracy initially is at 35%. Let us now set the hyperparameters and starting training the model.

    最初的精度为35%。 现在让我们设置超参数并开始训练模型。

    Opt_func stands for Optimizer Function. They tie together the loss function and model parameters by updating the model in response to the output of the loss function. The function that we are going to use is Adam optimizer. Adam is an optimization algorithm that can be used instead of the classical stochastic gradient descent procedure to update network weights iterative based in training data. It realizes the benefits of both AdaGrad(Adaptive Gradient Algorithm) and RMSProp(Root Mean Square Propagation).

    Opt_func代表优化器功能。 通过响应于损失函数的输出来更新模型,他们将损失函数和模型参数联系在一起。 我们将要使用的功能是Adam优化器。 亚当(Adam)是一种优化算法,可以代替经典的随机梯度下降过程来基于训练数据更新网络权重迭代。 它同时实现了AdaGrad(自适应梯度算法)和RMSProp(均方根传播)的好处。

    Let us now analyze the model.

    现在让我们分析模型。

    And now, let us finally evaluate the model.

    现在,让我们最终评估模型。

    分析 (Analysis)

    As we can see, the application of Convolution layers helped increase the accuracy to 89.5%. The accuracy can further be increased by having a larger training dataset and by further tuning the hyperparameters.

    如我们所见,卷积图层的应用有助于将准确性提高到89.5%。 通过拥有更大的训练数据集并进一步调整超参数,可以进一步提高准确性。

    结论 (Conclusion)

    We have successfully built a Convolutional Neural Network model to classify zoo animals. There are quite a lot of similar classification datasets that one can get acquainted with to get familiarized with Convolution Neural Network, PyTorch and other concepts.

    我们已经成功建立了卷积神经网络模型来对动物园动物进行分类。 您可以熟悉很多相似的分类数据集,以熟悉卷积神经网络,PyTorch和其他概念。

    Image for post
    Photo by Tincho Franco on Unsplash
    Tincho FrancoUnsplash拍摄的照片

    翻译自: https://towardsdatascience.com/animal-classification-using-pytorch-and-convolutional-neural-networks-78f2c97ca160

    卷积神经网络pytorch

    展开全文
  • """---------------------cnn卷积神经网络---------------------""" import torch from torch import nn, optim import torch.nn.functional as F from torch.autograd import Variable from torch.utils.data ...
  • CNN卷积神经网络实例(基于pytorch)

    千次阅读 多人点赞 2020-06-06 20:56:45
    CNN卷积神经网络1.关于卷积神经网络2.卷积神经网络实例(手写字母识别)2.1 代码示例2.2 运行过程及结果2.3 测试结果3.参考与致谢 1.关于卷积神经网络 卷积神经网络(Convolutional Neural Network,CNN) 是一种具有...
  • 该存储库包含许多在PyTorch中实现的卷积神经网络可视化技术。 注意:我删除了cv2依赖性并将存储库移至PIL。 有些事情可能会坏掉(尽管我测试了所有方法),如果在某些情况下无法解决问题,可以提出问题,我将不胜...
  • 卷积神经网络CNN--PyTorch实现

    千次阅读 2020-02-02 19:55:16
      在我看来,卷积神经网络对图像处理的过程就是:①先将图像读入程序,得到图像的每个像素点的每个颜色通道的值。本篇博客是使用MNIST数据集,是28 ×\times× 28的图像,并且使用单颜色通道。然后将读入的图像...
  • 本文使用Pytorch实现卷积神经网络CNN,仅为Pytorch新入坑者提供帮助,避免入门到放弃; 数据集为MNIST如文中代码所示; 最后,恭喜各位入坑,在调参的路上越走越远! import torch from torch.autograd import ...
  • #4.1_CNN_卷积神经网络_(PyTorch_tutorial_神经网络_教学)
  • 把薄书读厚,把经典例子嚼碎吃透 pytorch-CNN经典案例拆解
  • 卷积神经网络CNN入门【pytorch学习】

    千次阅读 2018-11-10 01:36:53
    在学习GANs的时候遇到一篇论文DCGANs,说是其中用到了卷积神经网络。 所以,就抽空学习一下,结果,真没想到有那么多的坑。 文章目录简述数据配置配套的代码段参数设置训练集批处理构建测试集构建CNN框架训练测试...
  • MeshCNN是用于3D三角形网格的通用深度神经网络,可用于诸如3D形状分类或分割之类的任务。 该框架包括直接应用于网格边缘的卷积,池化和解池层。 该代码由和在支持下编写。 入门 安装 克隆此仓库: git clone ...
  • Pytorch实现CNN卷积神经网络

    万次阅读 2017-08-02 15:08:38
    Pytorch实现CNN卷积神经网络
  • PyTorch入门实战教程笔记(十九):卷积神经网络CNN 1 什么是卷积 卷积神经网络基本概念 对于神经网络有几层,第一层为输入层,是不计算在内的,下图有3个隐藏层1个输出层,所以是4层的神经网络。每一层包含输入它...
  • PyTorch入门实战教程笔记(二十):卷积神经网络CNN 2 Batch Norm 详细相关论文解读可参考:Batch Normalization(BN层)网络详解,下面我们简要的分析一下,比如我们使用Sigmoid函数时,如果数据过小或者过大会出现...
  • 上文聚焦于源码和论文,对于各种卷积神经网络模型的实现,本文将介绍它们的 PyTorch 实现,非常有用! 这份资源已经开源在了 GitHub 上,链接如下: https://github.com/shanglianlm0525/PyTorch-Networks 先来个...
  • # 打印神经网络的结构(net architecture) # 优化 optimizer = torch.optim.Adam(cnn.parameters(),lr=LR) # 用Adam优化器优化cnn网络所有参数(optimizer all cnn parameters) loss_func = nn.CrossEntropyLoss() # ...
  • 基于pytorch框架,采用CNN实现Mnist数据集,该示例训练,相当于语言编程界的“hello world”入门程序。 文章目录前言一、Mnist数据模型简介二、使用步骤1.引入库2.读入数据总结 前言 基于pytorch框架实现Mnist数据...
  • 我们介绍了带变分推理的贝叶斯卷积神经网络,这是卷积神经网络CNN)的一种变体,其中权重的难处理的后验概率分布是由Backprop的Bayes推断的。 我们证明我们提出的变分推断方法是如何实现的性能相当于频率论推理在...
  • pytorch卷积神经网络

    2021-03-19 16:19:25
    即参数kernel_size, string, padding, dilation 也可以是一个int的数据,此时卷积height和weight的数值相同;也可以是一个tuple数组,tuple的第一维表示height的数值,tuple的第二维表示width的数值。 Hout和Wout...
  • Pytorch——回归问题

    2020-12-22 05:48:56
    我会这次会来见证神经网络是如何通过简单的形式将一群数据用一条线条来表示. 或者说, 是如何在数据当中找到他们的关系, 然后用神经网络模型来建立一个可以代表他们关系的线条. 2.数据准备 我们创建一些假数据来模拟...
  • 本篇文章主要介绍了PyTorch上实现卷积神经网络CNN的方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧 一、卷积神经网络 卷积神经网络(ConvolutionalNeuralNetwork,CNN)最初是...
  • Pytorch实现MNIST手写数字识别(全连接神经网络及卷积神经网络)-附件资源

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,115
精华内容 4,046
关键字:

cnn卷积神经网络pytorch