昇思25天学习打卡营第5天|网络构建

最新推荐文章于 2024-07-01 00:48:07 发布

不雨_亦潇潇

最新推荐文章于 2024-07-01 00:48:07 发布

阅读量1.1k

点赞数 31

分类专栏：人工智能AI # MindSpore Python 文章标签：网络 python MindSpore 神经网络 NN 晟思 AI

本文链接：https://blog.csdn.net/weixin_43470383/article/details/140065694

版权

人工智能AI 同时被 3 个专栏收录

48 篇文章 0 订阅

订阅专栏

Python

26 篇文章 0 订阅

订阅专栏

MindSpore

14 篇文章 0 订阅

订阅专栏

☀️ 最近报名参加了昇思25天学习打卡训练营
☀️ 第1天初步学习了MindSpore的基本操作
☀️ 第2天初步学习了张量Tensor
☀️ 第3天初步学习了数据集Dataset
☀️ 第4天初步学习了数据变换Transforms
☀️ 第5天学习 初学入门 / 初学教程 / 06-网络构建Transforms

1. 代码跑通流程

神经网络模型是由神经网络层和Tensor操作构成的，mindspore.nn提供了常见神经网络层的实现，在MindSpore中，Cell类是构建所有网络的基类，也是网络的基本单元。一个神经网络模型表示为一个Cell，它由不同的子Cell构成。使用这样的嵌套结构，可以简单地使用面向对象编程的思维，对神经网络结构进行构建和管理。

下面我们将构建一个用于Mnist数据集分类的神经网络模型。

1.1 导入库

import mindspore
from mindspore import nn, ops

1.2 定义模型类

当我们定义神经网络时，可以继承 nn.Cell 类，在__init__方法中进行子Cell的实例化和状态管理，在 construct 方法中实现Tensor操作。

construct 意为神经网络（计算图）构建，相关内容详见使用静态图加速。

AI编译框架分为两种运行模式，分别是动态图模式以及静态图模式。 MindSpore默认情况下是以动态图模式运行，但也支持手工切换为静态图模式。
动态图的特点是计算图的构建和计算同时发生（Define by run），其符合Python的解释执行方式，在计算图中定义一个Tensor时，其值就已经被计算且确定，因此在调试模型时较为方便，能够实时得到中间结果的值，但由于所有节点都需要被保存，导致难以对整个计算图进行优化。在MindSpore中，动态图模式又被称为PyNative模式。由于动态图的解释执行特性，在脚本开发和网络流程调试过程中，推荐使用动态图模式进行调试。
相较于动态图而言，静态图的特点是将计算图的构建和实际计算分开（Define and run）。
在MindSpore中，静态图模式又被称为Graph模式，在Graph模式下，基于图优化、计算图整图下沉等技术，编译器可以针对图进行全局的优化，获得较好的性能，因此比较适合网络固定且需要高性能的场景。

from mindspore import nn  
  
# 定义一个名为Network的神经网络类，继承自nn.Cell  
class Network(nn.Cell):  
    # 初始化方法  
    def __init__(self):  
        # 调用父类nn.Cell的初始化方法  
        super().__init__()  
          
        # 定义一个flatten层，用于将多维的输入数据展平为一维数据  
        self.flatten = nn.Flatten()  
          
        # 定义一个SequentialCell，它是一个顺序容器，可以包含多个层，数据会按照顺序依次通过这些层  
        self.dense_relu_sequential = nn.SequentialCell(  
            # 第一个全连接层（Dense），输入特征数为28*28（例如，MNIST图像的大小），输出特征数为512  
            # weight_init和bias_init参数指定了权重和偏置的初始化方式
            # 随机生成权重矩阵的初始值，偏置项初始化为零  
            nn.Dense(28*28, 512, weight_init="normal", bias_init="zeros"),  
              
            # ReLU激活函数  
            nn.ReLU(),  
              
            # 第二个全连接层，输入和输出特征数均为512  
            nn.Dense(512, 512, weight_init="normal", bias_init="zeros"),  
              
            # ReLU激活函数  
            nn.ReLU(),  
              
            # 第三个全连接层，作为输出层，输入特征数为512，输出特征数为10（例如，用于分类10个类别的MNIST数据集）  
            nn.Dense(512, 10, weight_init="normal", bias_init="zeros")  
        )  
  
    # 前向传播方法，MindSpore中使用construct方法来实现  
    def construct(self, x):  
        # 将输入数据x通过flatten层展平  
        x = self.flatten(x)  
          
        # 将展平后的数据x通过dense_relu_sequential层（包含多个全连接层和ReLU激活函数）  
        # 得到logits，即网络的输出值，通常用于分类任务中的概率值或得分  
        logits = self.dense_relu_sequential(x)  
          
        # 返回logits作为网络的输出  
        return logits

construct 方法定义了网络的前向传播过程。当数据 x 被传入Network实例时，它首先被 flatten 层展平，然后经过 dense_relu_sequential 层（其中包含3个全连接层和2个ReLU激活函数），最终得到输出 logits。这个 logits 可以被用于进一步的操作，如计算损失、进行softmax 操作以得到概率分布等。

构建完成后，实例化 Network 对象，并查看其结构。

model = Network()
print(model)

输出：

Network<
  (flatten): Flatten<>
  (dense_relu_sequential): SequentialCell<
    (0): Dense<input_channels=784, output_channels=512, has_bias=True>
    (1): ReLU<>
    (2): Dense<input_channels=512, output_channels=512, has_bias=True>
    (3): ReLU<>
    (4): Dense<input_channels=512, output_channels=10, has_bias=True>
    >
  >

在这里插入图片描述

我们构造一个输入数据，直接调用模型，可以获得一个十维的Tensor输出，其包含每个类别的原始预测值。

model.construct() 方法不可直接调用。

X = ops.ones((1, 28, 28), mindspore.float32)
logits = model(X)
# print logits
logits

输出：

Tensor(shape=[1, 10], dtype=Float32, value=
[[-1.34644797e-03,  1.29277352e-04,  1.17136752e-02 ...  5.12425695e-03, -2.85935123e-03,  1.22657903e-02]])

在此基础上，我们通过一个 nn.Softmax 层实例来获得预测概率。

pred_probab = nn.Softmax(axis=1)(logits)
y_pred = pred_probab.argmax(1)
print(f"Predicted class: {y_pred}")

输出：

Predicted class: [9]

1.3 模型层

本节中我们分解上节构造的神经网络模型中的每一层。首先我们构造一个shape为(3, 28, 28)的随机数据（3个28x28的图像），依次通过每一个神经网络层来观察其效果。

input_image = ops.ones((3, 28, 28), mindspore.float32)
print(input_image.shape)

输出：

(3, 28, 28)

1️⃣ nn.Flatten

实例化 nn.Flatten 层，将28x28的2D张量转换为784大小的连续数组。

flatten = nn.Flatten()
flat_image = flatten(input_image)
print(flat_image.shape)

输出：

(3, 784)

将输入数据从多维（例如，图像的高×宽×通道）转换为一维向量，以便输入到后续的全连接层。

2️⃣ nn.Dense

nn.Dense为全连接层，其使用权重和偏差对输入进行线性变换。

layer1 = nn.Dense(in_channels=28*28, out_channels=20)
hidden1 = layer1(flat_image)
print(hidden1.shape)

输出：

(3, 20)

3️⃣ nn.ReLU

nn.ReLU层给网络中加入非线性的激活函数，帮助神经网络学习各种复杂的特征。

print(f"Before ReLU: {hidden1}\n\n")
hidden1 = nn.ReLU()(hidden1)
print(f"After ReLU: {hidden1}")

输出：

Before ReLU: [[ 0.6843467   0.259497   -0.25782263  0.6184629   0.6070477  -0.73334247
   0.74973434  0.45182937 -0.23277852  0.7250475  -0.52080756 -0.15784171
   0.01202491 -0.60827506  0.8921455   0.449151    0.1737952   0.8706826
  -0.08334174 -0.7448301 ]
 [ 0.6843467   0.259497   -0.25782263  0.6184629   0.6070477  -0.73334247
   0.74973434  0.45182937 -0.23277852  0.7250475  -0.52080756 -0.15784171
   0.01202491 -0.60827506  0.8921455   0.449151    0.1737952   0.8706826
  -0.08334174 -0.7448301 ]
 [ 0.6843467   0.259497   -0.25782263  0.6184629   0.6070477  -0.73334247
   0.74973434  0.45182937 -0.23277852  0.7250475  -0.52080756 -0.15784171
   0.01202491 -0.60827506  0.8921455   0.449151    0.1737952   0.8706826
  -0.08334174 -0.7448301 ]]


After ReLU: [[0.6843467  0.259497   0.         0.6184629  0.6070477  0.
  0.74973434 0.45182937 0.         0.7250475  0.         0.
  0.01202491 0.         0.8921455  0.449151   0.1737952  0.8706826
  0.         0.        ]
 [0.6843467  0.259497   0.         0.6184629  0.6070477  0.
  0.74973434 0.45182937 0.         0.7250475  0.         0.
  0.01202491 0.         0.8921455  0.449151   0.1737952  0.8706826
  0.         0.        ]
 [0.6843467  0.259497   0.         0.6184629  0.6070477  0.
  0.74973434 0.45182937 0.         0.7250475  0.         0.
  0.01202491 0.         0.8921455  0.449151   0.1737952  0.8706826
  0.         0.        ]]

4️⃣ nn.SequentialCell

nn.SequentialCell是一个有序的Cell容器。输入Tensor将按照定义的顺序通过所有Cell。我们可以使用SequentialCell来快速组合构造一个神经网络模型。

seq_modules = nn.SequentialCell(
    flatten,
    layer1,
    nn.ReLU(),
    nn.Dense(20, 10)
)

logits = seq_modules(input_image)
print(logits.shape)

输出：

(3, 10)

5️⃣ nn.Softmax

最后使用nn.Softmax将神经网络最后一个全连接层返回的logits的值缩放为[0, 1]，表示每个类别的预测概率。axis指定的维度数值和为1。

softmax = nn.Softmax(axis=1)
pred_probab = softmax(logits)

1.4 模型参数

网络内部神经网络层具有权重参数和偏置参数（如nn.Dense），这些参数会在训练过程中不断进行优化，可通过 model.parameters_and_names() 来获取参数名及对应的参数详情。

print(f"Model structure: {model}\n\n")

for name, param in model.parameters_and_names():
    print(f"Layer: {name}\nSize: {param.shape}\nValues : {param[:2]} \n")

输出：

Model structure: Network<
  (flatten): Flatten<>
  (dense_relu_sequential): SequentialCell<
    (0): Dense<input_channels=784, output_channels=512, has_bias=True>
    (1): ReLU<>
    (2): Dense<input_channels=512, output_channels=512, has_bias=True>
    (3): ReLU<>
    (4): Dense<input_channels=512, output_channels=10, has_bias=True>
    >
  >


Layer: dense_relu_sequential.0.weight
Size: (512, 784)
Values : [[ 0.00421729  0.00764486  0.00125789 ... -0.00573038 -0.0162938
  -0.0076075 ]
 [ 0.00555476 -0.00247079  0.01020895 ...  0.0078051  -0.00817331
  -0.00015425]] 

Layer: dense_relu_sequential.0.bias
Size: (512,)
Values : [0. 0.] 

Layer: dense_relu_sequential.2.weight
Size: (512, 512)
Values : [[-0.00897185  0.01778448 -0.01740738 ... -0.0008132  -0.01179575
  -0.00346031]
 [-0.01564151  0.00206684  0.00829779 ...  0.00204611  0.00772646
  -0.01689647]] 

Layer: dense_relu_sequential.2.bias
Size: (512,)
Values : [0. 0.] 

Layer: dense_relu_sequential.4.weight
Size: (10, 512)
Values : [[ 0.00857544  0.00762396 -0.017364   ... -0.00465207  0.00717399
   0.00302128]
 [ 0.01176514 -0.0085316   0.00299114 ...  0.0016758   0.00445736
   0.00648327]] 

Layer: dense_relu_sequential.4.bias
Size: (10,)
Values : [0. 0.]

2. 小结

今天学习了网络构建，后续可以在这基础上扩展。

在这里插入图片描述

参考：
https://blog.csdn.net/qq_39306047/article/details/139857746

不雨_亦潇潇

关注

31
点赞
踩
26

收藏

觉得还不错? 一键收藏
打赏
0
评论
昇思25天学习打卡营第5天|网络构建

当我们定义神经网络时，可以继承 nn.Cell 类，在__init__方法中进行子Cell的实例化和状态管理，在 construct 方法中实现Tensor操作。construct 意为神经网络（计算图）构建，相关内容详见使用静态图加速。AI编译框架分为两种运行模式，分别是动态图模式以及静态图模式。MindSpore默认情况下是以动态图模式运行，但也支持手工切换为静态图模式。动态图的特点是计算图的构建和计算同时发生（Define by run）
复制链接

扫一扫