1. Toy模板网首页
  2. > Toy博客

卷积神经网络——上篇【深度学习】【PyTorch】【d2l】

7月前 作者：来杯Sherry 分类：Toy博客 阅读(28) 违法举报

这篇具有很好参考价值的文章主要介绍了卷积神经网络——上篇【深度学习】【PyTorch】【d2l】。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

5、卷积神经网络

5.1、卷积

5.1.1、理论部分

全连接层后，卷积层出现的意义？

一个足够充分的照片数据集，输入，全连接层参数，GPU成本，训练时间是巨大的。

（convolutional neural networks，CNN）是机器学习利用自然图像中一些已知结构的创造性方法，需要更少的参数，在处理图像和其他类型的结构化数据上各类成本，效果，可行性普遍优于全连接层。

卷积层做了什么？

将输入和核矩阵进行互相关运算，加上偏移后得到输出。

图片中找模式的原则

  • 平移不变性
  • 局部性

对全连接层使用如上原则得到卷积层。

（详细待补充）

二维卷积层

卷积神经网络——上篇【深度学习】【PyTorch】【d2l】,深度学习,Python,深度学习,cnn,pytorch

Y = X ★ W + b Y = X ★ W + b Y=X★W+b

  • 输入 X X X： n h × n w n_h × n_w nh​×nw​

    图中，h：高、w：宽、输入大小 n = 3。

  • 核 W W W： k h × k w k_h × k_w kh​×kw​

    图中，卷积核大小 k = 2，超参数。

  • 偏差 b∈ R

  • 输出 Y Y Y： （ n h − k h + 1 ） × （ n w − k w + 1 ） （ n_h - k_h + 1）×（n_w - k_w + 1） （nh​−kh​+1）×（nw​−kw​+1）

    图中 （3-2 +1）*（3-2 +1） = 4 ，计算的是 Y 的形状。

  • ★：二维交叉操作子 | 外积

  • W 和 b是可学习的参数

卷积效果举例

卷积神经网络——上篇【深度学习】【PyTorch】【d2l】,深度学习,Python,深度学习,cnn,pytorch

5.1.2、代码实现

（1）实现互相关运算

卷积运算 ≠ 互相关运算

卷积运算：在卷积运算中，核心（也称为滤波器）在进行滑动时，会被翻转（180度旋转）后与输入数据进行逐元素相乘，并将乘积求和作为输出。这意味着核心的权重是翻转的。在卷积运算中，处理核心的边界像素会被覆盖，所以输出的大小通常会小于输入的大小。

互相关运算：在互相关运算中，核心与输入数据进行逐元素相乘，并将乘积求和作为输出，但核心不进行翻转。互相关运算不会覆盖核心的边界像素，所以输出的大小与输入的大小通常是一致的。

在深度学习中，人们通常使用卷积运算的术语来描述这种操作，尽管实际实现可能使用了互相关运算。卷积运算和互相关运算在数学上的操作相似，但在处理核心边界像素时存在微小的差异。在实际深度学习应用中，这两个术语通常可以互换使用。

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

def corr2d(X, K):  #@save
    """计算二维互相关运算"""
    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

验证运算结果

X = torch.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]])
K = torch.tensor([[0.0, 1.0], [2.0, 3.0]])
corr2d(X, K)

result：

tensor([[19., 25.],
     [37., 43.]])

实现二维卷积层

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

（2）学习由X生成Y卷积核

#一个输入通道、一个输出通道，不使用偏置
conv2d = nn.Conv2d(1,1,kernel_size=(1,2),bias =False)

X = X.reshape((1,1,6,8))
Y = Y.reshape((1,1,6,7))

for i in range(10):
    Y_hat = conv2d(X)
    l = (Y_hat - Y) **2
    conv2d.zero_grad()
    l.sum().backward()
    conv2d.weight.data[:] -=3e-2 * conv2d.weight.grad
    if(i + 1)% 2 == 0:
        print(f'batch{i + 1}, loss {l.sum():.3f}')

所学卷积核权重

conv2d.weight.data.reshape((1,2))

tensor([[ 1.0084, -0.9816]])

5.1.3、边缘检测

利用卷积层检测 图像中的不同边缘

输入

X = torch.ones((6,8))
X[:, 2:6]  =0
X

tensor([[1., 1., 0., 0., 0., 0., 1., 1.],
     [1., 1., 0., 0., 0., 0., 1., 1.],
     [1., 1., 0., 0., 0., 0., 1., 1.],
     [1., 1., 0., 0., 0., 0., 1., 1.],
     [1., 1., 0., 0., 0., 0., 1., 1.],
     [1., 1., 0., 0., 0., 0., 1., 1.]])

核矩阵

K = torch.tensor([[1,-1]])

输出

Y  = corr2d(X,K)
Y

tensor([[ 0.,  1.,  0.,  0.,  0., -1.,  0.],
     [ 0.,  1.,  0.,  0.,  0., -1.,  0.],
     [ 0.,  1.,  0.,  0.,  0., -1.,  0.],
     [ 0.,  1.,  0.,  0.,  0., -1.,  0.],
     [ 0.,  1.,  0.,  0.,  0., -1.,  0.],
     [ 0.,  1.,  0.,  0.,  0., -1.,  0.]])

只能检测垂直边缘

Y  = corr2d(X.t(),K)
Y

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

将核矩阵一起转置

Y  = corr2d(X.t(),K.t())
Y

水平边缘检测可行。

tensor([[ 0.,  0.,  0.,  0.,  0.,  0.],
     [ 1.,  1.,  1.,  1.,  1.,  1.],
     [ 0.,  0.,  0.,  0.,  0.,  0.],
     [ 0.,  0.,  0.,  0.,  0.,  0.],
     [ 0.,  0.,  0.,  0.,  0.,  0.],
     [-1., -1., -1., -1., -1., -1.],
     [ 0.,  0.,  0.,  0.,  0.,  0.]])

5.2、填充和步幅

5.2.1、理论部分

填充操作

更大的卷积核可以更快地减小输出大小。

如果不想结果太小，也可以通过填充实现输出更大尺寸的X，实现控制输出形状的减少量。

卷积神经网络——上篇【深度学习】【PyTorch】【d2l】,深度学习,Python,深度学习,cnn,pytorch

填充 p h p_h ph​行 p w p_w pw​列，输出形状：

（ n h − k h + p h + 1 ） × （ n w − k w + p w + 1 ） （n_h -k_h +p_h +1）×（n_w - k_w + p_w +1） （nh​−kh​+ph​+1）×（nw​−kw​+pw​+1）

填充的是外围的一层：上下各填充 p h p_h ph​，宽度填充同理。

在卷积层代码中有个参数叫做padding= ，假设padding=p，代入上述公式：

（ n h − k h + p ∗ 2 + 1 ） × （ n w − k w + p ∗ 2 + 1 ） （n_h -k_h +p*2 +1）×（n_w - k_w + p*2 +1） （nh​−kh​+p∗2+1）×（nw​−kw​+p∗2+1）

计算错误就是把 p h p_h ph​和 p p p混为一谈了。

通常取 p h = k h − 1 ,     p w = k w − 1 p_h = k_h -1, \ \ \ p_w =k_w -1 ph​=kh​−1,   pw​=kw​−1

  • k h k_h kh​奇数：上下两侧填充 p h / 2 p_h/2 ph​/2
  • k h k_h kh​偶数：上侧填充 ⌈ p h / 2 ⌉ ⌈p_h/2⌉ ⌈ph​/2⌉下侧填充 ⌊ p h / 2 ⌋ ⌊p_h/2⌋ ⌊ph​/2⌋

步幅

步幅指行/列滑动步长。

设置步幅的效果？

成倍减少输出形状。

下图为高3宽2步幅示意图：

卷积神经网络——上篇【深度学习】【PyTorch】【d2l】,深度学习,Python,深度学习,cnn,pytorch

（图片来自 《DIVE INTO DEEP LEARNING》）

给定步幅，高度 s h s_h sh​宽度 s w s_w sw​，输出形状：

⌊ ( n h − k h + p h + s h ) / s h ⌋ × ⌊ ( n w − k w + p w + s w ) / s w ⌋ ⌊(n_h - k_h + p_h + s_h)/s_h⌋ ×⌊(n_w - k_w + p_w + s_w)/s_w⌋ ⌊(nh​−kh​+ph​+sh​)/sh​⌋×⌊(nw​−kw​+pw​+sw​)/sw​⌋

如果输入高度宽度可被步幅整除，形状为：

( n h / s h ) × ( n w / s w ) (n_h / s_h)×(n_w / s_w) (nh​/sh​)×(nw​/sw​)

5.2.2、代码实现

填充、步幅是卷积层超参数。

所有侧边填充一个像素

import torch
from torch import nn

def comp_conv2d(conv2d, X):
    X = X.reshape((1,1) + X.shape)
    Y =conv2d(X)
    return Y.reshape(Y.shape[2:])

conv2d = nn.Conv2d(1,1,kernel_size=3,padding=1)
X= torch.rand(size=(8,8))
comp_conv2d(conv2d,X).shape

填充相同高度宽度

import torch
from torch import nn

def comp_conv2d(conv2d, X):
    X = X.reshape((1,1) + X.shape)
    #执行一次卷积操作
    Y =conv2d(X)
    return Y.reshape(Y.shape[2:])
#padding=1 在输入数据的边界填充一行和一列的零值
conv2d = nn.Conv2d(1,1,kernel_size=3,padding=1)
X= torch.rand(size=(8,8))
comp_conv2d(conv2d,X).shape

torch.Size([8, 8])

不同高度宽度

conv2d = nn.Conv2d(1,1,kernel_size=(5,3),padding=(2,1))
comp_conv2d(conv2d,X).shape

torch.Size([8, 8])

增设步幅，其宽高为2

conv2d = nn.Conv2d(1,1,kernel_size=3,padding=1,stride =2)
comp_conv2d(conv2d,X).shape

torch.Size([4, 4])

成倍缩小。

5.3、多输入多输出通道

5.3.1、理论部分

彩色RGB图片，是三通道输入数据。

每个通道都有一个卷积核，结果为各通道卷积的和。

卷积神经网络——上篇【深度学习】【PyTorch】【d2l】,深度学习,Python,深度学习,cnn,pytorch

1×1卷积层

不识别空间，用途是融合通道。

二维卷积层（多通道）

Y = X ★ W + B Y = X ★ W + B Y=X★W+B

  • 输入 X X X： c i × n h × n w c_i × n_h × n_w ci​×nh​×nw​

    c i c_i ci​输入通道数、h高、w宽、输入大小 n。

  • 核 W W W： c o × c i × k h × k w c_o × c_i × k_h × k_w co​×ci​×kh​×kw​

    c o c_o co​输出通道数、卷积核大小 k。其中， c o c_o co​是卷积层的超参数。

  • 偏差 B B B ： c o × c i c_o × c_i co​×ci​

    一共有 c o × c i c_o × c_i co​×ci​个卷积核 每个卷积核都有一个偏差

  • 输出 Y Y Y： c o × m h × m w c_o × m_h × m_w co​×mh​×mw​

    m h   m w m_h \ m_w mh​ mw​大小与 填充p、核大小k有关。

  • ★：二维交叉操作子 | 外积

怎么理解每个输出通道有独立的三维卷积核？

具有三个维度：高度、宽度和通道数。

通道变化的意义

通道变化是非线性变换。

  1. 通道变大的意义： 增加通道数可以增强网络的表达能力和特征提取能力。通过引入更多的卷积核，网络可以学习更多不同尺度和不同抽象级别的特征。它们有助于捕获图像的细节和纹理，以及高级别的抽象特征。在更高的层次上学习到更丰富的特征。
  2. 通道变小的意义： 减小通道数可以降低网络的计算成本和参数数量，同时也可以起到特征压缩和维度约减的作用。通过将较大通道数的特征图进行降维，从而实现网络的轻量化。还可以起到正则化的作用，减少过拟合的风险。在某些情况下，通道数的减小也可以帮助网络更好地学习到一些共享的、更为重要的特征。

5.3.2、代码实现

（1）实现多通道互相关运算

定义多通道输入

import torch
from d2l import torch as d2l
#先遍历“X”和“K”的第0个维度（通道维度），再把它们加在一起
def corr2d_multi_in(X,K):
    return sum(d2l.corr2d(x,k) for x,k in zip(X,K))

多通道第零维度的几何意义？

卷积神经网络——上篇【深度学习】【PyTorch】【d2l】,深度学习,Python,深度学习,cnn,pytorch

图中X第零维度有两组，几何上就是通道数。

X :

(tensor([[[0., 1., 2.],
          [3., 4., 5.],
          [6., 7., 8.]],

         [[1., 2., 3.],
          [4., 5., 6.],
          [7., 8., 9.]]]),

定义X，K

# X 2*3*3
X = torch.tensor([[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
               [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]])
#K 2*2*2
K = torch.tensor([[[0.0, 1.0], [2.0, 3.0]], [[1.0, 2.0], [3.0, 4.0]]])

X,K,corr2d_multi_in(X, K)

(tensor([[[0., 1., 2.],
       [3., 4., 5.],
       [6., 7., 8.]],

      [[1., 2., 3.],
       [4., 5., 6.],
       [7., 8., 9.]]]),
tensor([[[0., 1.],
       [2., 3.]],

      [[1., 2.],
       [3., 4.]]]),
tensor([[ 56.,  72.],
      [104., 120.]]))

定义多通道输出

def corr2d_multi_in_out(X,K):
    # 使用 PyTorch 的 torch.stack 函数，它将一组张量沿着指定的维度（这里是维度0）进行堆叠，生成一个新的张量。
    return torch.stack([corr2d_multi_in(X,k) for k in K],0)
# K+1 K的每个值加一，K规模扩成了原来3倍。
K = torch.stack((K,K+1,K+2),0)
K,K.shape

(tensor([[[[0., 1.],
        [2., 3.]],

       [[1., 2.],
        [3., 4.]]],


      [[[1., 2.],
        [3., 4.]],

       [[2., 3.],
        [4., 5.]]],


      [[[2., 3.],
        [4., 5.]],

       [[3., 4.],
        [5., 6.]]]]),
torch.Size([3, 2, 2, 2]))

返回值那一行为什么用小k对应X，多通道输入那里不是用的大K对应X，然后第零维度展开，抽出x，k对应计算吗？

K扩了三倍，所以用小k规模和原来的K相当，因此X 对应扩充前的K，扩充后的小k。

corr2d_multi_in_out(X,K)

tensor([[[ 56.,  72.],
      [104., 120.]],

     [[ 76., 100.],
      [148., 172.]],

     [[ 96., 128.],
      [192., 224.]]])

（2）实现1*1卷积核

def corr2d_multi_in_out_1x1(X, K):
    c_i, h, w = X.shape
    c_o = K.shape[0]
    X = X.reshape((c_i, h * w))
    K = K.reshape((c_o, c_i))
    # 全连接层中的矩阵乘法
    Y = torch.matmul(K, X)
    return Y.reshape((c_o, h, w))

X = torch.normal(0, 1, (3, 3, 3))
K = torch.normal(0, 1, (2, 3, 1, 1))

Y1 = corr2d_multi_in_out_1x1(X, K)
Y2 = corr2d_multi_in_out(X, K)
# 进行断言，验证使用 1x1 卷积操作得到的输出 Y1 与多通道卷积操作得到的输出 Y2 是否非常接近，以确保两种方法的结果一致
assert float(torch.abs(Y1 - Y2).sum()) < 1e-6

5.4、池化层 | 汇聚层

5.4.1、理论部分

最大池化，每个窗口最强的模式信号，它针对卷积对空间位置敏感（边缘检测案例），允许输入有一定的偏移。

也有平均池化层。

特点

  • 具有填充，步幅；
  • 没有可学习的参数；
  • 输出通道 = 输入通道，一一对应。

5.4.2、代码实现

池化层向前传播

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

def pool2d(X, pool_size, mode='max'):
    p_h, p_w = pool_size
    Y = torch.zeros((X.shape[0] - p_h + 1, X.shape[1] - p_w + 1))
    for i in range(Y.shape[0]):
        for j in range(Y.shape[1]):
            if mode == 'max':
                Y[i, j] = X[i: i + p_h, j: j + p_w].max()
            elif mode == 'avg':
                Y[i, j] = X[i: i + p_h, j: j + p_w].mean()
    return Y

验证最大池化层

X = torch.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]])
pool2d(X, (2, 2))

tensor([[4., 5.],
  [7., 8.]])

验证平均池化层

pool2d(X, (2,2), 'avg')

tensor([[2., 3.],
  [5., 6.]])

使用内置的最大池化层

X = torch.arange(16, dtype=torch.float32).reshape((1, 1, 4, 4))
X

tensor([[[[ 0.,  1.,  2.,  3.],
       [ 4.,  5.,  6.,  7.],
       [ 8.,  9., 10., 11.],
       [12., 13., 14., 15.]]]])

pool2d = nn.MaxPool2d(3, padding=1, stride=2)#等价于nn.MaxPool2d((3,3), padding=(1,1), stride=(2,2))
pool2d(X)

tensor([[[[ 5.,  7.],
       [13., 15.]]]])

pool2d = nn.MaxPool2d((2, 3), stride=(2, 3), padding=(0, 1))
pool2d(X)

tensor([[[[ 5.,  7.],
       [13., 15.]]]])

验证多通道

汇聚层在每个输入通道上单独运算，输出通道数与输入通道数相同。

拼接上 torch.cat和torch.stack的区别

torch.cat 是在现有维度上进行拼接。

torch.stack 用于创建一个新的维度，并将多个张量沿该新维度进行堆叠。文章来源地址https://www.toymoban.com/news/detail-664269.html

# 将两个张量 X, X + 1 进行拼接
X = torch.cat((X, X + 1), 1)
X

tensor([[[[ 0.,  1.,  2.,  3.],
    [ 4.,  5.,  6.,  7.],
    [ 8.,  9., 10., 11.],
    [12., 13., 14., 15.]],

   [[ 1.,  2.,  3.,  4.],
    [ 5.,  6.,  7.,  8.],
    [ 9., 10., 11., 12.],
    [13., 14., 15., 16.]]]])

pool2d = nn.MaxPool2d(3, padding=1, stride=2)
pool2d(X)

tensor([[[[ 5.,  7.],
       [13., 15.]],

      [[ 6.,  8.],
       [14., 16.]]]])

到了这里，关于卷积神经网络——上篇【深度学习】【PyTorch】【d2l】的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【AI】《动手学-深度学习-PyTorch版》笔记（十七）：卷积神经网络入门

    我们在前面学习的多层感知机中，已经认识了全链接层，缺点很明显，在稍微大点的网络模型中，参数成指数级别增长。参数量很快就达到数十亿，这样的量级几乎无法计算。为此科学家们想出一个减少参数的方法：卷积。 从全链接层到卷积的推论，使用如下两个原则： 平

    2024年02月13日
    浏览(43)
  • 【AI】《动手学-深度学习-PyTorch版》笔记（十九）：卷积神经网络模型（GoogLeNet、ResNet、DenseNet）

    【AI】《动手学-深度学习-PyTorch版》笔记（十九）：卷积神经网络模型（GoogLeNet、ResNet、DenseNet）

    发布时间：2014年 GoogLeNet的贡献是如何选择合适大小的卷积核，并将不同大小的卷积核组合使用。 之前介绍的网络结构都是串行的，GoogLeNet使用并行的网络块，称为“Inception块” “Inception块”前后进化了四次，论文链接： [1]https://arxiv.org/pdf/1409.4842.pdf [2]https://arxiv.org/pdf/150

    2024年02月12日
    浏览(35)
  • 深度学习图像分类实战——pytorch搭建卷积神经网络(AlexNet, LeNet, ResNet50)进行场景图像分类（详细）

    深度学习图像分类实战——pytorch搭建卷积神经网络(AlexNet, LeNet, ResNet50)进行场景图像分类（详细）

    目录 1  一、实验过程 1.1  实验目的 1.2  实验简介 1.3  数据集的介绍 1.4  一、LeNet5网络模型 1.5  二、AlexNet网络模型 1.6  三、ResNet50（残差网络）网络模型  二、实验代码 导入实验所需要的库  参数配置 数据预处理 重新DataSet 加载数据转为DataLoader函数 可视化一批训练

    2024年02月05日
    浏览(47)
  • 【AI】《动手学-深度学习-PyTorch版》笔记（十八）：卷积神经网络模型(LeNet、AlexNet、VGG、NiN)

    【AI】《动手学-深度学习-PyTorch版》笔记（十八）：卷积神经网络模型(LeNet、AlexNet、VGG、NiN)

    发布时间：1989年 模型目的：识别手写数字 1.3.1 相关函数原型 1）nn.Conv2d：卷积层

    2024年02月12日
    浏览(37)
  • 深度学习，卷积神经网络

    深度学习，卷积神经网络

      CV领域发展 CV领域是计算机视觉（Computer Vision）领域的简称。 计算机视觉是指利用计算机模拟人类视觉系统的科学，让计算机具有类似于人类在观察外界的视觉、图像的能力，包括图像处理、图像分析、图像理解等。 计算机视觉领域发展有以下特点： 视觉系统的出现和不

    2024年02月15日
    浏览(40)
  • 深度学习｜卷积神经网络

    深度学习｜卷积神经网络

    卷积神经网络（Convolutional Neural Network，CNN）是一种深度学习神经网络结构，主要用于 图像识别 、 计算机视觉 等领域。该结构在处理图像等高维数据时表现出色，因为它具有共享权重和局部感知的特点，一方面减少了权值的数量使得网络易于优化，另一方面降低了模型的复

    2024年02月11日
    浏览(27)

  • PyTorch入门学习（八）：神经网络-卷积层

    目录 一、数据准备 二、创建卷积神经网络模型 三、可视化卷积前后的图像 一、数据准备 首先，需要准备一个数据集来演示卷积层的应用。在这个示例中，使用了CIFAR-10数据集，该数据集包含了10个不同类别的图像数据，用于分类任务。使用PyTorch的 torchvision 库来加载CIFAR-1

    2024年02月07日
    浏览(29)
  • 【深度学习】6-1 卷积神经网络 - 卷积层

    【深度学习】6-1 卷积神经网络 - 卷积层

    卷积神经网络(Convolutional Neural Network， CNN )。 CNN 被用于图像识别、语音识别等各种场合，在图像识别的比赛中，基于深度学习的方法几乎都以 CNN 为基础。 首先，来看一下 CNN 的网络结构，了解 CNN 的大致框架。CNN 和之前介绍的神经网络一样，可以像乐高积木一样通过组装层

    2024年02月10日
    浏览(31)
  • Python中的深度学习：神经网络与卷积神经网络

    Python中的深度学习：神经网络与卷积神经网络

    当下，深度学习已经成为人工智能研究和应用领域的关键技术之一。作为一个开源的高级编程语言，Python提供了丰富的工具和库，为深度学习的研究和开发提供了便利。本文将深入探究Python中的深度学习，重点聚焦于神经网络与卷积神经网络的原理和应用。 深度学习是机器学

    2024年02月08日
    浏览(32)
  • 深度学习基础——卷积神经网络（一）

    深度学习基础——卷积神经网络（一）

    卷积是卷积神经网络中的基本操作，对于图像的特征提取有着关键的作用，本文首先介绍卷积的基本原理与作用，然后通过编写程序实现卷积操作，并展示了均值、高斯与sobel等几种经典卷积核的卷积效果，接着调用MindSpore中的卷积算子Conv2d来实现卷积操作，最后介绍了Mind

    2024年02月20日
    浏览(26)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包