diff --git a/api/source_zh_cn/index.rst b/api/source_zh_cn/index.rst index 63b9597aef3b4cb840093dc03464ecf78b457685..b0be7f217451a0096b17670e237031f2a2177b6e 100644 --- a/api/source_zh_cn/index.rst +++ b/api/source_zh_cn/index.rst @@ -6,12 +6,6 @@ MindSpore API ============= -.. toctree:: - :maxdepth: 1 - :caption: 编程指南 - - programming_guide/api_structure - .. toctree:: :maxdepth: 1 :caption: MindSpore Python API diff --git a/api/source_zh_cn/programming_guide/api_structure.md b/api/source_zh_cn/programming_guide/api_structure.md deleted file mode 100644 index 9a42ef664223fdccb211cc09fa9034ce1f1a83a7..0000000000000000000000000000000000000000 --- a/api/source_zh_cn/programming_guide/api_structure.md +++ /dev/null @@ -1,37 +0,0 @@ -# MindSpore API概述 - - - -- [MindSpore API概述](#mindsporeapi概述) - - [设计理念](#设计理念) - - [层次结构](#层次结构) - - - - - -## 设计理念 - -MindSpore源于全产业的最佳实践，向数据科学家和算法工程师提供了统一的模型训练、推理和导出等接口，支持端、边、云等不同场景下的灵活部署，推动深度学习和科学计算等领域繁荣发展。 - -MindSpore提供了动态图和静态图统一的编码方式，用户无需开发多套代码，仅变更一行代码便可切换动态图/静态图模式，从而拥有更轻松的开发调试及性能体验。 - -此外，由于MindSpore统一了单机和分布式训练的编码方式，开发者无需编写复杂的分布式策略，在单机代码中添加少量代码即可实现分布式训练，大大降低了AI开发门槛。 - -## 层次结构 - -MindSpore向用户提供了3个不同层次的API，支撑用户进行网络构建、整图执行、子图执行以及单算子执行，从低到高分别为Low-Level Python API、Medium-Level Python API以及High-Level Python API。 - -![img](./images/api_structure.png) - -- Low-Level Python API - - 第一层为低阶API，主要包括张量定义、基础算子、自动微分等模块，用户可使用低阶API轻松实现张量操作和求导计算。 - -- Medium-Level Python API - - 第二层为中阶API，其封装了低价API，提供网络层、优化器、损失函数等模块，用户可通过中阶API灵活构建神经网络和控制执行流程，快速实现模型算法逻辑。 - -- High-Level Python API - - 第三层为高阶API，其在中阶API的基础上又提供了训练推理的管理、Callback、混合精度训练等高级接口，方便用户控制整网的执行流程和实现神经网络的训练及推理。 diff --git a/api/source_zh_cn/programming_guide/images/api_structure.png b/api/source_zh_cn/programming_guide/images/api_structure.png deleted file mode 100644 index 9bb9f2c1f4402e4b404f76720725b10b27a4a89e..0000000000000000000000000000000000000000 Binary files a/api/source_zh_cn/programming_guide/images/api_structure.png and /dev/null differ diff --git a/api/source_zh_cn/programming_guide/nn.md b/api/source_zh_cn/programming_guide/nn.md deleted file mode 100644 index a1bb61ec965da01e16ed19d5d850ee92594e9ea5..0000000000000000000000000000000000000000 --- a/api/source_zh_cn/programming_guide/nn.md +++ /dev/null @@ -1,28 +0,0 @@ -# nn模块 - - - -MindSpore的nn模块是Python实现的模型组件，是对低阶API的封装，主要包括各种模型层、损失函数、优化器等。 - -同时nn也提供了部分与Primitive算子同名的接口，主要作用是对Primitive算子进行进一步封装，为用户提供更友好的API。 - -代码样例如下： -```python -import numpy as np -from mindspore.common.tensor import Tensor -import mindspore.nn as nn -import mindspore - -net = nn.PSNR() -img1 = Tensor(np.random.random((1,3,16,16)), mindspore.float32) -img2 = Tensor(np.random.random((1,3,16,16)), mindspore.float32) -output = net(img1, img2) -print("output =", output) -``` - -输出如下： -``` -output = [7.6338434] -``` - -各种模型层、损失函数、优化器等代码样例正在完善中。 diff --git a/api/source_zh_cn/programming_guide/ops.md b/api/source_zh_cn/programming_guide/ops.md deleted file mode 100644 index 53bb69f5dfd011be5b4ed47d1f440da45df482a6..0000000000000000000000000000000000000000 --- a/api/source_zh_cn/programming_guide/ops.md +++ /dev/null @@ -1,126 +0,0 @@ -# ops模块 - - - -- [ops模块](#ops模块) - - [mindspore.ops.operations](#mindsporeopsoperations) - - [mindspore.ops.functional](#mindsporeopsfunctional) - - [mindspore.ops.composite](#mindsporeopscomposite) - - - - - -MindSpore的ops模块主要存放算子相关接口，同时包含算子的校验和正反向关联的逻辑。 - -ops主要包括operations、functional和composite，可通过ops直接获取到这三类算子。 -- operations提供单个的Primtive算子。一个算子对应一个原语，是最小的执行对象，需要实例化之后使用。 -- composite提供一些预定义的组合算子，以及复杂的涉及图变换的算子，如`GradOperation`。 -- functional提供operations和composite实例化后的对象，简化算子的调用流程。 - -## mindspore.ops.operations - -operations提供了所有的Primitive算子接口，是开放给用户的最低阶算子接口。算子支持情况可查询[算子支持列表](https://www.mindspore.cn/docs/zh-CN/master/operator_list.html#mindspore-ops-operations)。 - -Primitive算子也称为算子原语，它直接封装了底层的Ascend、GPU、AICPU、CPU等多种算子的具体实现，为用户提供基础算子能力。 - -Primitive算子接口是构建高阶接口、自动微分、网络模型等能力的基础。 - -代码样例如下： -```python -import numpy as np -import mindspore -from mindspore import Tensor -import mindspore.ops.operations as P - -input_x = mindspore.Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32) -input_y = 3.0 -pow = P.Pow() -output = pow(input_x, input_y) -print("output =", output) -``` - -输出如下： -``` -output = [ 1. 8. 64.] -``` - -## mindspore.ops.functional - -为了简化没有属性的算子的调用流程，MindSpore提供了一些算子的functional版本。入参要求参考原算子的输入输出要求。算子支持情况可以查询[算子支持列表](https://www.mindspore.cn/docs/zh-CN/master/operator_list.html#mindspore-ops-functional)。 - -例如`P.Pow`算子，我们提供了functional版本的`F.tensor_pow`算子。 - -使用functional的代码样例如下： - -```python -import numpy as np -import mindspore -from mindspore import Tensor -from mindspore.ops import functional as F - -input_x = mindspore.Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32) -input_y = 3.0 -output = F.tensor_pow(input_x, input_y) -print("output =", output) -``` - -输出如下： -``` -output = [ 1. 8. 64.] -``` - -## mindspore.ops.composite - -composite提供了一些算子的组合，包括clip_by_value和random相关的一些算子，以及涉及图变换的函数（`GradOperation`、`HyperMap`和`Map`等）。 - -算子的组合可以直接像一般函数一样使用，例如使用`normal`生成一个随机分布： -```python -from mindspore.common import dtype as mstype -from mindspore.ops import composite as C -from mindspore import Tensor - -mean = Tensor(1.0, mstype.float32) -stddev = Tensor(1.0, mstype.float32) -output = C.normal((2, 3), mean, stddev, seed=5) -print("ouput =", output) -``` -输出如下： -``` -output = [[2.4911082 0.7941146 1.3117087] - [0.30582333 1.772938 1.525996]] -``` - -> 以上代码运行于MindSpore的GPU版本。 - -针对涉及图变换的函数，用户可以使用`MultitypeFuncGraph`定义一组重载的函数，根据不同类型，走到不同实现。 - -代码样例如下： -```python -import numpy as np -from mindspore.ops.composite import MultitypeFuncGraph -from mindspore import Tensor -from mindspore.ops import functional as F - -add = MultitypeFuncGraph('add') -@add.register("Number", "Number") -def add_scalar(x, y): - return F.scalar_add(x, y) - -@add.register("Tensor", "Tensor") -def add_tensor(x, y): - return F.tensor_add(x, y) - -tensor1 = Tensor(np.array([[1.2, 2.1], [2.2, 3.2]]).astype('float32')) -tensor2 = Tensor(np.array([[1.2, 2.1], [2.2, 3.2]]).astype('float32')) -print('tensor', add(tensor1, tensor2)) -print('scalar', add(1, 2)) -``` -输出如下： -``` -tensor [[2.4, 4.2] - [4.4, 6.4]] -scalar 3 -``` - -此外，高阶函数`GradOperation`提供了根据输入的函数，求这个函数对应的梯度函数的方式，详细可以参阅[API文档](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.composite.html#mindspore.ops.composite.GradOperation)。 \ No newline at end of file diff --git a/api/source_zh_cn/programming_guide/tensor.md b/api/source_zh_cn/programming_guide/tensor.md deleted file mode 100644 index c935dc71bba6a42e0174e03048f7e4d704db9bb4..0000000000000000000000000000000000000000 --- a/api/source_zh_cn/programming_guide/tensor.md +++ /dev/null @@ -1,369 +0,0 @@ -# 张量 - - - -- [张量](#张量) - - [概述](#概述) - - [常量张量](#常量张量) - - [变量张量](#变量张量) - - [张量的属性和方法](#张量的属性和方法) - - [属性](#属性) - - [方法](#方法) - - [张量操作](#张量操作) - - [结构操作](#结构操作) - - [数学运算](#数学运算) - - [广播](#广播) - - - - - -## 概述 - -张量是MindSpore网络运算中的基本数据结构，即为多维数组，分为常量张量（Tensor）和变量张量（Parameter），常量张量的值在网络中不能被改变，而变量张量的值则可以被更新。 - -张量里的数据分为不同的类型，支持的类型有int8、int16、int32、int64、uint8、uint16、uint32、uint64、float16、float32、float64、bool_，与NumPy里的数据类型一一对应。 - -不同维度的张量分别表示不同的数据，0维张量表示标量，1维张量表示向量，2维张量表示矩阵，3维张量可以表示彩色图像的RGB三通道等等。 - -> 本文档中的所有示例，都是在PyNative模式下运行的，暂不支持CPU。 - -## 常量张量 - -常量张量的值在网络中不能被改变，构造时支持传入float、int、bool、tuple、list和numpy.array。 - -Tensor作为初始值可指定dtype，如果没有指定dtype，int、float、bool分别对应int32、float32、bool_，tuple和list生成的1维Tensor数据类型与tuple和list里存放数据的类型相对应。 - -代码样例如下： - -``` -import numpy as np -from mindspore import Tensor -from mindspore.common import dtype as mstype - -x = Tensor(np.array([[1, 2], [3, 4]]), mstype.int32) -y = Tensor(1.0, mstype.int32) -z = Tensor(2, mstype.int32) -m = Tensor(True, mstype.bool_) -n = Tensor((1, 2, 3), mstype.int16) -p = Tensor([4.0, 5.0, 6.0], mstype.float64) - -print(x, "\n\n", y, "\n\n", z, "\n\n", m, "\n\n", n, "\n\n", p) -``` - -输出如下： - -``` -[[1 2] - [3 4]] - -1 - -2 - -True - -[1 2 3] - -[4. 5. 6.] -``` - -## 变量张量 - -变量张量的值在网络中可以被更新，用来表示需要被更新的参数，MindSpore使用Tensor的子类Parameter构造变量张量，构造时支持传入Tensor、Initializer或者Number。 - -代码样例如下： - -``` -import numpy as np -from mindspore import Tensor, Parameter -from mindspore.common import dtype as mstype -from mindspore.common.initializer import initializer - -x = Tensor(np.arange(2*3).reshape((2, 3))) -y = Parameter(x, name="x") -z = Parameter(initializer('ones', [1, 2, 3], mstype.float32), name='y') -m = Parameter(2.0, name='m') - -print(x, "\n\n", y, "\n\n", z, "\n\n", m) -``` - -输出如下： - -``` -[[0 1 2] - [3 4 5]] - -Parameter (name=x, value=[[0 1 2] - [3 4 5]]) - -Parameter (name=y, value=[[[1. 1. 1.] - [1. 1. 1.]]]) - -Parameter (name=m, value=2.0) -``` - -## 张量的属性和方法 -### 属性 - -张量的属性包括形状（shape）和数据类型（dtype）。 -- 形状：Tensor的shape，是一个tuple。 -- 数据类型：Tensor的的dtype，是MindSpore的一个数据类型。 - -代码样例如下： - -``` -import numpy as np -from mindspore import Tensor -from mindspore.common import dtype as mstype - -x = Tensor(np.array([[1, 2], [3, 4]]), mstype.int32) -x_shape = x.shape -x_dtype = x.dtype - -print(x_shape, x_dtype) -``` - -输出如下： - -``` -(2, 2) Int32 -``` - -### 方法 - -张量的方法包括`all`、`any`和`asnumpy`。 -- all(axis, keep_dims)：在指定维度上通过“and”操作进行归约，axis代表归约维度，keep_dims表示是否保留归约后的维度。 -- any(axis, keep_dims)：在指定维度上通过“or”操作进行归约，axis代表归约维度，keep_dims表示是否保留归约后的维度。 -- asnumpy()：将Tensor转换为NumPy的array。 - -代码样例如下： - -``` -import numpy as np -from mindspore import Tensor -from mindspore.common import dtype as mstype - -x = Tensor(np.array([[True, True], [False, False]]), mstype.bool_) -x_all = x.all() -x_any = x.any() -x_array = x.asnumpy() - -print(x_all, "\n\n", x_any, "\n\n", x_array) -``` - -输出如下： - -``` -False - -True - -[[ True True] - [False False]] - -``` - -## 张量操作 - -张量的操作主要包括张量的结构操作和数学运算。 - -### 结构操作 - -张量的结构操作主要包括张量创建、索引切片、维度变换和合并分割。 - -- 张量创建 - - MindSpore创建张量的算子有`Range`、`Fill`、`ScalarToArray`、`ScalarToTensor`、`TupleToArray`、`Cast`、`ZerosLike`、`OnesLike`等。 - - 代码样例如下： - - ``` - from mindspore.common import dtype as mstype - from mindspore.ops import operations as P - - x = P.Fill()(mstype.float32, (2, 2), 1) - y = P.ScalarToArray()(1.0) - z = P.TupleToArray()((1, 2, 3)) - - print(x, "\n\n", y, "\n\n", z) - ``` - - 输出如下： - - ``` - [[1. 1.] - [1. 1.]] - - 1.0 - - [1 2 3] - ``` - -- 索引切片 - - MindSpore的索引操作跟NumPy的索引操作保持一致，包括取值和赋值，支持整数索引、bool索引、None索引、切片索引、Tensor索引和混合索引。 - - 支持索引操作的算子主要有`Slice`、`StridedSlice`、`GatherV2`、`GatherNd`、`ScatterUpdate`、`ScatterNdUpdate`等。 - - 代码样例如下： - - ``` - import numpy as np - from mindspore import Tensor - from mindspore.common import dtype as mstype - - x = Tensor(np.arange(3*4*5).reshape((3, 4, 5)), mstype.int32) - indices = Tensor(np.array([[0, 1], [1, 2]]), mstype.int32) - y = x[:3, indices, 3] - - print(x, "\n\n", y) - ``` - - 输出如下： - - ``` - [[[ 0 1 2 3 4] - [ 5 6 7 8 9] - [10 11 12 13 14] - [15 16 17 18 19]] - [[20 21 22 23 24] - [25 26 27 28 29] - [30 31 32 33 34] - [35 36 37 38 39]] - [[40 41 42 43 44] - [45 46 47 48 49] - [50 51 52 53 54] - [55 56 57 58 59]]] - - [[[ 3 8] - [ 8 13]] - [[23 28] - [28 33]] - [[43 48] - [48 53]]] - ``` - -- 维度变化 - - MindSpore的维度变化，主要涉及shape改变、维度扩展、维度消除、转置，支持的算子有`Reshape`、`ExpandDims`、`Squeeze`、`Transpose`、Reduce类算子，具体含义如下： - - `Reshape`：改变张量的shape，改变前后张量中元素个数保持一致。 - - `ExpanDims`：在张量里插入一维，长度为1。 - - `Squeeze`：将张量里长度为1的维度消除。 - - `Transpose`：将张量转置，交换维度。 - - Reduce类算子：对张量在指定维度上按照一定计算规则进行归约，Tensor的`all`和`any`接口就是归约操作中的两种。 - - 代码样例如下： - - ``` - import numpy as np - from mindspore import Tensor - from mindspore.ops import operations as P - - x = Tensor(np.arange(2*3).reshape((1, 2, 3))) - y = P.Reshape()(x, (1, 3, 2)) - z = P.ExpandDims()(x, 1) - m = P.Squeeze(axis=0)(x) - n = P.Transpose()(x, (2, 0, 1)) - - print(x, "\n\n", y, "\n\n", z, "\n\n", m, "\n\n", n) - ``` - - 输出如下： - - ``` - [[[0 1 2] - [3 4 5]]] - - [[[0 1] - [2 3] - [4 5]]] - - [[[[0 1 2] - [3 4 5]]]] - - [[0 1 2] - [3 4 5]] - - [[[0 3]] - [[1 4]] - [[2 5]]] - - ``` - -- 合并分割 - - MindSpore可以将多个张量合并为一个，也可以将一个张量拆分成多个，支持的算子有`Pack`、`Concat`和`Split`，具体含义如下： - - `Pack`：将多个Tensor打包成一个，会增加一个维度，增加维度的长度等于参与打包算子的个数。 - - `Concat`：将多个Tensor在某一个维度上进行拼接，不会增加维度。 - - `Split`：将一个Tensor进行拆分。 - - 代码样例如下： - - ``` - import numpy as np - from mindspore import Tensor - from mindspore.ops import operations as P - - x = Tensor(np.arange(2*3).reshape((2, 3))) - y = Tensor(np.arange(2*3).reshape((2, 3))) - z = P.Pack(axis=0)((x, y)) - m = P.Concat(axis=0)((x, y)) - n = P.Split(0, 2)(x) - - print(x, "\n\n", z, "\n\n", m, "\n\n", n) - ``` - - 输出如下： - - ``` - [[0 1 2] - [3 4 5]] - - [[[0 1 2] - [3 4 5]] - [[0 1 2] - [3 4 5]]] - - [[0 1 2] - [3 4 5] - [0 1 2] - [3 4 5]] - - (Tensor(shape=[1, 3], dtype=Int64, [[0 1 2]]), Tensor(shape=[1, 3], dtype=Int64, [[3 4 5]])) - ``` - -### 数学运算 - -数学运算主要是对张量的一些数学运算上的操作，包括加减乘除、求模求余求幂、比大小等等。支持的算子包括`TensorAdd`、`Sub`、`Mul`、`RealDiv`、`FloorMod`、`FloorDiv`、`Pow`、`Maximum`、`Minimum`等。 - -## 广播 - -MindSpore支持对张量进行广播，包括显式广播和隐式广播。显式广播为算子`Tile`，隐式广播是当两个shape不一样的张量进行运算，且它们的shape满足广播的要求时，系统会自动将这两个张量广播成shape相同的张量进行运算。 - -代码样例如下： - -``` -import numpy as np -from mindspore import Tensor -from mindspore.ops import operations as P -from mindspore.common import dtype as mstype - -x = Tensor(np.arange(2*3).reshape((2, 3)), mstype.int32) -y = P.Tile()(x, (2, 3)) - -print(x, "\n\n", y) - -``` - -输出如下： - -``` -[[0 1 2] - [3 4 5]] - -[[0 1 2 0 1 2 0 1 2] - [3 4 5 3 4 5 3 4 5] - [0 1 2 0 1 2 0 1 2] - [3 4 5 3 4 5 3 4 5]] -``` diff --git a/tutorials/notebook/linear_regression.ipynb b/tutorials/notebook/linear_regression.ipynb index b67175937c7ec66376c1431e764e81fbfb150e7e..291d0a4c5b4e26470649618d4d2aa767f806acdb 100644 --- a/tutorials/notebook/linear_regression.ipynb +++ b/tutorials/notebook/linear_regression.ipynb @@ -49,7 +49,9 @@ "\n", "MindSpore版本：GPU\n", "\n", - "设置MindSpore运行配置" + "设置MindSpore运行配置\n", + "\n", + "第三方支持包：`matplotlib`，未安装此包的，可使用命令`pip install matplotlib`预先安装。" ] }, { @@ -466,7 +468,7 @@ "\n", "$$w_{ud}=w_{s}-\\alpha\\frac{\\partial{J(w_{s})}}{\\partial{w}}\\tag{11}$$\n", "\n", - "当权重$w$在更新的过程中假如临近$w_{min}$在增加或者减少一个$\\Delta{w}$，从左边或者右边越过了$w_{min}$，公式10都会使权重往反的方向移动，那么最终$w_{s}$的值会在$w_{min}$附近来回迭代，在实际训练中我们也是这样采用迭代的方式取得最优权重$w$，使得损失函数无限逼近局部最小值。" + "当权重$w$在更新的过程中假如临近$w_{min}$在增加或者减少一个$\\Delta{w}$，从左边或者右边越过了$w_{min}$，公式11都会使权重往反的方向移动，那么最终$w_{s}$的值会在$w_{min}$附近来回迭代，在实际训练中我们也是这样采用迭代的方式取得最优权重$w$，使得损失函数无限逼近局部最小值。" ] }, { @@ -546,7 +548,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "`nn.RMSProp`为完成权重更新的函数，更新方式大致为公式10，但是考虑的因素更多，具体信息请参考[官网说明](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html?highlight=rmsprop#mindspore.nn.RMSProp)。" + "`nn.RMSProp`为完成权重更新的函数，更新方式大致为公式11，但是考虑的因素更多，具体信息请参考[官网说明](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html?highlight=rmsprop#mindspore.nn.RMSProp)。" ] }, { @@ -718,7 +720,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "本次体验我们了解了线性拟合的算法原理，并在MindSpore框架下实现了相应的算法定义，了解了线性拟合这类的线性回归模型在MindSpore中的训练过程，并最终拟合出了一条接近目标函数的模型函数。另外有兴趣的可以调整数据集的生成区间从（-10,10）扩展到（-100,100），看看权重值是否更接近目标函数；调整学习率大小，看看拟合的效率是否有变化；当然也可以探索如何使用MindSpore拟合$f(x)=ax^2+bx+c$这类的二次函数或者更高阶的函数。" + "本次体验我们了解了线性拟合的算法原理，并在MindSpore框架下实现了相应的算法定义，了解了线性拟合这类的线性回归模型在MindSpore中的训练过程，并最终拟合出了一条接近目标函数的模型函数。另外有兴趣的可以调整数据集的生成区间从（-10,10）扩展到（-100,100），看看权重值是否更接近目标函数；调整学习率大小，看看拟合的效率是否有变化；当然也可以探索如何使用MindSpore拟合$f(x)=ax^2+bx+c$这类的二次函数或者更高次的函数。" ] } ], diff --git a/tutorials/source_zh_cn/quick_start/linear_regression.md b/tutorials/source_zh_cn/quick_start/linear_regression.md index 18e69319de898a00f15984d03a8725e86a8e601c..08519684932a61ed7c290095dbdc67b750bcb63b 100644 --- a/tutorials/source_zh_cn/quick_start/linear_regression.md +++ b/tutorials/source_zh_cn/quick_start/linear_regression.md @@ -52,6 +52,7 @@ MindSpore版本：GPU 设置MindSpore运行配置 +第三方支持包：`matplotlib`，未安装此包的，可使用命令`pip install matplotlib`预先安装。 ```python from mindspore import context @@ -268,7 +269,7 @@ $$w_{ud}=w_{s}-\alpha\frac{\partial{J(w_{s})}}{\partial{w}}\tag{10}$$ $$w_{ud}=w_{s}-\alpha\frac{\partial{J(w_{s})}}{\partial{w}}\tag{11}$$ -当权重$w$在更新的过程中假如临近$w_{min}$在增加或者减少一个$\Delta{w}$，从左边或者右边越过了$w_{min}$，公式10都会使权重往反的方向移动，那么最终$w_{s}$的值会在$w_{min}$附近来回迭代，在实际训练中我们也是这样采用迭代的方式取得最优权重$w$，使得损失函数无限逼近局部最小值。 +当权重$w$在更新的过程中假如临近$w_{min}$在增加或者减少一个$\Delta{w}$，从左边或者右边越过了$w_{min}$，公式11都会使权重往反的方向移动，那么最终$w_{s}$的值会在$w_{min}$附近来回迭代，在实际训练中我们也是这样采用迭代的方式取得最优权重$w$，使得损失函数无限逼近局部最小值。 同理：对于公式5中的另一个权重$b$容易得出其更新公式为： @@ -306,7 +307,7 @@ class GradWrap(nn.Cell): ### 反向传播更新权重 -`nn.RMSProp`为完成权重更新的函数，更新方式大致为公式10，但是考虑的因素更多，具体信息请参考[官网说明](https://www.mindspore.cn/api/zh-CN/r0.7/api/python/mindspore/mindspore.nn.html?highlight=rmsprop#mindspore.nn.RMSProp)。 +`nn.RMSProp`为完成权重更新的函数，更新方式大致为公式11，但是考虑的因素更多，具体信息请参考[官网说明](https://www.mindspore.cn/api/zh-CN/r0.7/api/python/mindspore/mindspore.nn.html?highlight=rmsprop#mindspore.nn.RMSProp)。 ```python @@ -400,4 +401,4 @@ print("weight:", net.weight.default_input[0][0], "bias:", net.bias.default_input ## 总结 -本次体验我们了解了线性拟合的算法原理，并在MindSpore框架下实现了相应的算法定义，了解了线性拟合这类的线性回归模型在MindSpore中的训练过程，并最终拟合出了一条接近目标函数的模型函数。另外有兴趣的可以调整数据集的生成区间从（-10,10）扩展到（-100,100），看看权重值是否更接近目标函数；调整学习率大小，看看拟合的效率是否有变化；当然也可以探索如何使用MindSpore拟合$f(x)=ax^2+bx+c$这类的二次函数或者更高阶的函数。 +本次体验我们了解了线性拟合的算法原理，并在MindSpore框架下实现了相应的算法定义，了解了线性拟合这类的线性回归模型在MindSpore中的训练过程，并最终拟合出了一条接近目标函数的模型函数。另外有兴趣的可以调整数据集的生成区间从（-10,10）扩展到（-100,100），看看权重值是否更接近目标函数；调整学习率大小，看看拟合的效率是否有变化；当然也可以探索如何使用MindSpore拟合$f(x)=ax^2+bx+c$这类的二次函数或者更高次的函数。