网络构建

有些基本概念和知识，需要在进一步学习前予以明确一下。

神经网络算法：

思维学普遍认为，人类大脑的思维分为抽象（逻辑）思维、形象（直观）思维和灵感（顿悟）思维三种基本方式。

逻辑性的思维是指根据逻辑规则进行推理的过程；它先将信息化成概念，并用符号表示，然后，根据符号运算按串行模式进行逻辑推理；这一过程可以写成串行的指令，让计算机执行。这就是传统的程序员的编程方式。

然而，直观性的思维是将分布式存储的信息综合起来，结果是忽然间产生的想法或解决问题的办法。这种思维方式的根本之点在于以下两点：1.信息是通过神经元上的兴奋模式分布存储在网络上；2.信息处理是通过神经元之间同时相互作用的动态过程来完成的。
人工神经网络就是模拟人思维的第二种方式。这是一个非线性动力学系统，其特色在于信息的分布式存储和并行协同处理。虽然单个神经元的结构极其简单，功能有限，但大量神经元构成的网络系统所能实现的行为却是极其丰富多彩的。
 

以前。程序员，写程序，是先了解需求。其实就是了解一个数据处理的流程。然后数据结构，算法，写代码。

现在，考虑的是。使用什么神经网络模型。再次打比方，神经网络模型对应于不同的思维模式。是鱼的思维模式？还是动物的思维模式？

然后考虑怎么用什么数据集训练，是水中的环境数据？还是陆地的生存数据？

当然目前的神经网络模型还很有限。做不到真实自然界中的复杂神经模型。选择的数量还不是很多。我们现在学习的也就是如何运用好这些模型，来创造一些神奇的应用来。

这个学习的基础，就是要放弃传统的编程模式，改为神经网络编程模式。

再次强调，以上心得全属个人体验。不对之处欢迎大家指正，

网络构建

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

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

[1]:

%%capture captured_output

# 实验环境已经预装了mindspore==2.2.14，如需更换mindspore版本，可更改下面mindspore的版本号

!pip uninstall mindspore -y

!pip install -i https://pypi.mirrors.ustc.edu.cn/simple mindspore==2.2.14

[2]:

import mindspore

from mindspore import nn, ops

定义模型类

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

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

[3]:

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对象，并查看其结构。

[4]:

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()方法不可直接调用。

[5]:

X = ops.ones((1, 28, 28), mindspore.float32)

logits = model(X)

# print logits

logits

[5]:

Tensor(shape=[1, 10], dtype=Float32, value=
[[ 1.24741532e-03,  8.70083924e-03,  2.72330875e-03 ...  4.06273827e-03, -1.69203244e-03,  1.60523364e-03]])

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

[6]:

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

y_pred = pred_probab.argmax(1)

print(f"Predicted class: {y_pred}")

Predicted class: [1]

模型层

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

[7]:

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

print(input_image.shape)

(3, 28, 28)

nn.Flatten

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

[8]:

flatten = nn.Flatten()

flat_image = flatten(input_image)

print(flat_image.shape)

(3, 784)

nn.Dense

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

[9]:

layer1 = nn.Dense(in_channels=28*28, out_channels=20)

hidden1 = layer1(flat_image)

print(hidden1.shape)

(3, 20)

nn.ReLU

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

[10]:

print(f"Before ReLU: {hidden1}\n\n")

hidden1 = nn.ReLU()(hidden1)

print(f"After ReLU: {hidden1}")

Before ReLU: [[-1.1220896  -1.1263387  -0.32725674 -0.38023567 -0.00126252 -0.4972393
  -0.12831879  0.9653305  -1.0972991  -0.47796312  0.1628657   0.31285125
  -0.02965128 -0.6688667   0.3363133  -0.94191     0.48275143 -0.57251483
  -0.00868414 -0.02906343]
 [-1.1220896  -1.1263387  -0.32725674 -0.38023567 -0.00126252 -0.4972393
  -0.12831879  0.9653305  -1.0972991  -0.47796312  0.1628657   0.31285125
  -0.02965128 -0.6688667   0.3363133  -0.94191     0.48275143 -0.57251483
  -0.00868414 -0.02906343]
 [-1.1220896  -1.1263387  -0.32725674 -0.38023567 -0.00126252 -0.4972393
  -0.12831879  0.9653305  -1.0972991  -0.47796312  0.1628657   0.31285125
  -0.02965128 -0.6688667   0.3363133  -0.94191     0.48275143 -0.57251483
  -0.00868414 -0.02906343]]


After ReLU: [[0.         0.         0.         0.         0.         0.
  0.         0.9653305  0.         0.         0.1628657  0.31285125
  0.         0.         0.3363133  0.         0.48275143 0.
  0.         0.        ]
 [0.         0.         0.         0.         0.         0.
  0.         0.9653305  0.         0.         0.1628657  0.31285125
  0.         0.         0.3363133  0.         0.48275143 0.
  0.         0.        ]
 [0.         0.         0.         0.         0.         0.
  0.         0.9653305  0.         0.         0.1628657  0.31285125
  0.         0.         0.3363133  0.         0.48275143 0.
  0.         0.        ]]

nn.SequentialCell

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

[11]:

seq_modules = nn.SequentialCell(

    flatten,

    layer1,

    nn.ReLU(),

    nn.Dense(20, 10)

)

​

logits = seq_modules(input_image)

print(logits.shape)

(3, 10)

nn.Softmax

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

[12]:

softmax = nn.Softmax(axis=1)

pred_probab = softmax(logits)

模型参数

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

[13]:

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.01497326 -0.00296977 -0.00319311 ...  0.01000426  0.01317673
   0.00763267]
 [-0.00312469 -0.01605173 -0.0059301  ...  0.01658189 -0.01676002
   0.00475211]] 

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

Layer: dense_relu_sequential.2.weight
Size: (512, 512)
Values : [[ 0.00298386 -0.00523345  0.00564275 ... -0.00538902  0.01216204
   0.00763943]
 [ 0.01283401  0.01129468  0.01145692 ...  0.00057711 -0.00423607
   0.00815132]] 

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

Layer: dense_relu_sequential.4.weight
Size: (10, 512)
Values : [[-0.01729099 -0.00091905  0.00958878 ...  0.00464309 -0.00097861
   0.00312116]
 [-0.00350157 -0.00010133 -0.00455134 ... -0.00303722  0.01799901
   0.01484223]] 

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

更多内置神经网络层详见mindspore.nn API。

[14]:

import time

​

print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),'guojun0718')

​

2024-07-12 14:41:34 guojun0718

[ ]:

​