《昇思25天学习打卡营第05天|qingyun201003》

news2024/9/17 7:27:59

日期

image.png

心得

通过本节课的学习，学习到了通过网络获取数据集，处理数据集模型。数据模型层数据变换，模型参数解析和其对应代码中的API进行解析。

昇思MindSpore 基础入门学习 网络构建 (AI 代码解析)

网络构建

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

import mindspore  # 导入MindSpore库，这是一个深度学习框架，类似于TensorFlow和PyTorch。
from mindspore import nn, ops  # 从MindSpore库中导入神经网络模块(nn)和操作模块(ops)。
  1. import mindspore:
    • 这一行代码导入了MindSpore库，MindSpore是一个开源的深度学习框架，由华为开发，旨在提供高效、灵活的AI计算框架。
  2. from mindspore import nn, ops:
    • 这一行代码从MindSpore库中导入了两个重要的模块：
      • nn: 神经网络模块，包含了构建神经网络所需的各种层和函数，如卷积层、全连接层、激活函数等。
      • ops: 操作模块，提供了各种数学运算和操作，如矩阵运算、张量操作等。
  • mindspore:
    • MindSpore库的主要入口，提供了框架的基础功能和配置。
  • mindspore.nn:
    • 神经网络模块，包含了一系列用于构建神经网络的类和函数，例如：
      • nn.Conv2d: 二维卷积层。
      • nn.Linear: 全连接层。
      • nn.ReLU: ReLU激活函数。
      • nn.Sequential: 顺序容器，用于按顺序组合多个层。
  • mindspore.ops:
    • 操作模块，提供了各种数学运算和操作，例如：
      • ops.Add: 加法操作。
      • ops.MatMul: 矩阵乘法操作。
      • ops.ReduceSum: 求和操作。
      • ops.Softmax: Softmax操作，用于多分类问题的输出层。

这些模块和类是构建和训练深度学习模型的基础组件，通过组合和配置这些组件，可以实现复杂的神经网络结构和算法。

定义模型类

当我们定义神经网络时，可以继承nn.Cell类，在__init__方法中进行子Cell的实例化和状态管理，在construct方法中实现Tensor操作。
construct意为神经网络（计算图）构建，相关内容详见使用静态图加速。

class Network(nn.Cell):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.dense_relu_sequential = nn.SequentialCell(
            nn.Dense(28*28, 512, weight_init="normal", bias_init="zeros"),
            nn.ReLU(),
            nn.Dense(512, 512, weight_init="normal", bias_init="zeros"),
            nn.ReLU(),
            nn.Dense(512, 10, weight_init="normal", bias_init="zeros")
        )

    def construct(self, x):
        x = self.flatten(x)
        logits = self.dense_relu_sequential(x)
        return logits

model = Network()
print(model)
  1. class Network(nn.Cell)::
    • 定义了一个名为 Network 的类，继承自 nn.Cell。在 MindSpore 中，nn.Cell 是构建神经网络的基本单元。
  2. def __init__(self)::
    • 初始化方法，定义了网络的结构。
    • super().__init__()：调用父类 nn.Cell 的初始化方法。
    • self.flatten = nn.Flatten()：创建一个 nn.Flatten 层，用于将输入展平为一维向量。
    • self.dense_relu_sequential = nn.SequentialCell(...)：创建一个顺序容器 nn.SequentialCell，包含多个层：
      • nn.Dense(28*28, 512, weight_init="normal", bias_init="zeros")：输入层，输入大小为 28*28（即 784），输出大小为 512，权重初始化为正态分布，偏置初始化为零。
      • nn.ReLU()：ReLU 激活函数。
      • nn.Dense(512, 512, weight_init="normal", bias_init="zeros")：隐藏层，输入和输出大小均为 512。
      • nn.ReLU()：ReLU 激活函数。
      • nn.Dense(512, 10, weight_init="normal", bias_init="zeros")：输出层，输入大小为 512，输出大小为 10（假设是 10 类分类问题）。
  3. def construct(self, x)::
    • 定义了网络的前向传播过程。
    • x = self.flatten(x)：将输入 x 展平为一维向量。
    • logits = self.dense_relu_sequential(x)：将展平后的输入通过顺序容器中的各层，得到最终的输出 logits。
    • return logits：返回最终的输出。
  4. model = Network():
    • 创建 Network 类的一个实例 model。
  5. print(model):
    • 打印 model 的结构，显示网络的层和参数信息。
  • nn.Cell:
    • MindSpore 中用于构建神经网络的基本单元。
  • nn.Flatten:
    • 将输入展平为一维向量的层。
  • nn.SequentialCell:
    • 顺序容器，按顺序组合多个层。
  • nn.Dense:
    • 全连接层，参数包括输入大小、输出大小、权重初始化和偏置初始化。
  • nn.ReLU:
    • ReLU 激活函数，用于引入非线性。

通过这些组件，可以构建一个简单的多层感知机（MLP）网络，用于处理类似 MNIST 数据集的图像分类任务。

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

pred_probab = nn.Softmax(axis=1)(logits)
y_pred = pred_probab.argmax(1)
print(f"Predicted class: {y_pred}")
  1. X = ops.ones((1, 28, 28), mindspore.float32):
    • 创建一个形状为 (1, 28, 28) 的张量 X，其中所有元素值为 1，数据类型为 mindspore.float32。这个张量模拟了一个 28x28 的单通道图像输入。
  2. logits = model(X):
    • 将输入张量 X 传递给模型 model，得到模型的输出 logits。logits 是未经 softmax 处理的原始输出，通常用于分类任务。
  3. pred_probab = nn.Softmax(axis=1)(logits):
    • 对 logits 应用 softmax 函数，将其转换为概率分布。nn.Softmax(axis=1) 表示在第二个维度（即类别维度）上进行 softmax 操作。
  4. y_pred = pred_probab.argmax(1):
    • 在概率分布 pred_probab 上找到最大概率对应的索引，即预测的类别。argmax(1) 表示在第二个维度上找到最大值的索引。
  5. print(f"Predicted class: {y_pred}"):
    • 打印预测的类别。y_pred 是一个包含预测类别索引的张量。
  • ops.ones:
    • 创建一个全为 1 的张量，参数包括形状和数据类型。
  • nn.Softmax:
    • softmax 函数，用于将输入转换为概率分布，参数 axis 指定在哪个维度上进行 softmax 操作。
  • argmax:
    • 找到张量中指定维度上的最大值对应的索引。

通过这些操作，可以对模型的输出进行后处理，得到最终的预测类别。

模型层

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

input_image = ops.ones((3, 28, 28), mindspore.float32)
print(input_image.shape)
  1. input_image = ops.ones((3, 28, 28), mindspore.float32):
    • 创建一个形状为 (3, 28, 28) 的张量 input_image，其中所有元素值为 1，数据类型为 mindspore.float32。这个张量模拟了一个 28x28 的三通道图像输入（例如 RGB 图像）。
  2. print(input_image.shape):
    • 打印 input_image 的形状。shape 属性返回张量的维度信息。
  • ops.ones:
    • 创建一个全为 1 的张量，参数包括形状和数据类型。
  • shape:
    • 张量的属性，返回张量的维度信息。

通过这些操作，可以创建并查看一个模拟的三通道图像输入张量的形状。

nn.Flatten

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

flatten = nn.Flatten()
flat_image = flatten(input_image)
print(flat_image.shape)
  1. flatten = nn.Flatten():
    • 创建一个 nn.Flatten 层，用于将输入张量展平为一维向量。
  2. flat_image = flatten(input_image):
    • 将 input_image 传递给 flatten 层，得到展平后的张量 flat_image。
  3. print(flat_image.shape):
    • 打印 flat_image 的形状。shape 属性返回张量的维度信息。
  • nn.Flatten:
    • 用于将输入张量展平为一维向量的层。
  • shape:
    • 张量的属性，返回张量的维度信息。

通过这些操作，可以将一个形状为 (3, 28, 28) 的三通道图像输入张量展平为一维向量，并查看其形状。展平后的形状为 (3 * 28 * 28,)，即 (2352,)。

nn.Dense

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

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

  1. layer1 = nn.Dense(in_channels=28*28, out_channels=20):
    • 创建一个全连接层 layer1，输入通道数为 28*28（即 784），输出通道数为 20。这个层将输入的展平图像转换为一个 20 维的向量。
  2. hidden1 = layer1(flat_image):
    • 将展平后的图像 flat_image 传递给全连接层 layer1，得到输出 hidden1。hidden1 是经过全连接层处理后的张量。
  3. print(hidden1.shape):
    • 打印 hidden1 的形状。shape 属性返回张量的维度信息。

  • nn.Dense:
    • 全连接层（也称为线性层），用于将输入张量通过线性变换转换为输出张量。参数 in_channels 指定输入的特征数，out_channels 指定输出的特征数。
  • shape:
    • 张量的属性，返回张量的维度信息。

通过这些操作，可以将展平后的图像输入传递给一个全连接层，并查看其输出的形状。假设 flat_image 的形状为 (batch_size, 28*28)，那么 hidden1 的形状将为 (batch_size, 20)。

nn.ReLU

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

print(f"Before ReLU: {hidden1}\n\n")
hidden1 = nn.ReLU()(hidden1)
print(f"After ReLU: {hidden1}")
  1. print(f"Before ReLU: {hidden1}\n\n"):
    • 打印 hidden1 的值，即全连接层的输出，在应用 ReLU 激活函数之前。
  2. hidden1 = nn.ReLU()(hidden1):
    • 对 hidden1 应用 ReLU 激活函数。nn.ReLU() 创建一个 ReLU 激活函数层，并将其应用于 hidden1。ReLU 函数将所有负值置为 0，保持正值不变。
  3. print(f"After ReLU: {hidden1}"):
    • 打印 hidden1 的值，即应用 ReLU 激活函数之后的输出。
  • nn.ReLU:
    • ReLU（Rectified Linear Unit）激活函数层，用于将输入张量中的所有负值置为 0，保持正值不变。

通过这些操作，可以观察全连接层输出在应用 ReLU 激活函数前后的变化。ReLU 激活函数有助于引入非线性，使得神经网络能够学习更复杂的函数。

nn.SequentialCell

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

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

logits = seq_modules(input_image)
print(logits.shape)
  1. seq_modules = nn.SequentialCell(flatten, layer1, nn.ReLU(), nn.Dense(20, 10)):
    • 创建一个顺序模型 seq_modules，包含以下层：
      • flatten：展平层，将输入图像展平为一维向量。
      • layer1：全连接层，将展平后的图像转换为 20 维向量。
      • nn.ReLU()：ReLU 激活函数层，对全连接层的输出应用 ReLU 激活函数。
      • nn.Dense(20, 10)：另一个全连接层，将 20 维向量转换为 10 维向量。
  2. logits = seq_modules(input_image):
    • 将输入图像 input_image 传递给顺序模型 seq_modules，得到输出 logits。logits 是经过所有层处理后的最终输出。
  3. print(logits.shape):
    • 打印 logits 的形状。shape 属性返回张量的维度信息。
  • nn.SequentialCell:
    • 顺序模型容器，用于按顺序组合多个层。输入数据将按顺序通过这些层。
  • nn.Dense:
    • 全连接层（也称为线性层），用于将输入张量通过线性变换转换为输出张量。参数 in_channels 指定输入的特征数，out_channels 指定输出的特征数。
  • nn.ReLU:
    • ReLU（Rectified Linear Unit）激活函数层，用于将输入张量中的所有负值置为 0，保持正值不变。

通过这些操作，可以将输入图像传递给一个包含多个层的顺序模型，并查看其最终输出的形状。假设 input_image 的形状为 (batch_size, 1, 28, 28)，那么 logits 的形状将为 (batch_size, 10)。

nn.Softmax

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

softmax = nn.Softmax(axis=1)
pred_probab = softmax(logits)
  1. softmax = nn.Softmax(axis=1):
    • 创建一个 Softmax 层 softmax，指定在第 1 维度（即每个样本的类别维度）上应用 Softmax 函数。Softmax 函数将输入张量的每个元素转换为概率值，且这些概率值的总和为 1。
  2. pred_probab = softmax(logits):
    • 将 logits 传递给 Softmax 层 softmax，得到输出 pred_probab。pred_probab 是经过 Softmax 函数处理后的概率分布。
  • nn.Softmax:
    • Softmax 激活函数层，用于将输入张量转换为概率分布。参数 axis 指定在张量的哪个维度上应用 Softmax 函数。通常在分类任务中，Softmax 函数用于将网络的输出转换为类别概率。

通过这些操作，可以将网络的输出 logits 转换为概率分布 pred_probab。假设 logits 的形状为 (batch_size, 10)，那么 pred_probab 的形状也将为 (batch_size, 10)，且每个样本的 10 个类别概率之和为 1。

模型参数

网络内部神经网络层具有权重参数和偏置参数（如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")

解析

  1. print(f"Model structure: {model}\n\n"):
    • 打印模型的结构信息。model 是一个神经网络模型对象，打印它会显示模型的层和结构。
  2. for name, param in model.parameters_and_names()::
    • 遍历 model.parameters_and_names() 返回的迭代器，获取每个参数的名称 name 和参数张量 param。
  3. print(f"Layer: {name}\nSize: {param.shape}\nValues : {param[:2]} \n"):
    • 打印每个参数的名称、形状和前两个值。param.shape 返回参数张量的维度信息，param[:2] 返回参数张量的前两个值。

API解析

  • model.parameters_and_names():
    • 获取模型中所有参数及其名称的方法。返回一个迭代器，包含参数名称和对应的参数张量。

通过这些操作，可以查看模型的结构以及每个层的参数名称、形状和前两个值。这对于调试和理解模型参数非常有用。例如，对于一个全连接层 nn.Dense(20, 10)，其权重参数的形状可能是 (20, 10)，偏置参数的形状可能是 (10,)，并且可以查看这些参数的前两个值。

整体代码

#!/usr/bin/env python
# coding: utf-8

# [![下载Notebook](https://qingyun-test.oss-cn-hangzhou.aliyuncs.com/images/2024/07/14/image9817421053129015551.png)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/r2.3/tutorials/zh_cn/beginner/mindspore_model.ipynb) [![下载样例代码](https://qingyun-test.oss-cn-hangzhou.aliyuncs.com/images/2024/07/14/image11826012109507579499.png)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/r2.3/tutorials/zh_cn/beginner/mindspore_model.py) [![查看源文件](https://qingyun-test.oss-cn-hangzhou.aliyuncs.com/images/2024/07/14/image12685397076148884701.png)](https://gitee.com/mindspore/docs/blob/r2.3/tutorials/source_zh_cn/beginner/model.ipynb)
# 
# [基本介绍](https://www.mindspore.cn/tutorials/zh-CN/r2.3/beginner/introduction.html) || [快速入门](https://www.mindspore.cn/tutorials/zh-CN/r2.3/beginner/quick_start.html) || [张量 Tensor](https://www.mindspore.cn/tutorials/zh-CN/r2.3/beginner/tensor.html) || [数据集 Dataset](https://www.mindspore.cn/tutorials/zh-CN/r2.3/beginner/dataset.html) || [数据变换 Transforms](https://www.mindspore.cn/tutorials/zh-CN/r2.3/beginner/transforms.html) || **网络构建** || [函数式自动微分](https://www.mindspore.cn/tutorials/zh-CN/r2.3/beginner/autograd.html) || [模型训练](https://www.mindspore.cn/tutorials/zh-CN/r2.3/beginner/train.html) || [保存与加载](https://www.mindspore.cn/tutorials/zh-CN/r2.3/beginner/save_load.html) || [使用静态图加速](https://www.mindspore.cn/tutorials/zh-CN/r2.3/beginner/accelerate_with_static_graph.html)

# # 网络构建

# 神经网络模型是由神经网络层和Tensor操作构成的，[mindspore.nn](https://www.mindspore.cn/docs/zh-CN/r2.3/api_python/mindspore.nn.html)提供了常见神经网络层的实现，在MindSpore中，[Cell](https://www.mindspore.cn/docs/zh-CN/r2.3/api_python/nn/mindspore.nn.Cell.html)类是构建所有网络的基类，也是网络的基本单元。一个神经网络模型表示为一个`Cell`，它由不同的子`Cell`构成。使用这样的嵌套结构，可以简单地使用面向对象编程的思维，对神经网络结构进行构建和管理。
# 
# 下面我们将构建一个用于Mnist数据集分类的神经网络模型。

# In[1]:


import mindspore
from mindspore import nn, ops


# ## 定义模型类
# 
# 当我们定义神经网络时，可以继承`nn.Cell`类，在`__init__`方法中进行子Cell的实例化和状态管理，在`construct`方法中实现Tensor操作。
# 
# > `construct`意为神经网络（计算图）构建，相关内容详见[使用静态图加速](https://www.mindspore.cn/tutorials/zh-CN/r2.3/beginner/accelerate_with_static_graph.html)。

# In[2]:


class Network(nn.Cell):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.dense_relu_sequential = nn.SequentialCell(
            nn.Dense(28*28, 512, weight_init="normal", bias_init="zeros"),
            nn.ReLU(),
            nn.Dense(512, 512, weight_init="normal", bias_init="zeros"),
            nn.ReLU(),
            nn.Dense(512, 10, weight_init="normal", bias_init="zeros")
        )

    def construct(self, x):
        x = self.flatten(x)
        logits = self.dense_relu_sequential(x)
        return logits


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

# In[3]:


model = Network()
print(model)


# 我们构造一个输入数据，直接调用模型，可以获得一个二维的Tensor输出，其包含每个类别的原始预测值。
# 
# > `model.construct()`方法不可直接调用。

# In[4]:


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


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

# In[5]:


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


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

# In[6]:


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


# ### nn.Flatten
# 
# 实例化[nn.Flatten](https://www.mindspore.cn/docs/zh-CN/r2.3/api_python/nn/mindspore.nn.Flatten.html)层，将28x28的2D张量转换为784大小的连续数组。

# In[7]:


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


# ### nn.Dense
# 
# [nn.Dense](https://www.mindspore.cn/docs/zh-CN/r2.3/api_python/nn/mindspore.nn.Dense.html)为全连接层，其使用权重和偏差对输入进行线性变换。

# In[8]:


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


# ### nn.ReLU
# 
# [nn.ReLU](https://www.mindspore.cn/docs/zh-CN/r2.3/api_python/nn/mindspore.nn.ReLU.html)层给网络中加入非线性的激活函数，帮助神经网络学习各种复杂的特征。

# In[9]:


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


# ### nn.SequentialCell
# 
# [nn.SequentialCell](https://www.mindspore.cn/docs/zh-CN/r2.3/api_python/nn/mindspore.nn.SequentialCell.html)是一个有序的Cell容器。输入Tensor将按照定义的顺序通过所有Cell。我们可以使用`nn.SequentialCell`来快速组合构造一个神经网络模型。

# In[10]:


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

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


# ### nn.Softmax
# 
# 最后使用[nn.Softmax](https://www.mindspore.cn/docs/zh-CN/r2.3/api_python/nn/mindspore.nn.Softmax.html)将神经网络最后一个全连接层返回的logits的值缩放为\[0, 1\]，表示每个类别的预测概率。`axis`指定的维度数值和为1。

# In[11]:


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


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

# In[12]:


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")


# 更多内置神经网络层详见[mindspore.nn API](https://www.mindspore.cn/docs/zh-CN/r2.3/api_python/mindspore.nn.html)。

解析

  1. 导入必要的库：
import mindspore
from mindspore import nn, ops
  • mindspore：MindSpore的主库。
  • nn：包含神经网络层和模块。
  • ops：包含各种Tensor操作。
  1. 定义模型类：
class Network(nn.Cell):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.dense_relu_sequential = nn.SequentialCell(
            nn.Dense(28*28, 512, weight_init="normal", bias_init="zeros"),
            nn.ReLU(),
            nn.Dense(512, 512, weight_init="normal", bias_init="zeros"),
            nn.ReLU(),
            nn.Dense(512, 10, weight_init="normal", bias_init="zeros")
        )

    def construct(self, x):
        x = self.flatten(x)
        logits = self.dense_relu_sequential(x)
        return logits
  • Network类继承自nn.Cell。
  • __init__方法中定义了网络的层结构。
  • construct方法中定义了前向传播的逻辑。
  1. 实例化模型并查看结构：
model = Network()
print(model)
  1. 测试模型：
X = ops.ones((1, 28, 28), mindspore.float32)
logits = model(X)
logits
  1. 使用Softmax层获取预测概率：
pred_probab = nn.Softmax(axis=1)(logits)
y_pred = pred_probab.argmax(1)
print(f"Predicted class: {y_pred}")
  1. 分解模型层：
    • Flatten层：
flatten = nn.Flatten()
flat_image = flatten(input_image)
print(flat_image.shape)
  • Dense层：
layer1 = nn.Dense(in_channels=28*28, out_channels=20)
hidden1 = layer1(flat_image)
print(hidden1.shape)
  • ReLU层：
print(f"Before ReLU: {hidden1}\n\n")
hidden1 = nn.ReLU()(hidden1)
print(f"After ReLU: {hidden1}")
  • SequentialCell：
seq_modules = nn.SequentialCell(
    flatten,
    layer1,
    nn.ReLU(),
    nn.Dense(20, 10)
)
logits = seq_modules(input_image)
print(logits.shape)
  • Softmax层：
softmax = nn.Softmax(axis=1)
pred_probab = softmax(logits)
  1. 查看模型参数：
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")

API解析

  • nn.Cell：MindSpore中所有网络的基类。
  • nn.Flatten：将输入的2D张量展平为一维数组。
  • nn.Dense：全连接层，进行线性变换。
  • nn.ReLU：ReLU激活函数。
  • nn.SequentialCell：有序的Cell容器，按顺序执行各个Cell。
  • nn.Softmax：Softmax激活函数，将logits转换为概率分布。
  • model.parameters_and_names()：获取模型参数及其名称。

通过这些步骤和API的使用，可以构建和管理神经网络模型，并进行前向传播和参数管理。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1926166.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

一篇文章教你如何快速上手Spring MVC框架【万字详解|包含常用注解分析讲解】

一篇文章教你如何快速上手Spring MVC框架【万字详解|包含常用注解分析讲解】

目录 一.什么是Spring Web MVC 二.Spring MVC的使用 ▐ 建立连接 RestController RequestMapping ▐ 传递参数 1.简单类型传参 2.类对象传参（RequestParam） 3.数组&集合传参 4.JSON传参（RequestBody） 5.URL中的参数…
阅读更多...
JavaSE 面向对象程序设计进阶 IO 压缩流 解压缩流

JavaSE 面向对象程序设计进阶 IO 压缩流 解压缩流

目录 解压缩流 压缩流 解压缩流 压缩包 压缩包里面的每一个文件在java中都是一个ZipEntry对象 把每一个ZipEntry按照层级拷贝到另一个文件夹当中 import java.io.*; import java.util.Date; import java.util.zip.ZipEntry; import java.util.zip.ZipInputStream;public cl…
阅读更多...
清华计算几何-ConvexHull(凸包)-求极点InTriangle/ToLeft Test

清华计算几何-ConvexHull(凸包)-求极点InTriangle/ToLeft Test

ConvexHull(凸包) 凸包是什么 凸包是计算几何一个非常基础核心的概念。我理解的凸包就是给定一个点集合, 最外围的点的包围体就是凸包。如下所示: 极点(ExtremityPoint) 给定的点集合中, 如果一个点存在一条直线, 让其他所有点都在于该直线的同一侧, 则该点为极点。 非极点 …
阅读更多...
【Java--数据结构】栈：不仅仅是数据存储，它是编程的艺术

【Java--数据结构】栈：不仅仅是数据存储，它是编程的艺术

欢迎关注个人主页：逸狼 创造不易，可以点点赞吗~ 如有错误，欢迎指出~ 目录 栈 栈的方法介绍 入栈push 出栈pop和 瞄一眼peek 判空isEmpty和判满isFull 模拟实现栈 push入栈 pop出栈和peek 测试 使用泛型实现栈 测试 使用链表实现栈&#xff08…
阅读更多...
本地部署免费AI大模型+知识库

本地部署免费AI大模型+知识库

利用Ollama部署本地大模型 一：终端实现与大模型对话 1.去Ollama官网下载 https://ollama.com/download2.下载之后按照提示一步步安装即可 3.WinR, 输入cmd,打开命令行提示符 输入：ollama run llama3运行大模型 4.使用其他开源大模型，比如…
阅读更多...
基于门控循环单元(GRU)的数据回归预测

基于门控循环单元(GRU)的数据回归预测

代码原理 基于GRU（Gated Recurrent Unit）的数据回归预测通常涉及多输入单输出的情况。以下是简单的原理及流程： 数据准备： 准备多个时间序列作为输入特征，每个时间序列可以表示不同的变量或特征。准备一个目标变量作…
阅读更多...
算法学习day12(动态规划)

算法学习day12(动态规划)

一、不同的二叉搜索树 二叉搜索树的性质：父节点比左边的孩子节点都大；比右边的孩子节点都小； 由图片可知，dp[3]是可以由dp[2]和dp[1]得出来的。(二叉搜索树的种类和根节点的val有关) 当val为1时，左边是一定没有节点的…
阅读更多...
写真图片视频打赏系统源码全开源无加密

写真图片视频打赏系统源码全开源无加密

这是一款开源的写真图片及视频打赏系统源码，顾名思义他可以做写真图片打赏站也可以做视频打赏站，支付对接了易支付，拥有独立代理后台，全部源码无加密，另外也可以配合付费进群使用。支付扣量、域名防洪这些基本的就不介…
阅读更多...
基于信号处理的PPG信号滤波降噪方法（MATLAB）

基于信号处理的PPG信号滤波降噪方法（MATLAB）

光电容积脉搏波PPG信号结合相关算法可以用于人体生理参数检测，如血压、血氧饱和度等，但采集过程中极易受到噪声干扰，对于血压、血氧饱和度测量的准确性造成影响。随着当今社会医疗保健技术的发展，可穿戴监测设备对于PPG信号的质量…
阅读更多...
修正版头像上传组件

修正版头像上传组件

修正版头像上传组件 文章说明核心源码展示运行效果展示源码下载 文章说明 在头像剪切上传一文中，我采用div做裁剪效果，感觉会有一些小问题，在昨天基于canvas绘制的功能中改进了一版，让代码变得更简洁，而且通用性相对高…
阅读更多...
Linux的load（负载）

Linux的load（负载）

负载(load)是Linux机器的一个重要指标，直观了反应了机器当前的状态。 在Linux系统中，系统负载是对当前CPU工作量的度量，被定义为特定时间间隔内运行队列中的平均线程数。 Linux的负载高，主要是由于CPU使用、内存使用、10消…
阅读更多...
[UTCTF2020]babymips

[UTCTF2020]babymips

水一篇 32位 c写的，长得比较丑陋 进入sub-401164函数 V7的数据可以得到 unsigned char ida_chars[] {0x62, 0x6C, 0x7F, 0x76, 0x7A, 0x7B, 0x66, 0x73, 0x76, 0x50, 0x52, 0x7D, 0x40, 0x54, 0x55, 0x79, 0x40, 0x49, 0x47, 0x4D, 0x74, 0x19, 0x7B, 0x6A, 0x…
阅读更多...
大数据之路 读书笔记 Day5 数据同步遇到的问题与解决方案

大数据之路 读书笔记 Day5 数据同步遇到的问题与解决方案

回顾 Day 4 数据同步Day 3 无线客户端的日志采集 1. 分库分表的处理 分库分表（Sharding）是数据库水平扩展的一种策略，当单个数据库的性能和存储能力无法满足应用需求时，可以采用分库分表来分散数据和查询负载。它通常包括两个方面…
阅读更多...
钡铼4G无线RTU助力智慧能源发展实现电网远程调控

钡铼4G无线RTU助力智慧能源发展实现电网远程调控

随着全球对清洁能源和高效能源管理的需求日益增长，智慧能源技术正逐渐成为推动可持续发展的重要驱动力。在这一背景下，钡铼4G无线远程终端单元正在为智慧能源的发展和电网的远程调控提供强有力的支持。 钡铼4G无线RTU：智慧能源的神经网络 钡…
阅读更多...
数据恢复篇：适用于 Android 的恢复工具

数据恢复篇：适用于 Android 的恢复工具

正在摆弄 Android 设备。突然，您意外删除了一张或多张图片。不用担心，您总能找到一款价格实惠的照片恢复应用。这款先进的软件可帮助 Android 用户从硬盘、安全数字 (SD) 或存储卡以及数码相机中恢复已删除的图片。 Android 上文件被删除的主要原因 在获…
阅读更多...
Blender使用(二)点线面基本操作

Blender使用(二)点线面基本操作

Blender使用之点线面 1.编辑模式 tab键进行切换，为了方便菜单调出，可以设置键位映射为拖动时的饼菜单。 设置好后，按住tab键移动鼠标(注意不要点击鼠标)，即可弹出编辑菜单。 默认是点模式，在左上角可进行点线面的切换…
阅读更多...
Linux系统OpenSSH出现漏洞（CVE-2024-6387）修复

Linux系统OpenSSH出现漏洞（CVE-2024-6387）修复

CVE-2024-6387 是一个影响 OpenSSH 服务器（sshd）的严重远程代码执行（RCE）漏洞，它允许未经身份验证的攻击者在受影响的 Linux 系统上以 root 权限执行任意代码。此漏洞尤其危险，因为它可以在不需要任何用户交…
阅读更多...
husky 和 lint-staged 构建代码项目规范

husky 和 lint-staged 构建代码项目规范

目录 前言 最简单的方法 过 scripts 来解决如果检测工具多，需要多次处理 通过 husky(哈士奇)来解决容易遗忘的问题 1. 安装 2. husky init 3. 试一试​ lint-stadge 只 lint 改动的 1. 安装 2. 修改 package.json 配置 3. 添加 npm 脚本: 4.使用 Husky…
阅读更多...
ETL数据集成丨主流ETL工具(ETLCloud、DataX、Kettle)数据传输性能大PK

ETL数据集成丨主流ETL工具(ETLCloud、DataX、Kettle)数据传输性能大PK

目前市面上的ETL工具众多，为了方便广大企业用户在选择ETL工具时有一个更直观性能方面的参考值，我们选取了目前市面上最流行的三款ETL工具（ETLCloud、DataX、Kettle）来作为本次性能传输的代表，虽然性能测试数据有很多相…
阅读更多...
类和对象 中篇

类和对象 中篇

类和对象 中篇 ​ 在上篇中，我们介绍了类的基础部分，本篇我们讲解C类的六大默认成员函数 ​ 所谓默认成员函数，就是我们不写编译器也会自动生成，自动调用的函数。而自动生成的函数对内置类型的成员不会处理(有些高版本编译器会…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023