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_predy 用于计算L2。

参数:
  • inputs (Union[Tensor, list, numpy.array]) - y_predy 是输入 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 进行衰减,生成学习率数组。

根据给定的 milestonelr_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,\ for\ i \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_initgamma 不是float。

  • TypeError - 如果 steps_per_epochlast_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\_learning\_rate[i] = eta\_min + 0.5 * (lr\_init - eta\_min) * (1 + cos(\frac{current\_epoch}{last\_epoch}\pi))\]

其中 \(current\_epoch = floor(\frac{i}{steps\_per\_epoch})\) .

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

\[warmup\_learning\_rate[i] = (lr\_init - warmup\_lr\_init) * i / warmup\_steps + warmup\_lr\_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_initwarmup_lr_init 不是float。

  • TypeError - 如果 steps_per_epochwarmup_epochslast_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]