文档反馈

问题文档片段

问题文档片段包含公式时，显示为空格。

提交类型

issue

有点复杂...

找人问问吧。

请选择提交类型

问题类型

规范和低错类

- 规范和低错类：

- 错别字或拼写错误，标点符号使用错误、公式错误或显示异常。

- 链接错误、空单元格、格式错误。

- 英文中包含中文字符。

- 界面和描述不一致，但不影响操作。

- 表述不通顺，但不影响理解。

- 版本号不匹配：如软件包名称、界面版本号。

易用性

- 易用性：

- 关键步骤错误或缺失，无法指导用户完成任务。

- 缺少主要功能描述、关键词解释、必要前提条件、注意事项等。

- 描述内容存在歧义指代不明、上下文矛盾。

- 逻辑不清晰，该分类、分项、分步骤的没有给出。

正确性

- 正确性：

- 技术原理、功能、支持平台、参数类型、异常报错等描述和软件实现不一致。

- 原理图、架构图等存在错误。

- 命令、命令参数等错误。

- 代码片段错误。

- 命令无法完成对应功能。

- 界面错误，无法指导操作。

- 代码样例运行报错、运行结果不符。

风险提示

- 风险提示：

- 对重要数据或系统存在风险的操作，缺少安全提示。

内容合规

- 内容合规：

- 违反法律法规，涉及政治、领土主权等敏感词。

- 内容侵权。

请选择问题类型

问题描述

点击输入详细问题描述，以帮助我们快速定位问题。

提交

文档反馈

mindflow.common

class mindflow.common.EvalCallback(model, eval_ds, eval_interval)

在训练期间评估模型。

参数：

• model (Model) - 测试网络。

• eval_ds (Dataset) - 用于评估模型的数据集。

• eval_interval (int) - 指定在计算之前要训练多少个epoch。

支持平台：

Ascend GPU

样例：

>>> import numpy as np
>>> import mindspore.dataset as ds
>>> import mindspore as ms
>>> from mindspore import nn
>>> from mindflow import EvalCallback
>>> loss_fn = nn.MSELoss()
>>> net = nn.Dense(2, 1)
>>> optimizer = nn.Adam(net.trainable_params(), 0.001)
>>> model = ms.train.model.Model(net, loss_fn, optimizer)
>>> data = np.array(np.random.sample(size=(5, 5)))
>>> dataset = ds.NumpySlicesDataset([data], ["data"])
>>> eval_cb = EvalCallback(model, dataset, 1)

epoch_end(run_context)

在epoch结束时评估模型。

参数：

• run_context (RunContext) - 训练运行的上下文。

class mindflow.common.L2

计算L2距离度量，即计算欧式距离。

创建输入中每个元素 $x$ 和目标 $y$ 之间的L2度量准则。

$$\text{l2}=\sqrt{\sum _{i=1}^n\frac{(y_i-x_i{)}^2}{y_i^2}}$$

这里 $y_i$ 是真值， $x_i$ 是预测值。

说明

update 方法必须使用 update(y_pred, y) 的形式调用。

支持平台：

Ascend GPU

样例：

>>> import numpy as np
>>> from mindflow.common import L2
>>> from mindspore import nn, Tensor
>>> import mindspore
...
>>> x = Tensor(np.array([0.1, 0.2, 0.6, 0.9]), mindspore.float32)
>>> y = Tensor(np.array([0.1, 0.25, 0.7, 0.9]), mindspore.float32)
>>> metric = L2()
>>> metric.clear()
>>> metric.update(x, y)
>>> result = metric.eval()
>>> print(result)
0.09543302997807275

clear()

清理内部评估结果。

eval()

计算L2度量。

返回：

Float，计算结果。

update(*inputs)

更新内部评估结果 $\text{y\_pred}$ 和 $y$。输入 y_pred 和 y 用于计算L2。

参数：

• inputs (Union[Tensor, list, numpy.array]) - y_pred 和 y 是输入 input 中位置为0和1的元素，用于计算L2的预测值和真实值。两者有相同的shape。

异常：

• ValueError - 如果输入的长度不是2。

• ValueError - 如果y_pred和y的不相同。

class mindflow.common.LossAndTimeMonitor(data_size, per_print_times=1)

监控训练中的loss。

如果loss是NAN或INF，将终止训练。

说明

如果 per_print_times 为0，则不打印loss。

参数：

• data_size (int) - 每个epoch数据集的批次数。

• per_print_times (int) - 表示每隔多少个step打印一次loss。默认值：1。

异常：

• ValueError - 如果 data_size 不是整数或小于零。

• ValueError - 如果 per_print_times 不是整数或小于零。

支持平台：

Ascend GPU

样例：

>>> from mindflow.common import LossAndTimeMonitor
>>> loss_time_monitor = LossAndTimeMonitor(8)

epoch_begin(run_context)

在epoch开始时设置开始时间。

参数：

• run_context (RunContext) - 训练运行的上下文。

epoch_end(run_context)

在epoch结束时获得损失。

参数：

• run_context (RunContext) - 训练运行的上下文。

mindflow.common.get_multi_step_lr(lr_init, milestones, gamma, steps_per_epoch, last_epoch)

epoch的数量到达其中一个milestone时，学习率按 gamma 进行衰减，生成学习率数组。

根据给定的 milestone 和 lr_init 计算学习速率。对于 milestone 为 $(M_1,M_2,...,M_t,...,M_N)$ ， lr_init 为 $(x_1,x_2,...,x_t,...,x_N)$ 。N表示 milestone 的长度。设输出学习速度为 y ，则对于第 i 步，计算decayed_learning_rate[i]的表达式为：

$$y[i]=x_t,fori\in [M_{t-1},M_t)$$

参数：

• lr_init (float) - 初始学习速率，正值。

• milestones (Union[list[int], tuple[int]]) - 学习率改变时epoch的数量，非负值。

• gamma (float) - 学习速率调整倍数。

• steps_per_epoch (int) - 每个epoch的步数，正值。

• last_epoch (int) - 总epoch的数量，正值。

返回：

Numpy.array，学习率数组。

异常：

• TypeError - 如果 lr_init 或 gamma 不是float。

• TypeError - 如果 steps_per_epoch 或 last_epoch 不是int。

• TypeError - 如果 milestones 既不是tuple也不是list。

支持平台：

Ascend GPU CPU

样例：

>>> from mindflow import get_multi_step_lr
>>> lr_init = 0.001
>>> milestones = [2, 4]
>>> gamma = 0.1
>>> steps_per_epoch = 3
>>> last_epoch = 5
>>> lr = get_multi_step_lr(lr_init, milestones, gamma, steps_per_epoch, last_epoch)
>>> print(lr)
[1.e-03 1.e-03 1.e-03 1.e-03 1.e-03 1.e-03 1.e-04 1.e-04 1.e-04 1.e-04 1.e-04 1.e-04 1.e-05 1.e-05 1.e-05]

mindflow.common.get_poly_lr(global_step, lr_init, lr_end, lr_max, warmup_steps, total_steps, poly_power)

生成指数衰减学习率数组。学习率随着训练步数进行指数衰减。

参数：

• global_step (int) - 当前步骤编号，非负值。

• lr_init (float) - 初始学习速率，正值。

• lr_end (float) - 结束学习速率，非负值。

• lr_max (float) - 最大学习速率，正值。

• warmup_steps (int) - 热身epoch的数量，非负值。

• total_steps (int) - 训练的总epoch数量，正值。

• poly_power (float) - 多学习速率的次方数，正值。

返回：

Numpy.array，学习率数组。

支持平台：

Ascend GPU

样例：

>>> from mindflow.common import get_poly_lr
>>> learning_rate = get_poly_lr(100, 0.001, 0.1, 0.0001, 1000, 10000, 0.5)
>>> print(learning_rate.shape)
(9900,)

mindflow.common.get_warmup_cosine_annealing_lr(lr_init, steps_per_epoch, last_epoch, warmup_epochs=0, warmup_lr_init=0.0, eta_min=1e-06)

基于余弦函数生成衰减学习率数组。如果指定了预热epoch，将通过线性方法对预热epoch进行预热。 对于第 i 步，计算余弦衰减的学习速率decayed_learning_rate[i]的表达式为:

$$decayed\mathrm{\_}learning\mathrm{\_}rate[i]=eta\mathrm{\_}min+0.5\ast (lr\mathrm{\_}init-eta\mathrm{\_}min)\ast (1+cos(\frac{current\mathrm{\_}epoch}{last\mathrm{\_}epoch}\pi ))$$

其中 $current\mathrm{\_}epoch=floor(\frac{i}{steps\mathrm{\_}per\mathrm{\_}epoch})$ .

如果指定了预热epoch，对于预热epoch的第 i 步，预热学习速率的计算表达式warmup_learning_rate[i]为：

$$warmup\mathrm{\_}learning\mathrm{\_}rate[i]=(lr\mathrm{\_}init-warmup\mathrm{\_}lr\mathrm{\_}init)\ast i/warmup\mathrm{\_}steps+warmup\mathrm{\_}lr\mathrm{\_}init$$

参数：

• lr_init (float) - 初始学习速率，正值。

• steps_per_epoch (int) - 每个epoch的步数，正值。

• last_epoch (int) - 总epoch的数量，正值。

• warmup_epochs (int) - 热身epoch的数量，默认：0。

• warmup_lr_init (float) - 热身初始学习速率，默认：0.0。

• eta_min (float) - 学习速率最小值，默认：1e-6。

返回：

Numpy.array，学习率数组。

异常：

• TypeError - 如果 lr_init 或 warmup_lr_init 不是float。

• TypeError - 如果 steps_per_epoch 、 warmup_epochs 或 last_epoch 不是int。

支持平台：

Ascend GPU CPU

样例：

>>> from mindflow import get_warmup_cosine_annealing_lr
>>> lr_init = 0.001
>>> steps_per_epoch = 3
>>> last_epoch = 5
>>> warmup_epochs = 1
>>> lr = get_warmup_cosine_annealing_lr(lr_init, steps_per_epoch, last_epoch, warmup_epochs=warmup_epochs)
>>> print(lr)
[3.3333333e-04 6.6666666e-04 1.0000000e-03 9.0460398e-04 9.0460398e-04
9.0460398e-04 6.5485400e-04 6.5485400e-04 6.5485400e-04 3.4614600e-04
3.4614600e-04 3.4614600e-04 9.6396012e-05 9.6396012e-05 9.6396012e-05]