目录
从 MindSpore 模块中导入nn和ops
将 MindSpore 整个模块引入到当前的 Python 脚本里，方便后续运用 MindSpore 所提供的各类功能与类。从 MindSpore 模块中单独导入“nn”（一般代表神经网络相关的类和函数）以及“ops”（通常指操作符相关的功能），如此一来，在后续的代码中就能够直接使用“nn”和“ops”，而无需添加“mindspore.”这个前缀，让代码变得更加简洁、更易于阅读。
代码如下：
import mindspore
from mindspore import nn, ops 定义模型类
当我们定义神经网络时，可以继承nn.Cell类，在__init__方法中进行子Cell的实例化和状态管理，在construct方法中实现Tensor操作。
代码如下：
#用 MindSpore 框架定义了一个名为 Network 的类，它继承自 nn.Cell
class Network(nn.Cell):
#在 __init__ 方法（构造函数）中进行了一些初始化操作
def __init__(self):
#用于调用父类（即 nn.Cell ）的构造函数。
super().__init__()
#定义了 flatten 为 nn.Flatten 对象。
self.flatten = nn.Flatten()
#定义了 dense_relu_sequential 为一个包含多层全连接层（nn.Dense ）和激活函数（nn.ReLU ）的序列。
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")
)
#construct 方法用于定义前向传播的计算过程。
def construct(self, x):
x = self.flatten(x)
logits = self.dense_relu_sequential(x)
return logits
#然后创建了 Network 类的实例 model ，并打印出 model 的相关信息。
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输出，其包含每个类别的原始预测值。
代码如下：
X = ops.ones((1, 28, 28), mindspore.float32)
logits = model(X)
# print logits
logits 分析：在这段代码里，“X = ops.ones((1, 28, 28), mindspore.float32)”创建了一个 3 维的张量 X，其中所有元素都是 1，形状为(1, 28, 28)，数据类型是 mindspore.float32。
“logits = model(X)” 表示将这个 X 作为输入传递给之前定义的名为 model 的模型进行计算，计算得到的结果被存储在 logits 变量中。
所以，这里的“logits”指的是模型对特定输入 X 进行处理和计算后所产生的输出值。
运行结果：
Tensor(shape=[1, 10], dtype=Float32, value=
[[ 4.24947031e-03, -3.66483117e-03, -2.42522405e-03 ... -5.67489350e-03, -8.09418689e-03, 3.98061844e-03]])
在此基础上，我们通过一个nn.Softmax层实例来获得预测概率。
代码如下：
pred_probab = nn.Softmax(axis=1)(logits)
y_pred = pred_probab.argmax(1)
print(f"Predicted class: {y_pred}") 分析：pred_probab = nn.Softmax(axis=1)(logits) 对 logits 进行 Softmax 运算，沿着第 1 个维度（通常是类别维度）计算概率分布，结果存储在 pred_probab 中。
y_pred = pred_probab.argmax(1) 从计算得到的概率分布 pred_probab 中，沿着第 1 个维度找出最大值的索引，将结果存储在 y_pred 中。
print(f"Predicted class: {y_pred}") 打印出预测的类别，即 y_pred 的值。
总的来说，这段代码是对模型的输出 logits 进行处理，得到预测的类别并打印输出。
运行结果：
Predicted class: [5]
模型层
首先我们构造一个shape为(3, 28, 28)的随机数据（3个28x28的图像），依次通过每一个神经网络层来观察其效果。
代码如下：
input_image = ops.ones((3, 28, 28), mindspore.float32)
print(input_image.shape) 分析：首先使用 ops 中的 ones 函数创建一个元素全为 1 的张量 input_image ，这个张量的形状是 (3, 28, 28) ，数据类型是 mindspore.float32 。然后使用 print 函数输出这个张量的形状。
ops.ones((3, 28, 28), mindspore.float32) 表示创建一个 3 维的张量，第一个维度大小为 3，第二个维度大小为 28，第三个维度大小为 28，并且元素值都为 1，数据类型为单精度浮点数。
print(input_image.shape) 用于打印出 input_image 张量的形状信息。
运行结果：
(3, 28, 28)
nn.Flatten
实例化nn.Flatten层，将28x28的2D张量转换为784大小的连续数组。
代码如下：
flatten = nn.Flatten()
flat_image = flatten(input_image)
print(flat_image.shape)分析：首先，创建了一个名为 flatten 的对象，它是由 nn 模块中的 Flatten 类实例化得到的。Flatten 通常用于将多维的输入张量展平为一维。
然后，使用这个 flatten 对象对 input_image 进行处理，得到展平后的张量 flat_image 。
最后，打印出 flat_image 的形状。
总的来说，这段代码的目的是将一个多维的张量 input_image 展平，并查看展平后的形状。
运行结果：
(3, 784)
nn.Dense
nn.Dense为全连接层，其使用权重和偏差对输入进行线性变换。
代码如下：
layer1 = nn.Dense(in_channels=28*28, out_channels=20)
hidden1 = layer1(flat_image)
print(hidden1.shape) 分析：首先，创建了一个名为 layer1 的全连接层（Dense 层）对象。该层的输入通道数（in_channels）为 28*28 ，输出通道数（out_channels）为 20。
然后，将展平后的张量 flat_image 作为输入传递给这个全连接层 layer1 ，得到输出张量 hidden1 。
最后，打印出 hidden1 的形状。
这段代码主要是构建了一个全连接层，并对输入数据进行处理，以观察输出的形状特征。
运行结果：
(3, 20)
nn.ReLU
nn.ReLU层给网络中加入非线性的激活函数，帮助神经网络学习各种复杂的特征。
代码如下：
print(f"Before ReLU: {hidden1}\n\n")
hidden1 = nn.ReLU()(hidden1)
print(f"After ReLU: {hidden1}") 分析：首先，使用格式化字符串 f-string 打印出一条信息 Before ReLU: {hidden1}\n\n ，其中 {hidden1} 会被 hidden1 的值替换。\n\n 表示两个换行符，用于在输出中增加一些空白行。
接下来，将 hidden1 作为输入传递给 nn.ReLU() 激活函数进行处理，并将处理后的结果再次赋值给 hidden1 。
最后，再次使用 f-string 打印出信息 After ReLU: {hidden1} ，展示经过 ReLU 激活函数处理后的 hidden1 的值。
总的来说，这段代码的目的是先打印出激活前的 hidden1 的值，然后对其应用 ReLU 激活函数，再打印出激活后的结果。
运行结果：
#先打印
Before ReLU: [[ 0.3087794 0.9850689 -0.4070658 -0.701891 0.18653367 0.33947796
0.16613327 -0.09155615 -0.24978569 -0.4789814 -0.15506613 0.15600255
-0.25922856 0.89553624 0.4162153 -0.1209818 -1.3496804 -1.0204036
0.36344895 0.10704644]
[ 0.3087794 0.9850689 -0.4070658 -0.701891 0.18653367 0.33947796
0.16613327 -0.09155615 -0.24978569 -0.4789814 -0.15506613 0.15600255
-0.25922856 0.89553624 0.4162153 -0.1209818 -1.3496804 -1.0204036
0.36344895 0.10704644]
[ 0.3087794 0.9850689 -0.4070658 -0.701891 0.18653367 0.33947796
0.16613327 -0.09155615 -0.24978569 -0.4789814 -0.15506613 0.15600255
-0.25922856 0.89553624 0.4162153 -0.1209818 -1.3496804 -1.0204036
0.36344895 0.10704644]]
#后打印
After ReLU: [[0.3087794 0.9850689 0. 0. 0.18653367 0.33947796
0.16613327 0. 0. 0. 0. 0.15600255
0. 0.89553624 0.4162153 0. 0. 0.
0.36344895 0.10704644]
[0.3087794 0.9850689 0. 0. 0.18653367 0.33947796
0.16613327 0. 0. 0. 0. 0.15600255
0. 0.89553624 0.4162153 0. 0. 0.
0.36344895 0.10704644]
[0.3087794 0.9850689 0. 0. 0.18653367 0.33947796
0.16613327 0. 0. 0. 0. 0.15600255
0. 0.89553624 0.4162153 0. 0. 0.
0.36344895 0.10704644]]
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) 分析：创建了一个名为 seq_modules 的顺序模块（SequentialCell）对象，该模块依次包含了之前定义的 flatten（展平操作）、layer1（全连接层）、ReLU 激活函数和另一个全连接层 nn.Dense(20, 10)（输入大小为 20，输出大小为 10）。
然后，将 input_image 作为输入传递给这个顺序模块 seq_modules ，得到输出 logits 。
最后，打印出 logits 的形状。
总的来说，这段代码构建了一个包含多个层的神经网络模块，并对输入图像进行处理，查看最终输出的形状。
运行结果：
(3, 10)
nn.Softmax
最后使用nn.Softmax将神经网络最后一个全连接层返回的logits的值缩放为[0, 1]，表示每个类别的预测概率。axis指定的维度数值和为1。
代码如下：
softmax = nn.Softmax(axis=1)
pred_probab = softmax(logits) 分析：首先，创建了一个 Softmax 激活函数对象 softmax ，并指定了在维度 1 上进行 Softmax 运算。
然后，将之前得到的 logits 作为输入传递给这个 Softmax 激活函数，得到的结果赋值给 pred_probab 。
Softmax 函数通常用于将输入值转换为概率分布，使得所有值都在 0 到 1 之间，并且总和为 1。在这种情况下，它将 logits 转换为预测的概率分布。
模型参数
网络内部神经网络层具有权重参数和偏置参数（如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") 分析：首先，使用 f-string 打印出模型的结构信息，{model} 会被模型对象的相关描述替换。
然后，通过遍历模型 model 的参数及其名称。对于每个参数，打印出参数所在的层的名称 name ，参数的形状 param.shape ，以及参数的前两个值 param[:2] 。
总的来说，这段代码用于展示模型的结构以及每个层参数的一些基本信息，例如名称、形状和部分值。
运行结果：
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.0009794 0.01165624 0.00053267 ... -0.00562098 -0.01562027
-0.00652531]
[ 0.02572156 0.00160113 0.00114276 ... 0.00846921 0.00206852
-0.00754631]]
Layer: dense_relu_sequential.0.bias
Size: (512,)
Values : [0. 0.]
Layer: dense_relu_sequential.2.weight
Size: (512, 512)
Values : [[ 0.00148492 0.00554596 -0.00087604 ... -0.00471109 0.02263027
-0.00198138]
[-0.01316851 -0.0110001 -0.03218061 ... 0.01434446 0.00147917
-0.0073973 ]]
Layer: dense_relu_sequential.2.bias
Size: (512,)
Values : [0. 0.]
Layer: dense_relu_sequential.4.weight
Size: (10, 512)
Values : [[ 0.00122466 0.01266199 -0.0085449 ... 0.00097986 0.00859538
0.00752004]
[-0.01058272 0.00683428 0.01345662 ... 0.00476388 -0.00335832
-0.01059606]]
Layer: dense_relu_sequential.4.bias
Size: (10,)
Values : [0. 0.] 打印时间：
import time
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()),"qianduanjidi")运行截图：
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
