Skip to content

D
docs

MindSpore / docs

通知 4
Star 2
Fork 2
D
docs
提交 e434f581 编写于 作者: L lvmingfu
浏览文件
操作

modify files in docs for r0.7

上级 f7f6c916
隐藏空白更改
内联 并排
Showing with 10 addition and 573 deletion
api/source_zh_cn/index.rst
浏览文件 @ e434f581
......@@ -6,12 +6,6 @@
MindSpore API
=============
.. toctree::
:maxdepth: 1
:caption: 编程指南
programming_guide/api_structure
.. toctree::
:maxdepth: 1
:caption: MindSpore Python API
......
api/source_zh_cn/programming_guide/api_structure.md 已删除 100644 → 0
浏览文件 @ f7f6c916
# MindSpore API概述
<!-- TOC -->
- [MindSpore API概述](#mindsporeapi概述)
- [设计理念](#设计理念)
- [层次结构](#层次结构)
<!-- /TOC -->
<a href="https://gitee.com/mindspore/docs/blob/master/api/source_zh_cn/programming_guide/api_structure.md" target="_blank"><img src="../_static/logo_source.png"></a>
## 设计理念
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、混合精度训练等高级接口，方便用户控制整网的执行流程和实现神经网络的训练及推理。
api/source_zh_cn/programming_guide/nn.md 已删除 100644 → 0
浏览文件 @ f7f6c916
# nn模块
<a href="https://gitee.com/mindspore/docs/blob/master/api/source_zh_cn/programming_guide/nn.md" target="_blank"><img src="../_static/logo_source.png"></a>
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]
```
各种模型层、损失函数、优化器等代码样例正在完善中。
api/source_zh_cn/programming_guide/ops.md 已删除 100644 → 0
浏览文件 @ f7f6c916
# ops模块
<!-- TOC -->
- [ops模块](#ops模块)
- [mindspore.ops.operations](#mindsporeopsoperations)
- [mindspore.ops.functional](#mindsporeopsfunctional)
- [mindspore.ops.composite](#mindsporeopscomposite)
<!-- /TOC -->
<a href="https://gitee.com/mindspore/docs/blob/master/api/source_zh_cn/programming_guide/ops.md" target="_blank"><img src="../_static/logo_source.png"></a>
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
api/source_zh_cn/programming_guide/tensor.md 已删除 100644 → 0
浏览文件 @ f7f6c916
# 张量
<!-- TOC -->
- [张量](#张量)
- [概述](#概述)
- [常量张量](#常量张量)
- [变量张量](#变量张量)
- [张量的属性和方法](#张量的属性和方法)
- [属性](#属性)
- [方法](#方法)
- [张量操作](#张量操作)
- [结构操作](#结构操作)
- [数学运算](#数学运算)
- [广播](#广播)
<!-- /TOC -->
<a href="https://gitee.com/mindspore/docs/blob/master/api/source_zh_cn/programming_guide/tensor.md" target="_blank"><img src="../_static/logo_source.png"></a>
## 概述
张量是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]]
```
tutorials/notebook/linear_regression.ipynb
浏览文件 @ e434f581
......@@ -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$这类的二次函数或者更高次的函数。"
]
}
],
......
tutorials/source_zh_cn/quick_start/linear_regression.md
浏览文件 @ e434f581
......@@ -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$这类的二次函数或者更高次的函数。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或