forked from mindspore-Ecosystem/mindspore
udpate api
This commit is contained in:
parent
fe0e61e6cd
commit
7a962c2b56
|
|
@ -1,380 +1,324 @@
|
|||
mindspore.context
|
||||
=================
|
||||
|
||||
.. py:class:: mindspore.context
|
||||
|
||||
MindSpore上下文，用于配置当前执行环境，包括执行模式、执行后端和其他特性开关。
|
||||
|
||||
.. py:function:: set_context(**kwargs)
|
||||
|
||||
设置运行环境的上下文。
|
||||
|
||||
在运行程序之前，应配置上下文。如果没有配置，默认情况下将根据设备目标进行自动设置。
|
||||
|
||||
.. note::
|
||||
设置属性时，必须输入属性名称。初始化网络后不建议更改模式，因为某些操作在图模式和PyNative模式下是不同的。默认值：GRAPH_MODE。
|
||||
|
||||
某些配置适用于特定的设备，有关详细信息，请参见下表：
|
||||
|
||||
+-------------------------+------------------------------+----------------------------+
|
||||
| 功能分类 | 配置参数 | 硬件平台支持|
|
||||
+=========================+==============================+============================+
|
||||
| 系统配置 | device_id | CPU/GPU/Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | device_target | CPU/GPU/Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | max_device_memory | GPU |
|
||||
| +------------------------------+----------------------------+
|
||||
| | variable_memory_max_size | Ascend |
|
||||
+-------------------------+------------------------------+----------------------------+
|
||||
| 调试配置 | save_graphs | CPU/GPU/Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | save_graphs_path | CPU/GPU/Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | enable_dump | Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | save_dump_path | Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | enable_profiling | Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | profiling_options | Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | print_file_path | Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | env_config_path | CPU/GPU/Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | precompile_only | CPU/GPU/Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | reserve_class_name_in_scope | CPU/GPU/Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | pynative_synchronize | GPU/Ascend |
|
||||
+-------------------------+------------------------------+----------------------------+
|
||||
| 执行控制 | mode | CPU/GPU/Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | enable_graph_kernel | Ascend/GPU |
|
||||
| +------------------------------+----------------------------+
|
||||
| | graph_kernel_flags | Ascend/GPU |
|
||||
| +------------------------------+----------------------------+
|
||||
| | enable_reduce_precision | Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | auto_tune_mode | Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | check_bprop | CPU/GPU/Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | max_call_depth | CPU/GPU/Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | enable_sparse | CPU/GPU/Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | grad_for_scalar | CPU/GPU/Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | save_compile_cache | CPU/GPU/Ascend |
|
||||
| +------------------------------+----------------------------+
|
||||
| | load_compile_cache | CPU/GPU/Ascend |
|
||||
+-------------------------+------------------------------+----------------------------+
|
||||
|
||||
**参数：**
|
||||
|
||||
- **device_id** (int)：表示目标设备的ID，其值必须在[0, device_num_per_host-1]范围中，且 `device_num_per_host` 的值不应超过4096。默认值：0。
|
||||
- **device_target** (str)：表示待运行的目标设备，支持Ascend、GPU和CPU。如果未设置设备目标，则使用MindSpore包的版本。
|
||||
- **max_device_memory** (str)：设置设备可用的最大内存。目前，仅在GPU上支持。格式为“xxGB”。默认值：1024GB。实际使用的内存大小是设备的可用内存和 `max_device_memory` 值中的最小值。
|
||||
- **variable_memory_max_size** (str)：设置可变内存的最大值。默认值：30GB。设置此参数后，框架使用的最大内存受配置值的限制。
|
||||
- **save_graphs** (bool)：表示是否保存图形。默认值：False。当 `save_graphs` 属性设为True时， `save_graphs_path` 属性用于设置中间编译图的存储路径。默认情况下，图形保存在当前目录下。
|
||||
- **save_graphs_path** (str)：表示保存图形的路径。默认值："."。如果指定的目录不存在，系统将自动创建该目录。在分布式训练中，图形将被保存到 `save_graphs_path/rank_${rank_id}/` 目录下。 `rank_id` 为集群中当前设备的ID。
|
||||
- **enable_dump** (bool)：此参数已弃用，将在下一版本中删除。
|
||||
- **save_dump_path** (str)：此参数已弃用，将在下一版本中删除。
|
||||
- **enable_profiling** (bool)：此参数已弃用，将在下一版本中删除。请使用mindspore.profiler.Profiler API。
|
||||
- **profiling_options** (str)：此参数已弃用，将在下一版本中删除。请使用mindspore.profiler.Profiler API。
|
||||
- **print_file_path** (str)：表示用于保存打印数据的路径。如果设置了该参数，默认将打印数据保存到文件中。如果不设置 `print_file_path` ，则显示该屏幕。如果保存的文件已经存在，将添加时间戳后缀到文件中。将数据保存到文件中，解决了在产生大量数据时屏幕打印中数据丢失的问题。如果没有设置该参数，则会报错：prompt to set the upper absolute path。
|
||||
- **env_config_path** (str)：通过context.set_context(env_config_path="./mindspore_config.json")来配置DFX的路径。
|
||||
|
||||
配置Running Data Recorder：
|
||||
|
||||
- **enable**：表示在发生故障时是否启用Running Data Recorder去收集和保存训练中的关键数据。设置为True时，将打开Running Data Recorder。设置为False时，将关闭Running Data Recorder。
|
||||
- **path**：设置Running Data Recorder保存数据的路径。当前路径必须是一个绝对路径。
|
||||
|
||||
内存重用：
|
||||
|
||||
- **mem_Reuse**：表示内存复用功能是否打开。设置为True时，将打开内存复用功能。设置为False时，将关闭内存复用功能。
|
||||
|
||||
- **precompile_only** (bool)：表示是否仅预编译网络。默认值：False。设置为True时，仅编译网络，而不执行网络。
|
||||
- **reserve_class_name_in_scope** (bool)：表示是否将网络类名称保存到所属作用域中。默认值：True。每个节点都有一个作用域。子节点的作用域是其父节点。如果 `reserve_class_name_in_scope` 设置为True，则类名将保存在作用域中的关键字“net-”之后。例如：
|
||||
|
||||
Default/net-Net1/net-Net2 (reserve_class_name_in_scope=True)
|
||||
|
||||
Default/net/net (reserve_class_name_in_scope=False)
|
||||
|
||||
- **pynative_synchronize** (bool)：表示是否在PyNative模式下启动设备同步执行。默认值：False。设置为False时，将在设备上异步执行算子。当算子执行出错时，将无法定位特定错误脚本代码的位置。当设置为True时，将在设备上同步执行算子。这将降低程序的执行性能。此时，当算子执行出错时，可以根据错误的调用栈来定位错误脚本代码的位置。
|
||||
- **mode** (int)：表示在GRAPH_MODE(0)或PYNATIVE_MODE(1)模式中的运行。默认值：GRAPH_MODE(0)。GRAPH_MODE或PYNATIVE_MODE可以通过 `mode` 属性设置，两种模式都支持所有后端。默认模式为GRAPH_MODE。
|
||||
- **enable_graph_kernel** (bool)：表示是否启用图算融合去优化网络执行性能。默认值：False。表示是否启用图算融合去优化网络执行性能。如果 `enable_graph_kernel` 设置为True，则可以启用加速。有关图算融合的详细信息，请查看`使能图算融合`（https://www.mindspore.cn/docs/programming_guide/zh-CN/master/enable_graph_kernel_fusion.html）。
|
||||
- **graph_kernel_flags** (str)：图算融合的优化选项，当与enable_graph_kernel冲突时，它的优先级更高。其仅适用于有经验的用户。例如，context.set_context(graph_kernel_flags="--opt_level=2 --dump_as_text")。一些常用选项：
|
||||
|
||||
- **opt_level**：设置优化级别。默认值：2。当opt_level的值大于0时，启动图算融合。可选值包括：
|
||||
|
||||
- 0：关闭图算融合。
|
||||
- 1：启动算子的基本融合。
|
||||
- 2：包括级别1的所有优化，并打开更多的优化，如CSE优化算法、算术简化等。
|
||||
- 3：包括级别2的所有优化，并打开更多的优化，如SitchingFusion、ParallelFusion等。在某些场景下，该级别的优化激进且不稳定。使用此级别时要小心。
|
||||
|
||||
- **dump_as_text**：将详细信息转储为文本文件。默认值：False。
|
||||
|
||||
有关更多选项，可以参考实现代码。
|
||||
|
||||
- **enable_reduce_precision** (bool)：表示是否开启降低精度计算。默认值：True。设置为True时，不支持用户指定的精度，且精度将自动更改。设置为False时，如果未指定用例的精度，则会报错并退出。
|
||||
- **auto_tune_mode** (str)：表示算子构建时的自动调整模式，以获得最佳的切分性能。默认值：NO_TUNE。其值必须在['RL', 'GA', 'RL,GA']范围中。
|
||||
|
||||
- RL：强化学习调优。
|
||||
- GA：遗传算法调优。
|
||||
- RL，GA：当RL和GA优化同时打开时，工具会根据网络模型中的不同算子类型自动选择RL或GA。RL和GA的顺序没有区别。（自动选择）。
|
||||
|
||||
|
||||
有关启用算子调优工具设置的更多信息，请查看 `使能算子调优工具 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/enable_auto_tune.html>`_。
|
||||
|
||||
- **check_bprop** (bool)：表示是否检查反向传播节点，以确保反向传播节点输出的形状(shape)和数据类型与输入参数相同。默认值：False。
|
||||
- **max_call_depth** (int)：指定函数调用的最大深度。其值必须为正整数。默认值：1000。当嵌套Cell太深或子图数量太多时，需要设置 `max_call_depth` 参数。如果 `max_call_depth` 的值比以前的大，则应把系统最大堆栈深度设得更大，否则可能会因为系统堆栈溢出而引发 `core dumped` 异常。
|
||||
- **enable_sparse** (bool)：表示是否启用稀疏特征。默认值：False。有关稀疏特征和稀疏张量的详细信息，请查看 `稀疏张量 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/tensor.html#sparse-tensor>`_。
|
||||
- **grad_for_scalar** (bool)： 表示是否获取标量梯度。默认值：False。当 `grad_for_scalar` 设置为True时，则衍生函数的标量输入。默认值为False。由于后端目前不支持伸缩操作，所以该接口只支持在前端可推演的简单操作。
|
||||
- **enable_compile_cache** (bool)：表示是否加载或者保存前端编译的图。当 `enable_compile_cache` 被设置为True时，在第一次执行的过程中，一个硬件无关的编译缓存会被生成并且导出为一个MINDIR文件。当该网络被再次执行时，如果 `enable_compile_cache` 仍然为True并且网络脚本没有被更改，那么这个编译缓存会被加载。注意目前只支持有限的Python脚本更改的自动检测，这意味着可能有正确性风险。默认值：False。这是一个实验原型，可能会被更改或者删除。
|
||||
- **compile_cache_path** (str)：保存前端图编译缓存的路径。默认值："."。如果目录不存在，系统会自动创建这个目录。缓存会被保存到如下目录：`compile_cache_path/rank_${rank_id}/`。`rank_id` 是集群上当前设备的ID。
|
||||
|
||||
**异常：**
|
||||
|
||||
**ValueError**：输入key不是上下文中的属性。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> context.set_context(mode=context.PYNATIVE_MODE)
|
||||
>>> context.set_context(precompile_only=True)
|
||||
>>> context.set_context(device_target="Ascend")
|
||||
>>> context.set_context(device_id=0)
|
||||
>>> context.set_context(save_graphs=True, save_graphs_path="./model.ms")
|
||||
>>> context.set_context(enable_reduce_precision=True)
|
||||
>>> context.set_context(enable_dump=True, save_dump_path=".")
|
||||
>>> context.set_context(enable_graph_kernel=True)
|
||||
>>> context.set_context(graph_kernel_flags="--opt_level=2 --dump_as_text")
|
||||
>>> context.set_context(reserve_class_name_in_scope=True)
|
||||
>>> context.set_context(variable_memory_max_size="6GB")
|
||||
>>> context.set_context(enable_profiling=True,
|
||||
... profiling_options='{"output":"/home/data/output","training_trace":"on"}')
|
||||
>>> context.set_context(check_bprop=True)
|
||||
>>> context.set_context(max_device_memory="3.5GB")
|
||||
>>> context.set_context(print_file_path="print.pb")
|
||||
>>> context.set_context(enable_sparse=True)
|
||||
>>> context.set_context(max_call_depth=80)
|
||||
>>> context.set_context(env_config_path="./env_config.json")
|
||||
>>> context.set_context(auto_tune_mode="GA,RL")
|
||||
>>> context.set_context(grad_for_scalar=True)
|
||||
>>> context.set_context(save_compile_cache=True)
|
||||
>>> context.set_context(load_compile_cache=True)
|
||||
>>> context.set_context(pynative_synchronize=True)
|
||||
|
||||
.. py:function:: get_context(attr_key)
|
||||
|
||||
根据输入key获取上下文中的属性值。如果某些属性没有设置，则会自动获取这些属性。
|
||||
|
||||
**参数：**
|
||||
|
||||
**attr_key** (str)：属性的key。
|
||||
|
||||
**返回：**
|
||||
|
||||
Object，表示给定属性key的值。
|
||||
|
||||
**异常：**
|
||||
|
||||
**ValueError**：输入key不是上下文中的属性。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> context.get_context("device_target")
|
||||
>>> context.get_context("device_id")
|
||||
|
||||
.. py:function:: set_auto_parallel_context(**kwargs)
|
||||
|
||||
配置自动并行，仅在Ascend和GPU上有效。
|
||||
|
||||
应在init之前配置自动并行。
|
||||
|
||||
.. note::
|
||||
配置时，必须输入配置的名称。如果某个程序具有不同并行模式下的任务，则需要再为下一个任务设置新的并行模式之前，调用reset_auto_parallel_context()接口来重置配置。若要设置或更改并行模式，必须在创建任何Initializer之前调用接口，否则，在编译网络时，可能会出现RuntimeError。
|
||||
|
||||
某些配置适用于特定的并行模式，有关详细信息，请参见下表：
|
||||
|
||||
=========================== ===========================
|
||||
Common AUTO_PARALLEL
|
||||
=========================== ===========================
|
||||
device_num gradient_fp32_sync
|
||||
global_rank loss_repeated_mean
|
||||
gradients_mean auto_parallel_search_mode
|
||||
parallel_mode strategy_ckpt_load_file
|
||||
all_reduce_fusion_config strategy_ckpt_save_file
|
||||
enable_parallel_optimizer dataset_strategy
|
||||
\ pipeline_stages
|
||||
\ grad_accumulation_step
|
||||
=========================== ===========================
|
||||
|
||||
**参数：**
|
||||
|
||||
- **device_num** (int)：表示可用设备的编号，必须在[1,4096]范围中。默认值：1。
|
||||
- **global_rank** (int)：表示全局RANK的ID，必须在[0,4095]范围中。默认值：0。
|
||||
- **gradients_mean** (bool)：表示是否在梯度的 AllReduce后执行平均算子。stand_alone不支持gradients_mean。默认值：False。
|
||||
- **gradient_fp32_sync** (bool)：在FP32中运行梯度的 AllReduce。stand_alone、data_parallel和hybrid_parallel不支持gradient_fp32_sync。默认值：True。
|
||||
- **parallel_mode** (str)：有五种并行模式，分别是stand_alone、data_parallel、hybrid_parallel、semi_auto_parallel和auto_parallel。默认值：stand_alone。
|
||||
|
||||
- stand_alone：单卡模式。
|
||||
- data_parallel：数据并行模式。
|
||||
- hybrid_parallel：手动实现数据并行和模型并行。
|
||||
- semi_auto_parallel：半自动并行模式。
|
||||
- auto_parallel：自动并行模式。
|
||||
|
||||
- **auto_parallel_search_mode** (str)：表示有两种策略搜索模式，分别是recursive_programming和dynamic_programming。默认值：dynamic_programming。
|
||||
|
||||
- recursive_programming：表示双递归搜索模式。
|
||||
- dynamic_programming：表示动态规划搜索模式。
|
||||
|
||||
- **parameter_broadcast** (bool)：表示在训练前是否广播参数。在训练之前，为了使所有设备的网络初始化参数值相同，请将设备0上的参数广播到其他设备。不同并行模式下的参数广播不同。在data_parallel模式下，除layerwise_parallel属性为True的参数外，所有参数都会被广播。在hybrid_parallel、semi_auto_parallel和auto_parallel模式下，分段参数不参与广播。默认值：False。
|
||||
- **strategy_ckpt_load_file** (str)：表示用于加载并行策略checkpoint的路径。默认值：''。
|
||||
- **strategy_ckpt_save_file** (str)：表示用于保存并行策略checkpoint的路径。默认值：''。
|
||||
- **full_batch** (bool)：如果在auto_parallel模式下加载整个batch数据集，则此参数应设置为True。默认值：False。目前不建议使用该接口，建议使用dataset_strategy来替换它。
|
||||
- **dataset_strategy** (Union[str, tuple])：表示数据集分片策略。默认值：data_parallel。dataset_strategy="data_parallel"等于full_batch=False，dataset_strategy="full_batch"等于full_batch=True。对于通过模型并列策略加载到网络的数据集，如ds_stra ((1, 8)、(1, 8))，需要使用set_auto_parallel_context(dataset_strategy=ds_stra)。
|
||||
- **enable_parallel_optimizer** (bool)：这是一个开发中的特性，它可以为数据并行训练对权重更新计算进行分片，以节省时间和内存。目前，自动和半自动并行模式支持Ascend和GPU中的所有优化器。数据并行模式仅支持Ascend中的`Lamb`和`AdamWeightDecay`。默认值：False。
|
||||
- **all_reduce_fusion_config** (list)：通过参数索引设置 AllReduce 融合策略。仅支持ReduceOp.SUM和HCCL_WORLD_GROUP/NCCL_WORLD_GROUP。没有默认值。如果不设置，则关闭算子融合。
|
||||
- **pipeline_stages** (int)：设置pipeline并行的阶段信息。这表明了设备如何单独分布在pipeline上。所有的设备将被划分为pipeline_stags个阶段。目前，这只能在启动semi_auto_parallel模式的情况下使用。默认值：1。
|
||||
- **grad_accumulation_step** (int)：在自动和半自动并行模式下设置梯度的累积step。其值应为正整数。默认值：1。
|
||||
|
||||
**异常：**
|
||||
|
||||
**ValueError**：输入key不是自动并行上下文中的属性。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> context.set_auto_parallel_context(device_num=8)
|
||||
>>> context.set_auto_parallel_context(global_rank=0)
|
||||
>>> context.set_auto_parallel_context(gradients_mean=True)
|
||||
>>> context.set_auto_parallel_context(gradient_fp32_sync=False)
|
||||
>>> context.set_auto_parallel_context(parallel_mode="auto_parallel")
|
||||
>>> context.set_auto_parallel_context(auto_parallel_search_mode="dynamic_programming")
|
||||
>>> context.set_auto_parallel_context(parameter_broadcast=False)
|
||||
>>> context.set_auto_parallel_context(strategy_ckpt_load_file="./strategy_stage1.ckpt")
|
||||
>>> context.set_auto_parallel_context(strategy_ckpt_save_file="./strategy_stage1.ckpt")
|
||||
>>> context.set_auto_parallel_context(dataset_strategy=((1, 8), (1, 8)))
|
||||
>>> context.set_auto_parallel_context(enable_parallel_optimizer=False)
|
||||
>>> context.set_auto_parallel_context(all_reduce_fusion_config=[8, 160])
|
||||
>>> context.set_auto_parallel_context(pipeline_stages=2)
|
||||
|
||||
.. py:function:: get_auto_parallel_context(attr_key)
|
||||
|
||||
根据key获取自动并行的配置。
|
||||
|
||||
**参数：**
|
||||
|
||||
**attr_key** (str)：配置的key。
|
||||
|
||||
**返回：**
|
||||
|
||||
根据key返回配置的值。
|
||||
|
||||
**异常：**
|
||||
|
||||
**ValueError**：输入key不在自动并行的配置列表中。
|
||||
|
||||
.. py:function:: reset_auto_parallel_context()
|
||||
|
||||
重置自动并行的配置为默认值。
|
||||
|
||||
- device_num：1。
|
||||
- global_rank：0。
|
||||
- gradients_mean：False。
|
||||
- gradient_fp32_sync：True。
|
||||
- parallel_mode：'stand_alone'。
|
||||
- auto_parallel_search_mode：'dynamic_programming'。
|
||||
- parameter_broadcast：False。
|
||||
- strategy_ckpt_load_file：''。
|
||||
- strategy_ckpt_save_file：''。
|
||||
- full_batch：False。
|
||||
- enable_parallel_optimizer：False。
|
||||
- pipeline_stages：1。
|
||||
|
||||
.. py:class:: mindspore.context.ParallelMode
|
||||
|
||||
并行模式。
|
||||
|
||||
有五种并行模式，分别是STAND_ALONE、DATA_PARALLEL、HYBRID_PARALLEL、SEMI_AUTO_PARALLEL和AUTO_PARALLEL。默认值：STAND_ALONE。
|
||||
|
||||
- STAND_ALONE：单卡模式。
|
||||
- DATA_PARALLEL：数据并行模式。
|
||||
- HYBRID_PARALLEL：手动实现数据并行和模型并行。
|
||||
- SEMI_AUTO_PARALLEL：半自动并行模式。
|
||||
- AUTO_PARALLEL：自动并行模式。
|
||||
|
||||
MODE_LIST：表示所有支持的并行模式的列表。
|
||||
|
||||
.. py:function:: set_ps_context(**kwargs)
|
||||
|
||||
设置参数服务器训练模式的上下文。
|
||||
|
||||
.. note::
|
||||
需要给参数服务器训练模式设置其他的环境变量。些环境变量如下所示：
|
||||
|
||||
- MS_SERVER_NUM：表示参数服务器数量。
|
||||
- MS_WORKER_NUM：表示工作进程数量。
|
||||
- MS_SCHED_HOST：表示调度器IP地址。
|
||||
- MS_SCHED_PORT：表示调度器开启的监听端口。
|
||||
- MS_ROLE：表示进程角色，角色列表如下：
|
||||
|
||||
- MS_SCHED：表示调度器。
|
||||
- MS_WORKER：表示工作进程。
|
||||
- MS_PSERVER/MS_SERVER：表示参数服务器。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **enable_ps** (bool)：表示是否启用参数服务器训练模式。只有在enable_ps设置为True后，环境变量才会生效。默认值：False。
|
||||
- **config_file_path** (string)：配置文件路径，用于容灾恢复等。默认值：''。
|
||||
- **scheduler_manage_port** (int)：调度器HTTP端口，对外开放用于接收和处理用户扩容/缩容等请求。默认值：11202。
|
||||
- **enable_ssl** (bool)：设置是否打开SSL认证。默认值：True。
|
||||
- **client_password** (str)：用于解密客户端证书密钥的密码。默认值：''。
|
||||
- **server_password** (str)：用于解密服务端证书密钥的密码。默认值：''。
|
||||
|
||||
|
||||
**异常：**
|
||||
|
||||
**ValueError**：输入key不是参数服务器训练模式上下文中的属性。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> context.set_ps_context(enable_ps=True, enable_ssl=True, client_password='123456', server_password='123456')
|
||||
|
||||
.. py:function:: get_ps_context(attr_key)
|
||||
|
||||
根据key获取参数服务器训练模式上下文中的属性值。
|
||||
|
||||
**参数：**
|
||||
|
||||
**attr_key** (str)：属性的key。
|
||||
|
||||
- enable_ps (bool)：表示是否启用参数服务器训练模式。
|
||||
- config_file_path (string)：配置文件路径，用于容灾恢复等。
|
||||
- scheduler_manage_port (int)：调度器HTTP端口，对外开放用于接收和处理用户扩容/缩容等请求。
|
||||
- enable_ssl (bool)：设置是否打开SSL认证。
|
||||
- client_password (str)：用于解密客户端证书密钥的密码。
|
||||
- server_password (str)：用于解密服务端证书密钥的密码。
|
||||
|
||||
**返回：**
|
||||
|
||||
根据key返回属性值。
|
||||
|
||||
**异常：**
|
||||
|
||||
ValueError：输入key不是参数服务器训练模式上下文中的属性。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> context.get_ps_context(enable_ps)
|
||||
|
||||
|
||||
.. py:function:: reset_ps_context()
|
||||
|
||||
将参数服务器训练模式上下文中的属性重置为默认值。各字段的含义及其默认值见'set_ps_context'接口。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> context.reset_ps_context()
|
||||
mindspore.context
|
||||
===================
|
||||
|
||||
.. py:class:: mindspore.context
|
||||
|
||||
MindSpore上下文，用于配置当前执行环境，包括执行模式、执行后端和其他特性开关。
|
||||
|
||||
.. py:function:: set_context(**kwargs)
|
||||
|
||||
设置运行环境的上下文。
|
||||
|
||||
在运行程序之前，应配置上下文。如果没有配置，默认情况下将根据设备目标进行自动设置。
|
||||
|
||||
.. note::
|
||||
设置属性时，必须输入属性名称。初始化网络后不建议更改模式，因为某些操作在图模式和PyNative模式下是不同的。默认值：GRAPH_MODE。
|
||||
|
||||
某些配置适用于特定的设备，有关详细信息，请参见下表：
|
||||
|
||||
**参数：**
|
||||
|
||||
- **device_id** (int)：表示目标设备的ID，其值必须在[0, device_num_per_host-1]范围中，且 `device_num_per_host` 的值不应超过4096。默认值：0。
|
||||
- **device_target** (str)：表示待运行的目标设备，支持Ascend、GPU和CPU。如果未设置设备目标，则使用MindSpore包的版本。
|
||||
- **max_device_memory** (str)：设置设备可用的最大内存。目前，仅在GPU上支持。格式为“xxGB”。默认值：1024GB。实际使用的内存大小是设备的可用内存和 `max_device_memory` 值中的最小值。
|
||||
- **variable_memory_max_size** (str)：设置可变内存的最大值。默认值：30GB。设置此参数后，框架使用的最大内存受配置值的限制。
|
||||
- **save_graphs** (bool)：表示是否保存图形。默认值：False。当 `save_graphs` 属性设为True时， `save_graphs_path` 属性用于设置中间编译图的存储路径。默认情况下，图形保存在当前目录下。
|
||||
- **save_graphs_path** (str)：表示保存图形的路径。默认值："."。如果指定的目录不存在，系统将自动创建该目录。在分布式训练中，图形将被保存到 `save_graphs_path/rank_${rank_id}/` 目录下。 `rank_id` 为集群中当前设备的ID。
|
||||
- **enable_dump** (bool)：此参数已弃用，将在下一版本中删除。
|
||||
- **save_dump_path** (str)：此参数已弃用，将在下一版本中删除。
|
||||
- **enable_profiling** (bool)：此参数已弃用，将在下一版本中删除。请使用mindspore.profiler.Profiler API。
|
||||
- **profiling_options** (str)：此参数已弃用，将在下一版本中删除。请使用mindspore.profiler.Profiler API。
|
||||
- **print_file_path** (str)：表示用于保存打印数据的路径。如果设置了该参数，默认将打印数据保存到文件中。如果不设置 `print_file_path` ，则显示该屏幕。如果保存的文件已经存在，将添加时间戳后缀到文件中。将数据保存到文件中，解决了在产生大量数据时屏幕打印中数据丢失的问题。如果没有设置该参数，则会报错：prompt to set the upper absolute path。
|
||||
- **env_config_path** (str)：通过context.set_context(env_config_path="./mindspore_config.json")来配置DFX的路径。
|
||||
|
||||
配置Running Data Recorder：
|
||||
|
||||
- **enable**：表示在发生故障时是否启用Running Data Recorder去收集和保存训练中的关键数据。设置为True时，将打开Running Data Recorder。设置为False时，将关闭Running Data Recorder。
|
||||
- **path**：设置Running Data Recorder保存数据的路径。当前路径必须是一个绝对路径。
|
||||
|
||||
内存重用：
|
||||
|
||||
- **mem_Reuse**：表示内存复用功能是否打开。设置为True时，将打开内存复用功能。设置为False时，将关闭内存复用功能。
|
||||
|
||||
- **precompile_only** (bool)：表示是否仅预编译网络。默认值：False。设置为True时，仅编译网络，而不执行网络。
|
||||
- **reserve_class_name_in_scope** (bool)：表示是否将网络类名称保存到所属作用域中。默认值：True。每个节点都有一个作用域。子节点的作用域是其父节点。如果 `reserve_class_name_in_scope` 设置为True，则类名将保存在作用域中的关键字“net-”之后。例如：
|
||||
|
||||
Default/net-Net1/net-Net2 (reserve_class_name_in_scope=True)
|
||||
|
||||
Default/net/net (reserve_class_name_in_scope=False)
|
||||
|
||||
- **pynative_synchronize** (bool)：表示是否在PyNative模式下启动设备同步执行。默认值：False。设置为False时，将在设备上异步执行算子。当算子执行出错时，将无法定位特定错误脚本代码的位置。当设置为True时，将在设备上同步执行算子。这将降低程序的执行性能。此时，当算子执行出错时，可以根据错误的调用栈来定位错误脚本代码的位置。
|
||||
- **mode** (int)：表示在GRAPH_MODE(0)或PYNATIVE_MODE(1)模式中的运行。默认值：GRAPH_MODE(0)。GRAPH_MODE或PYNATIVE_MODE可以通过 `mode` 属性设置，两种模式都支持所有后端。默认模式为GRAPH_MODE。
|
||||
- **enable_graph_kernel** (bool)：表示是否启用图算融合去优化网络执行性能。默认值：False。表示是否启用图算融合去优化网络执行性能。如果 `enable_graph_kernel` 设置为True，则可以启用加速。有关图算融合的详细信息，请查看`使能图算融合`（https://www.mindspore.cn/docs/programming_guide/zh-CN/master/enable_graph_kernel_fusion.html）。
|
||||
- **graph_kernel_flags** (str)：图算融合的优化选项，当与enable_graph_kernel冲突时，它的优先级更高。其仅适用于有经验的用户。例如，context.set_context(graph_kernel_flags="--opt_level=2 --dump_as_text")。一些常用选项：
|
||||
|
||||
- **opt_level**：设置优化级别。默认值：2。当opt_level的值大于0时，启动图算融合。可选值包括：
|
||||
|
||||
- 0：关闭图算融合。
|
||||
- 1：启动算子的基本融合。
|
||||
- 2：包括级别1的所有优化，并打开更多的优化，如CSE优化算法、算术简化等。
|
||||
- 3：包括级别2的所有优化，并打开更多的优化，如SitchingFusion、ParallelFusion等。在某些场景下，该级别的优化激进且不稳定。使用此级别时要小心。
|
||||
|
||||
- **dump_as_text**：将详细信息转储为文本文件。默认值：False。
|
||||
|
||||
有关更多选项，可以参考实现代码。
|
||||
|
||||
- **enable_reduce_precision** (bool)：表示是否开启降低精度计算。默认值：True。设置为True时，不支持用户指定的精度，且精度将自动更改。设置为False时，如果未指定用例的精度，则会报错并退出。
|
||||
- **auto_tune_mode** (str)：表示算子构建时的自动调整模式，以获得最佳的切分性能。默认值：NO_TUNE。其值必须在['RL', 'GA', 'RL,GA']范围中。
|
||||
|
||||
- RL：强化学习调优。
|
||||
- GA：遗传算法调优。
|
||||
- RL，GA：当RL和GA优化同时打开时，工具会根据网络模型中的不同算子类型自动选择RL或GA。RL和GA的顺序没有区别。（自动选择）。
|
||||
|
||||
|
||||
有关启用算子调优工具设置的更多信息，请查看 `使能算子调优工具 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/enable_auto_tune.html>`_。
|
||||
|
||||
- **check_bprop** (bool)：表示是否检查反向传播节点，以确保反向传播节点输出的形状(shape)和数据类型与输入参数相同。默认值：False。
|
||||
- **max_call_depth** (int)：指定函数调用的最大深度。其值必须为正整数。默认值：1000。当嵌套Cell太深或子图数量太多时，需要设置 `max_call_depth` 参数。如果 `max_call_depth` 的值比以前的大，则应把系统最大堆栈深度设得更大，否则可能会因为系统堆栈溢出而引发 `core dumped` 异常。
|
||||
- **enable_sparse** (bool)：表示是否启用稀疏特征。默认值：False。有关稀疏特征和稀疏张量的详细信息，请查看 `稀疏张量 <https://www.mindspore.cn/docs/programming_guide/zh-CN/master/tensor.html#sparse-tensor>`_。
|
||||
- **grad_for_scalar** (bool)： 表示是否获取标量梯度。默认值：False。当 `grad_for_scalar` 设置为True时，则衍生函数的标量输入。默认值为False。由于后端目前不支持伸缩操作，所以该接口只支持在前端可推演的简单操作。
|
||||
- **enable_compile_cache** (bool)：表示是否加载或者保存前端编译的图。当 `enable_compile_cache` 被设置为True时，在第一次执行的过程中，一个硬件无关的编译缓存会被生成并且导出为一个MINDIR文件。当该网络被再次执行时，如果 `enable_compile_cache` 仍然为True并且网络脚本没有被更改，那么这个编译缓存会被加载。注意目前只支持有限的Python脚本更改的自动检测，这意味着可能有正确性风险。默认值：False。这是一个实验原型，可能会被更改或者删除。
|
||||
- **compile_cache_path** (str)：保存前端图编译缓存的路径。默认值："."。如果目录不存在，系统会自动创建这个目录。缓存会被保存到如下目录：`compile_cache_path/rank_${rank_id}/`。`rank_id` 是集群上当前设备的ID。
|
||||
|
||||
**异常：**
|
||||
|
||||
**ValueError**：输入key不是上下文中的属性。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> context.set_context(mode=context.PYNATIVE_MODE)
|
||||
>>> context.set_context(precompile_only=True)
|
||||
>>> context.set_context(device_target="Ascend")
|
||||
>>> context.set_context(device_id=0)
|
||||
>>> context.set_context(save_graphs=True, save_graphs_path="./model.ms")
|
||||
>>> context.set_context(enable_reduce_precision=True)
|
||||
>>> context.set_context(enable_dump=True, save_dump_path=".")
|
||||
>>> context.set_context(enable_graph_kernel=True)
|
||||
>>> context.set_context(graph_kernel_flags="--opt_level=2 --dump_as_text")
|
||||
>>> context.set_context(reserve_class_name_in_scope=True)
|
||||
>>> context.set_context(variable_memory_max_size="6GB")
|
||||
>>> context.set_context(enable_profiling=True,
|
||||
... profiling_options='{"output":"/home/data/output","training_trace":"on"}')
|
||||
>>> context.set_context(check_bprop=True)
|
||||
>>> context.set_context(max_device_memory="3.5GB")
|
||||
>>> context.set_context(print_file_path="print.pb")
|
||||
>>> context.set_context(enable_sparse=True)
|
||||
>>> context.set_context(max_call_depth=80)
|
||||
>>> context.set_context(env_config_path="./env_config.json")
|
||||
>>> context.set_context(auto_tune_mode="GA,RL")
|
||||
>>> context.set_context(grad_for_scalar=True)
|
||||
>>> context.set_context(save_compile_cache=True)
|
||||
>>> context.set_context(load_compile_cache=True)
|
||||
>>> context.set_context(pynative_synchronize=True)
|
||||
|
||||
.. py:function:: get_context(attr_key)
|
||||
|
||||
根据输入key获取上下文中的属性值。如果某些属性没有设置，则会自动获取这些属性。
|
||||
|
||||
**参数：**
|
||||
|
||||
**attr_key** (str)：属性的key。
|
||||
|
||||
**返回：**
|
||||
|
||||
Object，表示给定属性key的值。
|
||||
|
||||
**异常：**
|
||||
|
||||
**ValueError**：输入key不是上下文中的属性。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> context.get_context("device_target")
|
||||
>>> context.get_context("device_id")
|
||||
|
||||
.. py:function:: set_auto_parallel_context(**kwargs)
|
||||
|
||||
配置自动并行，仅在Ascend和GPU上有效。
|
||||
|
||||
应在init之前配置自动并行。
|
||||
|
||||
.. note::
|
||||
配置时，必须输入配置的名称。如果某个程序具有不同并行模式下的任务，则需要再为下一个任务设置新的并行模式之前，调用reset_auto_parallel_context()接口来重置配置。若要设置或更改并行模式，必须在创建任何Initializer之前调用接口，否则，在编译网络时，可能会出现RuntimeError。
|
||||
|
||||
某些配置适用于特定的并行模式，有关详细信息，请参见下表：
|
||||
|
||||
=========================== ===========================
|
||||
Common AUTO_PARALLEL
|
||||
=========================== ===========================
|
||||
device_num gradient_fp32_sync
|
||||
global_rank loss_repeated_mean
|
||||
gradients_mean auto_parallel_search_mode
|
||||
parallel_mode strategy_ckpt_load_file
|
||||
all_reduce_fusion_config strategy_ckpt_save_file
|
||||
enable_parallel_optimizer dataset_strategy
|
||||
\ pipeline_stages
|
||||
\ grad_accumulation_step
|
||||
=========================== ===========================
|
||||
|
||||
**参数：**
|
||||
|
||||
- **device_num** (int)：表示可用设备的编号，必须在[1,4096]范围中。默认值：1。
|
||||
- **global_rank** (int)：表示全局RANK的ID，必须在[0,4095]范围中。默认值：0。
|
||||
- **gradients_mean** (bool)：表示是否在梯度的 AllReduce后执行平均算子。stand_alone不支持gradients_mean。默认值：False。
|
||||
- **gradient_fp32_sync** (bool)：在FP32中运行梯度的 AllReduce。stand_alone、data_parallel和hybrid_parallel不支持gradient_fp32_sync。默认值：True。
|
||||
- **parallel_mode** (str)：有五种并行模式，分别是stand_alone、data_parallel、hybrid_parallel、semi_auto_parallel和auto_parallel。默认值：stand_alone。
|
||||
|
||||
- stand_alone：单卡模式。
|
||||
- data_parallel：数据并行模式。
|
||||
- hybrid_parallel：手动实现数据并行和模型并行。
|
||||
- semi_auto_parallel：半自动并行模式。
|
||||
- auto_parallel：自动并行模式。
|
||||
|
||||
- **auto_parallel_search_mode** (str)：表示有两种策略搜索模式，分别是recursive_programming和dynamic_programming。默认值：dynamic_programming。
|
||||
|
||||
- recursive_programming：表示双递归搜索模式。
|
||||
- dynamic_programming：表示动态规划搜索模式。
|
||||
|
||||
- **parameter_broadcast** (bool)：表示在训练前是否广播参数。在训练之前，为了使所有设备的网络初始化参数值相同，请将设备0上的参数广播到其他设备。不同并行模式下的参数广播不同。在data_parallel模式下，除layerwise_parallel属性为True的参数外，所有参数都会被广播。在hybrid_parallel、semi_auto_parallel和auto_parallel模式下，分段参数不参与广播。默认值：False。
|
||||
- **strategy_ckpt_load_file** (str)：表示用于加载并行策略checkpoint的路径。默认值：''。
|
||||
- **strategy_ckpt_save_file** (str)：表示用于保存并行策略checkpoint的路径。默认值：''。
|
||||
- **full_batch** (bool)：如果在auto_parallel模式下加载整个batch数据集，则此参数应设置为True。默认值：False。目前不建议使用该接口，建议使用dataset_strategy来替换它。
|
||||
- **dataset_strategy** (Union[str, tuple])：表示数据集分片策略。默认值：data_parallel。dataset_strategy="data_parallel"等于full_batch=False，dataset_strategy="full_batch"等于full_batch=True。对于通过模型并列策略加载到网络的数据集，如ds_stra ((1, 8)、(1, 8))，需要使用set_auto_parallel_context(dataset_strategy=ds_stra)。
|
||||
- **enable_parallel_optimizer** (bool)：这是一个开发中的特性，它可以为数据并行训练对权重更新计算进行分片，以节省时间和内存。目前，自动和半自动并行模式支持Ascend和GPU中的所有优化器。数据并行模式仅支持Ascend中的`Lamb`和`AdamWeightDecay`。默认值：False。
|
||||
- **all_reduce_fusion_config** (list)：通过参数索引设置 AllReduce 融合策略。仅支持ReduceOp.SUM和HCCL_WORLD_GROUP/NCCL_WORLD_GROUP。没有默认值。如果不设置，则关闭算子融合。
|
||||
- **pipeline_stages** (int)：设置pipeline并行的阶段信息。这表明了设备如何单独分布在pipeline上。所有的设备将被划分为pipeline_stags个阶段。目前，这只能在启动semi_auto_parallel模式的情况下使用。默认值：1。
|
||||
- **grad_accumulation_step** (int)：在自动和半自动并行模式下设置梯度的累积step。其值应为正整数。默认值：1。
|
||||
|
||||
**异常：**
|
||||
|
||||
**ValueError**：输入key不是自动并行上下文中的属性。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> context.set_auto_parallel_context(device_num=8)
|
||||
>>> context.set_auto_parallel_context(global_rank=0)
|
||||
>>> context.set_auto_parallel_context(gradients_mean=True)
|
||||
>>> context.set_auto_parallel_context(gradient_fp32_sync=False)
|
||||
>>> context.set_auto_parallel_context(parallel_mode="auto_parallel")
|
||||
>>> context.set_auto_parallel_context(auto_parallel_search_mode="dynamic_programming")
|
||||
>>> context.set_auto_parallel_context(parameter_broadcast=False)
|
||||
>>> context.set_auto_parallel_context(strategy_ckpt_load_file="./strategy_stage1.ckpt")
|
||||
>>> context.set_auto_parallel_context(strategy_ckpt_save_file="./strategy_stage1.ckpt")
|
||||
>>> context.set_auto_parallel_context(dataset_strategy=((1, 8), (1, 8)))
|
||||
>>> context.set_auto_parallel_context(enable_parallel_optimizer=False)
|
||||
>>> context.set_auto_parallel_context(all_reduce_fusion_config=[8, 160])
|
||||
>>> context.set_auto_parallel_context(pipeline_stages=2)
|
||||
|
||||
.. py:function:: get_auto_parallel_context(attr_key)
|
||||
|
||||
根据key获取自动并行的配置。
|
||||
|
||||
**参数：**
|
||||
|
||||
**attr_key** (str)：配置的key。
|
||||
|
||||
**返回：**
|
||||
|
||||
根据key返回配置的值。
|
||||
|
||||
**异常：**
|
||||
|
||||
**ValueError**：输入key不在自动并行的配置列表中。
|
||||
|
||||
.. py:function:: reset_auto_parallel_context()
|
||||
|
||||
重置自动并行的配置为默认值。
|
||||
|
||||
- device_num：1。
|
||||
- global_rank：0。
|
||||
- gradients_mean：False。
|
||||
- gradient_fp32_sync：True。
|
||||
- parallel_mode：'stand_alone'。
|
||||
- auto_parallel_search_mode：'dynamic_programming'。
|
||||
- parameter_broadcast：False。
|
||||
- strategy_ckpt_load_file：''。
|
||||
- strategy_ckpt_save_file：''。
|
||||
- full_batch：False。
|
||||
- enable_parallel_optimizer：False。
|
||||
- pipeline_stages：1。
|
||||
|
||||
.. py:class:: mindspore.context.ParallelMode
|
||||
|
||||
并行模式。
|
||||
|
||||
有五种并行模式，分别是STAND_ALONE、DATA_PARALLEL、HYBRID_PARALLEL、SEMI_AUTO_PARALLEL和AUTO_PARALLEL。默认值：STAND_ALONE。
|
||||
|
||||
- STAND_ALONE：单卡模式。
|
||||
- DATA_PARALLEL：数据并行模式。
|
||||
- HYBRID_PARALLEL：手动实现数据并行和模型并行。
|
||||
- SEMI_AUTO_PARALLEL：半自动并行模式。
|
||||
- AUTO_PARALLEL：自动并行模式。
|
||||
|
||||
MODE_LIST：表示所有支持的并行模式的列表。
|
||||
|
||||
.. py:function:: set_ps_context(**kwargs)
|
||||
|
||||
设置参数服务器训练模式的上下文。
|
||||
|
||||
.. note::
|
||||
需要给参数服务器训练模式设置其他的环境变量。些环境变量如下所示：
|
||||
|
||||
- MS_SERVER_NUM：表示参数服务器数量。
|
||||
- MS_WORKER_NUM：表示工作进程数量。
|
||||
- MS_SCHED_HOST：表示调度器IP地址。
|
||||
- MS_SCHED_PORT：表示调度器开启的监听端口。
|
||||
- MS_ROLE：表示进程角色，角色列表如下：
|
||||
|
||||
- MS_SCHED：表示调度器。
|
||||
- MS_WORKER：表示工作进程。
|
||||
- MS_PSERVER/MS_SERVER：表示参数服务器。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **enable_ps** (bool)：表示是否启用参数服务器训练模式。只有在enable_ps设置为True后，环境变量才会生效。默认值：False。
|
||||
- **config_file_path** (string)：配置文件路径，用于容灾恢复等。默认值：''。
|
||||
- **scheduler_manage_port** (int)：调度器HTTP端口，对外开放用于接收和处理用户扩容/缩容等请求。默认值：11202。
|
||||
- **enable_ssl** (bool)：设置是否打开SSL认证。默认值：True。
|
||||
- **client_password** (str)：用于解密客户端证书密钥的密码。默认值：''。
|
||||
- **server_password** (str)：用于解密服务端证书密钥的密码。默认值：''。
|
||||
|
||||
|
||||
**异常：**
|
||||
|
||||
**ValueError**：输入key不是参数服务器训练模式上下文中的属性。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> context.set_ps_context(enable_ps=True, enable_ssl=True, client_password='123456', server_password='123456')
|
||||
|
||||
.. py:function:: get_ps_context(attr_key)
|
||||
|
||||
根据key获取参数服务器训练模式上下文中的属性值。
|
||||
|
||||
**参数：**
|
||||
|
||||
**attr_key** (str)：属性的key。
|
||||
|
||||
- enable_ps (bool)：表示是否启用参数服务器训练模式。
|
||||
- config_file_path (string)：配置文件路径，用于容灾恢复等。
|
||||
- scheduler_manage_port (int)：调度器HTTP端口，对外开放用于接收和处理用户扩容/缩容等请求。
|
||||
- enable_ssl (bool)：设置是否打开SSL认证。
|
||||
- client_password (str)：用于解密客户端证书密钥的密码。
|
||||
- server_password (str)：用于解密服务端证书密钥的密码。
|
||||
|
||||
**返回：**
|
||||
|
||||
根据key返回属性值。
|
||||
|
||||
**异常：**
|
||||
|
||||
ValueError：输入key不是参数服务器训练模式上下文中的属性。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> context.get_ps_context(enable_ps)
|
||||
|
||||
|
||||
.. py:function:: reset_ps_context()
|
||||
|
||||
将参数服务器训练模式上下文中的属性重置为默认值。各字段的含义及其默认值见'set_ps_context'接口。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> context.reset_ps_context()
|
||||
|
|
@ -1,20 +1,20 @@
|
|||
mindspore.get_level
|
||||
======================
|
||||
|
||||
.. py:class:: mindspore.get_level()
|
||||
|
||||
获取日志记录器的级别。
|
||||
|
||||
**返回：**
|
||||
|
||||
string，日志级别包括4(EXCEPTION)、3(ERROR)、2(WARNING)、1(INFO)和0(DEBUG)。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> import os
|
||||
>>> os.environ['GLOG_v'] = '0'
|
||||
>>> from mindspore import log as logger
|
||||
>>> level = logger.get_level()
|
||||
>>> print(level)
|
||||
'0'
|
||||
mindspore.get_level
|
||||
======================
|
||||
|
||||
.. py:class:: mindspore.get_level()
|
||||
|
||||
获取日志记录器的级别。
|
||||
|
||||
**返回：**
|
||||
|
||||
string，日志级别包括4(EXCEPTION)、3(ERROR)、2(WARNING)、1(INFO)和0(DEBUG)。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> import os
|
||||
>>> os.environ['GLOG_v'] = '0'
|
||||
>>> from mindspore import log as logger
|
||||
>>> level = logger.get_level()
|
||||
>>> print(level)
|
||||
'0'
|
||||
|
||||
|
|
@ -1,26 +1,26 @@
|
|||
mindspore.get_log_config
|
||||
=========================
|
||||
|
||||
.. py:class:: mindspore.get_log_config()
|
||||
|
||||
获取日志配置。
|
||||
|
||||
**返回：**
|
||||
|
||||
Dict，日志配置字典。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> import os
|
||||
>>> os.environ['GLOG_v'] = '1'
|
||||
>>> os.environ['GLOG_logtostderr'] = '0'
|
||||
>>> os.environ['GLOG_log_dir'] = '/var/log'
|
||||
>>> os.environ['logger_maxBytes'] = '5242880'
|
||||
>>> os.environ['logger_backupCount'] = '10'
|
||||
>>> os.environ['GLOG_stderrthreshold'] = '2'
|
||||
>>> from mindspore import log as logger
|
||||
>>> config= logger.get_log_config()
|
||||
>>> print(config)
|
||||
{'GLOG_v': '1', 'GLOG_logtostderr': '0', 'GLOG_log_dir': '/var/log',
|
||||
'logger_maxBytes': '5242880', 'logger_backupCount': '10', 'GLOG_stderrthreshold': '2'}
|
||||
mindspore.get_log_config
|
||||
=========================
|
||||
|
||||
.. py:class:: mindspore.get_log_config()
|
||||
|
||||
获取日志配置。
|
||||
|
||||
**返回：**
|
||||
|
||||
Dict，日志配置字典。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> import os
|
||||
>>> os.environ['GLOG_v'] = '1'
|
||||
>>> os.environ['GLOG_logtostderr'] = '0'
|
||||
>>> os.environ['GLOG_log_dir'] = '/var/log'
|
||||
>>> os.environ['logger_maxBytes'] = '5242880'
|
||||
>>> os.environ['logger_backupCount'] = '10'
|
||||
>>> os.environ['GLOG_stderrthreshold'] = '2'
|
||||
>>> from mindspore import log as logger
|
||||
>>> config= logger.get_log_config()
|
||||
>>> print(config)
|
||||
{'GLOG_v': '1', 'GLOG_logtostderr': '0', 'GLOG_log_dir': '/var/log',
|
||||
'logger_maxBytes': '5242880', 'logger_backupCount': '10', 'GLOG_stderrthreshold': '2'}
|
||||
|
||||
|
|
@ -1,94 +1,94 @@
|
|||
mindspore.nn.AdamOffload
|
||||
=========================
|
||||
|
||||
.. py:class:: mindspore.nn.AdamOffload(params, learning_rate=1e-3, beta1=0.9, beta2=0.999, eps=1e-08, use_locking=False, use_nesterov=False, weight_decay=0.0, loss_scale=1.0)
|
||||
|
||||
此优化器在主机CPU上运行Adam优化算法，设备上仅执行网络参数的更新，最大限度地降低内存成本。虽然会增加性能开销，但优化器可以运行更大的模型。
|
||||
|
||||
Adam算法参见 `Adam: A Method for Stochastic Optimization <https://arxiv.org/abs/1412.6980>`_。
|
||||
|
||||
更新公式如下：
|
||||
|
||||
.. math::
|
||||
\begin{array}{ll} \\
|
||||
m_{t+1} = \beta_1 * m_{t} + (1 - \beta_1) * g \\
|
||||
v_{t+1} = \beta_2 * v_{t} + (1 - \beta_2) * g * g \\
|
||||
l = \alpha * \frac{\sqrt{1-\beta_2^t}}{1-\beta_1^t} \\
|
||||
w_{t+1} = w_{t} - l * \frac{m_{t+1}}{\sqrt{v_{t+1}} + \epsilon}
|
||||
\end{array}
|
||||
|
||||
:math:`m` 代表第一个矩向量 `moment1` ，:math:`v` 代表第二个矩向量 `moment2`，:math:`g` 代表 `gradients`，:math:`l` 代表缩放因子，:math:`\beta_1,\beta_2` 代表 `beta1` 和 `beta2`，:math:`t` 代表当前step，:math:`beta_1^t` 和 :math:`beta_2^t` 代表 `beta1_power` 和 `beta2_power`，:math:`\alpha` 代表 `learning_rate`，:math:`w` 代表 `params`，:math:`\epsilon` 代表 `eps` 。
|
||||
|
||||
.. note::此优化器目前仅支持图模式。
|
||||
|
||||
.. include:: mindspore.nn.optim_note_weight_decay.rst
|
||||
|
||||
**参数：**
|
||||
|
||||
- **params** (Union[list[Parameter], list[dict]]) - 必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、和"order_params"：
|
||||
|
||||
.. include:: mindspore.nn.optim_group_param.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_group_lr.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_group_weight_decay.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_group_order.rst
|
||||
|
||||
|
||||
- **learning_rate (Union[float, Tensor, Iterable, LearningRateSchedule]): 默认值：1e-3。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_dynamic_lr.rst
|
||||
|
||||
- **beta1** (float) - `moment1` 的指数衰减率。参数范围（0.0,1.0）。默认值：0.9。
|
||||
- **beta2** (float) - `moment2` 的指数衰减率。参数范围（0.0,1.0）。默认值：0.999。
|
||||
- **eps** (float) - 将添加到分母中，以提高数值稳定性。必须大于0。默认值：1e-8。
|
||||
- **use_locking** (bool) - 是否对参数更新加锁保护。如果为True，则 `w` 、`m` 和 `v` 的更新将受到锁保护。如果为False，则结果不可预测。默认值：False。
|
||||
- **use_nesterov** (bool) - 是否使用Nesterov Accelerated Gradient (NAG)算法更新梯度。如果为True，使用NAG更新梯度。如果为False，则在不使用NAG的情况下更新梯度。默认值：False。
|
||||
- **weight_decay** (float) - 权重衰减（L2 penalty）。必须大于等于0。默认值：0.0。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_loss_scale.rst
|
||||
|
||||
**输入：**
|
||||
|
||||
**gradients** (tuple[Tensor])：`params`的梯度，shape与`params`相同。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor[bool]，值为True。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
|
||||
- **TypeError**：`parameters` 的元素不是Parameter或字典。
|
||||
- **TypeError**：`beta1` 、 `beta2` 、 `eps `或 `loss_scale` 不是float。
|
||||
- **TypeError**：`weight_decay` 不是float或int。
|
||||
- **TypeError**：`use_locking` 或 `use_nesterov` 不是bool。
|
||||
- **ValueError**：`loss_scale` 或 `eps` 不大于0。
|
||||
- **ValueError**：`beta1` 、 `beta2` 不在（0.0,1.0）范围内。
|
||||
- **ValueError**：`weight_decay` 小于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> #1) 所有参数使用相同的学习率和权重衰减
|
||||
>>> optim = nn.AdamOffload(params=net.trainable_params())
|
||||
>>>
|
||||
>>> #2) 使用参数分组并设置不同的值
|
||||
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
|
||||
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
|
||||
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01},
|
||||
... {'params': no_conv_params, 'lr': 0.01},
|
||||
... {'order_params': net.trainable_params()}]
|
||||
>>> optim = nn.AdamOffload(group_params, learning_rate=0.1, weight_decay=0.0)
|
||||
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01。
|
||||
>>> # no_conv_params参数组将使用该组的学习率0.01、优化器中的权重衰减0.0。
|
||||
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
|
||||
>>>
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=optim)
|
||||
mindspore.nn.AdamOffload
|
||||
=========================
|
||||
|
||||
.. py:class:: mindspore.nn.AdamOffload(params, learning_rate=1e-3, beta1=0.9, beta2=0.999, eps=1e-08, use_locking=False, use_nesterov=False, weight_decay=0.0, loss_scale=1.0)
|
||||
|
||||
此优化器在主机CPU上运行Adam优化算法，设备上仅执行网络参数的更新，最大限度地降低内存成本。虽然会增加性能开销，但优化器可以运行更大的模型。
|
||||
|
||||
Adam算法参见 `Adam: A Method for Stochastic Optimization <https://arxiv.org/abs/1412.6980>`_。
|
||||
|
||||
更新公式如下：
|
||||
|
||||
.. math::
|
||||
\begin{array}{ll} \\
|
||||
m_{t+1} = \beta_1 * m_{t} + (1 - \beta_1) * g \\
|
||||
v_{t+1} = \beta_2 * v_{t} + (1 - \beta_2) * g * g \\
|
||||
l = \alpha * \frac{\sqrt{1-\beta_2^t}}{1-\beta_1^t} \\
|
||||
w_{t+1} = w_{t} - l * \frac{m_{t+1}}{\sqrt{v_{t+1}} + \epsilon}
|
||||
\end{array}
|
||||
|
||||
:math:`m` 代表第一个矩向量 `moment1` ，:math:`v` 代表第二个矩向量 `moment2`，:math:`g` 代表 `gradients`，:math:`l` 代表缩放因子，:math:`\beta_1,\beta_2` 代表 `beta1` 和 `beta2`，:math:`t` 代表当前step，:math:`beta_1^t` 和 :math:`beta_2^t` 代表 `beta1_power` 和 `beta2_power`，:math:`\alpha` 代表 `learning_rate`，:math:`w` 代表 `params`，:math:`\epsilon` 代表 `eps` 。
|
||||
|
||||
.. note::此优化器目前仅支持图模式。
|
||||
|
||||
.. include:: mindspore.nn.optim_note_weight_decay.rst
|
||||
|
||||
**参数：**
|
||||
|
||||
- **params** (Union[list[Parameter], list[dict]]) - 必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、和"order_params"：
|
||||
|
||||
.. include:: mindspore.nn.optim_group_param.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_group_lr.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_group_weight_decay.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_group_order.rst
|
||||
|
||||
|
||||
- **learning_rate** (Union[float, Tensor, Iterable, LearningRateSchedule]): 默认值：1e-3。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_dynamic_lr.rst
|
||||
|
||||
- **beta1** (float) - `moment1` 的指数衰减率。参数范围（0.0,1.0）。默认值：0.9。
|
||||
- **beta2** (float) - `moment2` 的指数衰减率。参数范围（0.0,1.0）。默认值：0.999。
|
||||
- **eps** (float) - 将添加到分母中，以提高数值稳定性。必须大于0。默认值：1e-8。
|
||||
- **use_locking** (bool) - 是否对参数更新加锁保护。如果为True，则 `w` 、`m` 和 `v` 的更新将受到锁保护。如果为False，则结果不可预测。默认值：False。
|
||||
- **use_nesterov** (bool) - 是否使用Nesterov Accelerated Gradient (NAG)算法更新梯度。如果为True，使用NAG更新梯度。如果为False，则在不使用NAG的情况下更新梯度。默认值：False。
|
||||
- **weight_decay** (float) - 权重衰减（L2 penalty）。必须大于等于0。默认值：0.0。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_loss_scale.rst
|
||||
|
||||
**输入：**
|
||||
|
||||
**gradients** (tuple[Tensor])：`params` 的梯度，shape与 `params` 相同。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor[bool]，值为True。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
|
||||
- **TypeError**：`parameters` 的元素不是Parameter或字典。
|
||||
- **TypeError**：`beta1` 、 `beta2` 、 `eps `或 `loss_scale` 不是float。
|
||||
- **TypeError**：`weight_decay` 不是float或int。
|
||||
- **TypeError**：`use_locking` 或 `use_nesterov` 不是bool。
|
||||
- **ValueError**：`loss_scale` 或 `eps` 不大于0。
|
||||
- **ValueError**：`beta1` 、 `beta2` 不在（0.0,1.0）范围内。
|
||||
- **ValueError**：`weight_decay` 小于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> #1) 所有参数使用相同的学习率和权重衰减
|
||||
>>> optim = nn.AdamOffload(params=net.trainable_params())
|
||||
>>>
|
||||
>>> #2) 使用参数分组并设置不同的值
|
||||
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
|
||||
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
|
||||
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01},
|
||||
... {'params': no_conv_params, 'lr': 0.01},
|
||||
... {'order_params': net.trainable_params()}]
|
||||
>>> optim = nn.AdamOffload(group_params, learning_rate=0.1, weight_decay=0.0)
|
||||
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01。
|
||||
>>> # no_conv_params参数组将使用该组的学习率0.01、优化器中的权重衰减0.0。
|
||||
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
|
||||
>>>
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=optim)
|
||||
|
||||
|
|
@ -1,93 +1,92 @@
|
|||
mindspore.nn.AdamWeightDecay
|
||||
==============================
|
||||
|
||||
.. py:class:: mindspore.nn.AdamWeightDecay(params, learning_rate=1e-3, beta1=0.9, beta2=0.999, eps=1e-06, weight_decay=0.0)
|
||||
|
||||
实现权重衰减Adam算法。
|
||||
|
||||
.. math::
|
||||
\begin{array}{ll} \\
|
||||
m_{t+1} = \beta_1 * m_{t} + (1 - \beta_1) * g \\
|
||||
v_{t+1} = \beta_2 * v_{t} + (1 - \beta_2) * g * g \\
|
||||
update = \frac{m_{t+1}}{\sqrt{v_{t+1}} + eps} \\
|
||||
update =
|
||||
\begin{cases}
|
||||
update + weight\_decay * w_{t}
|
||||
& \text{ if } weight\_decay > 0 \\
|
||||
update
|
||||
& \text{ otherwise }
|
||||
\end{cases} \\
|
||||
w_{t+1} = w_{t} - lr * update
|
||||
\end{array}
|
||||
|
||||
:math:`m` 表示第1矩向量 `moment1` , :math:`v` 表示第2矩向量 `moment2`， :math:`g` 表示 `gradients` ，:math:`lr` 表示 `learning_rate` ，:math:`\beta_1, \beta_2` 表示 `beta1` 和 `beta2` ,:math:`t` 表示当前step，:math:`w` 表示 `params`。
|
||||
|
||||
.. note::
|
||||
.. include:: mindspore.nn.optim_note_loss_scale.rst
|
||||
.. include:: mindspore.nn.optim_note_weight_decay.rst
|
||||
|
||||
**参数：**
|
||||
|
||||
- **params** (Union[list[Parameter], list[dict]]) - 必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、和"order_params"：
|
||||
|
||||
.. include:: mindspore.nn.optim_group_param.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_group_lr.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_group_weight_decay.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_group_order.rst
|
||||
|
||||
|
||||
- **learning_rate** (Union[float, Tensor, Iterable, LearningRateSchedule]): 默认值：1e-3。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_dynamic_lr.rst
|
||||
|
||||
- **beta1** (float)：`moment1` 的指数衰减率。参数范围（0.0,1.0）。默认值：0.9。
|
||||
- **beta2** (float)：`moment2` 的指数衰减率。参数范围（0.0,1.0）。默认值：0.999。
|
||||
- **eps** (float)：将添加到分母中，以提高数值稳定性。必须大于0。默认值：1e-6。
|
||||
- **weight_decay** (float)：权重衰减（L2 penalty）。必须大于等于0。默认值：0.0。
|
||||
|
||||
**输入：**
|
||||
|
||||
**gradients** (tuple[Tensor])：`params`的梯度，shape与`params`相同。
|
||||
|
||||
|
||||
**输出：**
|
||||
|
||||
**tuple**[bool]，所有元素都为True。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
|
||||
- **TypeError**：`parameters` 的元素不是Parameter或字典。
|
||||
- **TypeError**：`beta1` 、 `beta2` 或 `eps` 不是float。
|
||||
- **TypeError**：`weight_decay` 不是float或int。
|
||||
- **ValueError**：`eps` 小于等于0。
|
||||
- **ValueError**：`beta1` 、 `beta2` 不在（0.0,1.0）范围内。
|
||||
- **ValueError**：`weight_decay` 小于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> #1) 所有参数使用相同的学习率和权重衰减
|
||||
>>> optim = nn.AdamWeightDecay(params=net.trainable_params())
|
||||
>>>
|
||||
>>> #2) 使用参数分组并设置不同的值
|
||||
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
|
||||
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
|
||||
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01},
|
||||
... {'params': no_conv_params, 'lr': 0.01},
|
||||
... {'order_params': net.trainable_params()}]
|
||||
>>> optim = nn.AdamWeightDecay(group_params, learning_rate=0.1, weight_decay=0.0)
|
||||
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01。
|
||||
>>> # no_conv_params参数组将使用该组的学习率0.01、优化器中的权重衰减0.0。
|
||||
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
|
||||
>>>
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=optim)
|
||||
mindspore.nn.AdamWeightDecay
|
||||
===============================
|
||||
|
||||
.. py:class:: mindspore.nn.AdamWeightDecay(params, learning_rate=1e-3, beta1=0.9, beta2=0.999, eps=1e-06, weight_decay=0.0)
|
||||
|
||||
实现权重衰减Adam算法。
|
||||
|
||||
.. math::
|
||||
\begin{array}{ll} \\
|
||||
m_{t+1} = \beta_1 * m_{t} + (1 - \beta_1) * g \\
|
||||
v_{t+1} = \beta_2 * v_{t} + (1 - \beta_2) * g * g \\
|
||||
update = \frac{m_{t+1}}{\sqrt{v_{t+1}} + eps} \\
|
||||
update =
|
||||
\begin{cases}
|
||||
update + weight\_decay * w_{t}
|
||||
& \text{ if } weight\_decay > 0 \\
|
||||
update
|
||||
& \text{ otherwise }
|
||||
\end{cases} \\
|
||||
w_{t+1} = w_{t} - lr * update
|
||||
\end{array}
|
||||
|
||||
:math:`m` 表示第1矩向量 `moment1` , :math:`v` 表示第2矩向量 `moment2`， :math:`g` 表示 `gradients` ，:math:`lr` 表示 `learning_rate` ，:math:`\beta_1, \beta_2` 表示 `beta1` 和 `beta2` ,:math:`t` 表示当前step，:math:`w` 表示 `params`。
|
||||
|
||||
.. note::
|
||||
.. include:: mindspore.nn.optim_note_loss_scale.rst
|
||||
.. include:: mindspore.nn.optim_note_weight_decay.rst
|
||||
|
||||
**参数：**
|
||||
|
||||
- **params** (Union[list[Parameter], list[dict]]) - 必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、和"order_params"：
|
||||
|
||||
.. include:: mindspore.nn.optim_group_param.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_group_lr.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_group_weight_decay.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_group_order.rst
|
||||
|
||||
|
||||
- **learning_rate** (Union[float, Tensor, Iterable, LearningRateSchedule]): 默认值：1e-3。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_dynamic_lr.rst
|
||||
|
||||
- **beta1** (float)：`moment1` 的指数衰减率。参数范围（0.0,1.0）。默认值：0.9。
|
||||
- **beta2** (float)：`moment2` 的指数衰减率。参数范围（0.0,1.0）。默认值：0.999。
|
||||
- **eps** (float)：将添加到分母中，以提高数值稳定性。必须大于0。默认值：1e-6。
|
||||
- **weight_decay** (float)：权重衰减（L2 penalty）。必须大于等于0。默认值：0.0。
|
||||
|
||||
**输入：**
|
||||
|
||||
**gradients** (tuple[Tensor])：`params` 的梯度，shape与 `params` 相同。
|
||||
|
||||
**输出：**
|
||||
|
||||
**tuple** [bool]，所有元素都为True。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
|
||||
- **TypeError**：`parameters` 的元素不是Parameter或字典。
|
||||
- **TypeError**：`beta1` 、 `beta2` 或 `eps` 不是float。
|
||||
- **TypeError**：`weight_decay` 不是float或int。
|
||||
- **ValueError**：`eps` 小于等于0。
|
||||
- **ValueError**：`beta1` 、 `beta2` 不在（0.0,1.0）范围内。
|
||||
- **ValueError**：`weight_decay` 小于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> #1) 所有参数使用相同的学习率和权重衰减
|
||||
>>> optim = nn.AdamWeightDecay(params=net.trainable_params())
|
||||
>>>
|
||||
>>> #2) 使用参数分组并设置不同的值
|
||||
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
|
||||
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
|
||||
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01},
|
||||
... {'params': no_conv_params, 'lr': 0.01},
|
||||
... {'order_params': net.trainable_params()}]
|
||||
>>> optim = nn.AdamWeightDecay(group_params, learning_rate=0.1, weight_decay=0.0)
|
||||
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01。
|
||||
>>> # no_conv_params参数组将使用该组的学习率0.01、优化器中的权重衰减0.0。
|
||||
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
|
||||
>>>
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=optim)
|
||||
|
||||
|
|
@ -1,63 +1,63 @@
|
|||
mindspore.nn.DynamicLossScaleUpdateCell
|
||||
=======================================
|
||||
|
||||
.. py:class:: mindspore.nn.DynamicLossScaleUpdateCell(loss_scale_value, scale_factor, scale_window)
|
||||
|
||||
用于动态地更新梯度放大系数(loss scale)的神经元。
|
||||
|
||||
使用梯度放大功能进行训练时，初始梯度放大系数值为 `loss_scale_value`。在每个训练步骤中，当出现溢出时，通过计算公式 `loss_scale`/`scale_factor` 减小梯度放大系数。如果连续 `scale_window` 步（step）未溢出，则将通过 `loss_scale` * `scale_factor` 增大梯度放大系数。
|
||||
|
||||
该类是 :class:`mindspore.nn.DynamicLossScaleManager` 的 `get_update_cell` 方法的返回值。训练过程中，类 :class:`mindspore.TrainOneStepWithLossScaleCell` 会调用该Cell来更新梯度放大系数。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **loss_scale_value** (float)：初始的梯度放大系数。
|
||||
- **scale_factor** (int)：增减系数。
|
||||
- **scale_window** (int)：未溢出时，增大梯度放大系数的最大连续训练步数。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **loss_scale** (Tensor)：训练期间的梯度放大系数，shape为 :math:`()`。
|
||||
- **overflow** (bool)：是否发生溢出。
|
||||
|
||||
**输出：**
|
||||
|
||||
Bool，即输入`overflow`。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> import numpy as np
|
||||
>>> from mindspore import Tensor, Parameter, nn
|
||||
>>> import mindspore.ops as ops
|
||||
>>>
|
||||
>>> class Net(nn.Cell):
|
||||
... def __init__(self, in_features, out_features)：
|
||||
... super(Net, self).__init__()
|
||||
... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
|
||||
... name='weight')
|
||||
... self.matmul = ops.MatMul()
|
||||
...
|
||||
... def construct(self, x)：
|
||||
... output = self.matmul(x, self.weight)
|
||||
... return output
|
||||
...
|
||||
>>> in_features, out_features = 16, 10
|
||||
>>> net = Net(in_features, out_features)
|
||||
>>> loss = nn.MSELoss()
|
||||
>>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
|
||||
>>> net_with_loss = nn.WithLossCell(net, loss)
|
||||
>>> manager = nn.DynamicLossScaleUpdateCell(loss_scale_value=2**12, scale_factor=2, scale_window=1000)
|
||||
>>> train_network = nn.TrainOneStepWithLossScaleCell(net_with_loss, optimizer, scale_sense=manager)
|
||||
>>> input = Tensor(np.ones([out_features, in_features]), mindspore.float32)
|
||||
>>> labels = Tensor(np.ones([out_features,]), mindspore.float32)
|
||||
>>> output = train_network(input, labels)
|
||||
|
||||
|
||||
.. py:method:: get_loss_scale()
|
||||
|
||||
获取当前梯度放大系数。
|
||||
mindspore.nn.DynamicLossScaleUpdateCell
|
||||
=======================================
|
||||
|
||||
.. py:class:: mindspore.nn.DynamicLossScaleUpdateCell(loss_scale_value, scale_factor, scale_window)
|
||||
|
||||
用于动态地更新梯度放大系数(loss scale)的神经元。
|
||||
|
||||
使用梯度放大功能进行训练时，初始梯度放大系数值为 `loss_scale_value`。在每个训练步骤中，当出现溢出时，通过计算公式 `loss_scale`/`scale_factor` 减小梯度放大系数。如果连续 `scale_window` 步（step）未溢出，则将通过 `loss_scale` * `scale_factor` 增大梯度放大系数。
|
||||
|
||||
该类是 :class:`mindspore.nn.DynamicLossScaleManager` 的 `get_update_cell` 方法的返回值。训练过程中，类 :class:`mindspore.TrainOneStepWithLossScaleCell` 会调用该Cell来更新梯度放大系数。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **loss_scale_value** (float)：初始的梯度放大系数。
|
||||
- **scale_factor** (int)：增减系数。
|
||||
- **scale_window** (int)：未溢出时，增大梯度放大系数的最大连续训练步数。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **loss_scale** (Tensor)：训练期间的梯度放大系数，shape为 :math:`()`。
|
||||
- **overflow** (bool)：是否发生溢出。
|
||||
|
||||
**输出：**
|
||||
|
||||
Bool，即输入 `overflow` 。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> import numpy as np
|
||||
>>> from mindspore import Tensor, Parameter, nn
|
||||
>>> import mindspore.ops as ops
|
||||
>>>
|
||||
>>> class Net(nn.Cell):
|
||||
... def __init__(self, in_features, out_features)：
|
||||
... super(Net, self).__init__()
|
||||
... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
|
||||
... name='weight')
|
||||
... self.matmul = ops.MatMul()
|
||||
...
|
||||
... def construct(self, x)：
|
||||
... output = self.matmul(x, self.weight)
|
||||
... return output
|
||||
...
|
||||
>>> in_features, out_features = 16, 10
|
||||
>>> net = Net(in_features, out_features)
|
||||
>>> loss = nn.MSELoss()
|
||||
>>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
|
||||
>>> net_with_loss = nn.WithLossCell(net, loss)
|
||||
>>> manager = nn.DynamicLossScaleUpdateCell(loss_scale_value=2**12, scale_factor=2, scale_window=1000)
|
||||
>>> train_network = nn.TrainOneStepWithLossScaleCell(net_with_loss, optimizer, scale_sense=manager)
|
||||
>>> input = Tensor(np.ones([out_features, in_features]), mindspore.float32)
|
||||
>>> labels = Tensor(np.ones([out_features,]), mindspore.float32)
|
||||
>>> output = train_network(input, labels)
|
||||
|
||||
|
||||
.. py:method:: get_loss_scale()
|
||||
|
||||
获取当前梯度放大系数。
|
||||
|
||||
|
|
@ -1,104 +1,104 @@
|
|||
mindspore.nn. mindspore.nn.FTRL
|
||||
================================
|
||||
|
||||
.. py:class:: mindspore.nn.FTRL(*args, **kwargs)
|
||||
|
||||
使用ApplyFtrl算子实现FTRL算法。
|
||||
|
||||
FTRL是一种在线凸优化算法，根据损失函数自适应地选择正则化函数。详见论文 `Adaptive Bound Optimization for Online Convex Optimization <https://arxiv.org/abs/1002.4908>`_。工程文档参阅 `Ad Click Prediction: a View from the Trenches <https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf>`_。
|
||||
|
||||
|
||||
更新公式如下：
|
||||
|
||||
.. math::
|
||||
|
||||
\begin{array}{ll} \\
|
||||
m_{t+1} = m_{t} + g^2 \\
|
||||
u_{t+1} = u_{t} + g - \frac{m_{t+1}^\text{-p} - m_{t}^\text{-p}}{\alpha } * \omega_{t} \\
|
||||
\omega_{t+1} =
|
||||
\begin{cases}
|
||||
\frac{(sign(u_{t+1}) * l1 - u_{t+1})}{\frac{m_{t+1}^\text{-p}}{\alpha } + 2 * l2 }
|
||||
& \text{ if } |u_{t+1}| > l1 \\
|
||||
0.0
|
||||
& \text{ otherwise }
|
||||
\end{cases}\\
|
||||
\end{array}
|
||||
|
||||
:math:`m` 表示累加器，:math:`g` 表示 `grads`， :math:`t` 表示当前step，:math:`u` 表示需要更新的线性系数，:math:`p` 表示` lr_power`，:math:`\alpha` 表示 `learning_rate` ，:math:`\omega` 表示 `params` 。
|
||||
|
||||
.. note::
|
||||
.. include:: mindspore.nn.optim_note_sparse.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_note_weight_decay.rst
|
||||
|
||||
**参数：**
|
||||
|
||||
- **params** (Union[list[Parameter], list[dict]]) - 必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、"grad_centralization"和"order_params"：
|
||||
|
||||
.. include:: mindspore.nn.optim_group_param.rst
|
||||
|
||||
- **lr** - 学习率当前不支持参数分组。
|
||||
|
||||
.. include:: mindspore.nn.optim_group_weight_decay.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_group_gc.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_group_order.rst
|
||||
|
||||
- **initial_accum** (float)：累加器 `m` 的初始值，必须大于等于零。默认值：0.1。
|
||||
- **learning_rate** (float)：学习速率值必须为零或正数，当前不支持动态学习率。默认值：0.001。
|
||||
- **lr_power** (float)：学习率的幂值，控制训练期间学习率的下降方式，必须小于或等于零。如果lr_power为零，则使用固定的学习率。默认值：-0.5。
|
||||
- **l1** (float)：l1正则化强度，必须大于等于零。默认值：0.0。
|
||||
- **l2** (float)：l2正则化强度，必须大于等于零。默认值：0.0。
|
||||
- **use_locking** (bool)：如果为True，则更新操作使用锁保护。默认值：False。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_loss_scale.rst
|
||||
|
||||
- **weight_decay** (Union[float, int])：要乘以权重的权重衰减值，必须为零或正值。默认值：0.0。
|
||||
|
||||
**输入：**
|
||||
|
||||
**grads** (tuple[Tensor])：优化器中 `params` 的梯度，shape与优化器中的 `params` 相同。
|
||||
|
||||
|
||||
**输出：**
|
||||
|
||||
tuple[Parameter]，更新的参数，shape与`params`相同。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`initial_accum`、`learning_rate`、`lr_power`、`l1`、`l2` 或 `loss_scale` 不是float。
|
||||
- **TypeError**：`parameters` 的元素不是Parameter或dict。
|
||||
- **TypeError**：`weight_decay` 不是float或int。
|
||||
- **TypeError**：`use_nesterov` 不是bool。
|
||||
- **ValueError**：`lr_power` 大于0。
|
||||
- **ValueError**：`loss_scale` 小于等于0。
|
||||
- **ValueError**：`initial_accum`、`l1` 或 `l2` 小于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> #1) 所有参数使用相同的学习率和权重衰减
|
||||
>>> optim = nn.FTRL(params=net.trainable_params())
|
||||
>>>
|
||||
>>> #2) 使用参数分组并设置不同的值
|
||||
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
|
||||
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
|
||||
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01, 'grad_centralization':True},
|
||||
... {'params': no_conv_params},
|
||||
... {'order_params': net.trainable_params()}]
|
||||
>>> optim = nn.FTRL(group_params, learning_rate=0.1, weight_decay=0.0)
|
||||
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01、该组的梯度中心化配置True。
|
||||
>>> # no_conv_params参数组使用优化器中的学习率0.1、优化器中的权重衰减0.0、梯度中心化使用默认值False。
|
||||
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
|
||||
>>>
|
||||
>>>
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=optim)
|
||||
|
||||
|
||||
mindspore.nn. mindspore.nn.FTRL
|
||||
================================
|
||||
|
||||
.. py:class:: mindspore.nn.FTRL(*args, **kwargs)
|
||||
|
||||
使用ApplyFtrl算子实现FTRL算法。
|
||||
|
||||
FTRL是一种在线凸优化算法，根据损失函数自适应地选择正则化函数。详见论文 `Adaptive Bound Optimization for Online Convex Optimization <https://arxiv.org/abs/1002.4908>`_。工程文档参阅 `Ad Click Prediction: a View from the Trenches <https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf>`_。
|
||||
|
||||
|
||||
更新公式如下：
|
||||
|
||||
.. math::
|
||||
|
||||
\begin{array}{ll} \\
|
||||
m_{t+1} = m_{t} + g^2 \\
|
||||
u_{t+1} = u_{t} + g - \frac{m_{t+1}^\text{-p} - m_{t}^\text{-p}}{\alpha } * \omega_{t} \\
|
||||
\omega_{t+1} =
|
||||
\begin{cases}
|
||||
\frac{(sign(u_{t+1}) * l1 - u_{t+1})}{\frac{m_{t+1}^\text{-p}}{\alpha } + 2 * l2 }
|
||||
& \text{ if } |u_{t+1}| > l1 \\
|
||||
0.0
|
||||
& \text{ otherwise }
|
||||
\end{cases}\\
|
||||
\end{array}
|
||||
|
||||
:math:`m` 表示累加器，:math:`g` 表示 `grads`， :math:`t` 表示当前step，:math:`u` 表示需要更新的线性系数，:math:`p` 表示` lr_power`，:math:`\alpha` 表示 `learning_rate` ，:math:`\omega` 表示 `params` 。
|
||||
|
||||
.. note::
|
||||
.. include:: mindspore.nn.optim_note_sparse.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_note_weight_decay.rst
|
||||
|
||||
**参数：**
|
||||
|
||||
- **params** (Union[list[Parameter], list[dict]]) - 必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、"grad_centralization"和"order_params"：
|
||||
|
||||
.. include:: mindspore.nn.optim_group_param.rst
|
||||
|
||||
- **lr** - 学习率当前不支持参数分组。
|
||||
|
||||
.. include:: mindspore.nn.optim_group_weight_decay.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_group_gc.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_group_order.rst
|
||||
|
||||
- **initial_accum** (float)：累加器 `m` 的初始值，必须大于等于零。默认值：0.1。
|
||||
- **learning_rate** (float)：学习速率值必须为零或正数，当前不支持动态学习率。默认值：0.001。
|
||||
- **lr_power** (float)：学习率的幂值，控制训练期间学习率的下降方式，必须小于或等于零。如果lr_power为零，则使用固定的学习率。默认值：-0.5。
|
||||
- **l1** (float)：l1正则化强度，必须大于等于零。默认值：0.0。
|
||||
- **l2** (float)：l2正则化强度，必须大于等于零。默认值：0.0。
|
||||
- **use_locking** (bool)：如果为True，则更新操作使用锁保护。默认值：False。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_loss_scale.rst
|
||||
|
||||
- **weight_decay** (Union[float, int])：要乘以权重的权重衰减值，必须为零或正值。默认值：0.0。
|
||||
|
||||
**输入：**
|
||||
|
||||
**grads** (tuple[Tensor])：优化器中 `params` 的梯度，shape与优化器中的 `params` 相同。
|
||||
|
||||
|
||||
**输出：**
|
||||
|
||||
tuple[Parameter]，更新的参数，shape与`params`相同。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`initial_accum`、`learning_rate`、`lr_power`、`l1`、`l2` 或 `loss_scale` 不是float。
|
||||
- **TypeError**：`parameters` 的元素不是Parameter或dict。
|
||||
- **TypeError**：`weight_decay` 不是float或int。
|
||||
- **TypeError**：`use_nesterov` 不是bool。
|
||||
- **ValueError**：`lr_power` 大于0。
|
||||
- **ValueError**：`loss_scale` 小于等于0。
|
||||
- **ValueError**：`initial_accum`、`l1` 或 `l2` 小于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> #1) 所有参数使用相同的学习率和权重衰减
|
||||
>>> optim = nn.FTRL(params=net.trainable_params())
|
||||
>>>
|
||||
>>> #2) 使用参数分组并设置不同的值
|
||||
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
|
||||
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
|
||||
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01, 'grad_centralization':True},
|
||||
... {'params': no_conv_params},
|
||||
... {'order_params': net.trainable_params()}]
|
||||
>>> optim = nn.FTRL(group_params, learning_rate=0.1, weight_decay=0.0)
|
||||
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01、该组的梯度中心化配置True。
|
||||
>>> # no_conv_params参数组使用优化器中的学习率0.1、优化器中的权重衰减0.0、梯度中心化使用默认值False。
|
||||
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
|
||||
>>>
|
||||
>>>
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=optim)
|
||||
|
||||
|
||||
.. include::mindspore.nn.optim_target_unique_for_sparse.rst
|
||||
|
|
@ -1,58 +1,58 @@
|
|||
mindspore.nn.FixedLossScaleUpdateCell
|
||||
=======================================
|
||||
|
||||
.. py:class:: mindspore.nn.FixedLossScaleUpdateCell(loss_scale_value)
|
||||
|
||||
固定梯度放大系数的神经元。
|
||||
|
||||
该类是 :class:`mindspore.nn.FixedLossScaleManager` 的 `get_update_cell` 方法的返回值。训练过程中，类 :class:`mindspore.TrainOneStepWithLossScaleCell` 会调用该Cell。
|
||||
|
||||
**参数：**
|
||||
|
||||
**loss_scale_value** (float)：初始梯度放大系数。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **loss_scale** (Tensor)：训练期间的梯度放大系数，shape为 :math:`()`，在当前类中，该值被忽略。
|
||||
- **overflow** (bool)：是否发生溢出。
|
||||
|
||||
**输出：**
|
||||
|
||||
Bool，即输入`overflow`。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> import numpy as np
|
||||
>>> from mindspore import Tensor, Parameter, nn, ops
|
||||
>>>
|
||||
>>> class Net(nn.Cell):
|
||||
... def __init__(self, in_features, out_features)：
|
||||
... super(Net, self).__init__()
|
||||
... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
|
||||
... name='weight')
|
||||
... self.matmul = ops.MatMul()
|
||||
...
|
||||
... def construct(self, x)：
|
||||
... output = self.matmul(x, self.weight)
|
||||
... return output
|
||||
...
|
||||
>>> in_features, out_features = 16, 10
|
||||
>>> net = Net(in_features, out_features)
|
||||
>>> loss = nn.MSELoss()
|
||||
>>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
|
||||
>>> net_with_loss = nn.WithLossCell(net, loss)
|
||||
>>> manager = nn.FixedLossScaleUpdateCell(loss_scale_value=2**12)
|
||||
>>> train_network = nn.TrainOneStepWithLossScaleCell(net_with_loss, optimizer, scale_sense=manager)
|
||||
>>> input = Tensor(np.ones([out_features, in_features]), mindspore.float32)
|
||||
>>> labels = Tensor(np.ones([out_features,]), mindspore.float32)
|
||||
>>> output = train_network(input, labels)
|
||||
|
||||
|
||||
.. py:method:: get_loss_scale()
|
||||
|
||||
获取当前梯度放大系数。
|
||||
mindspore.nn.FixedLossScaleUpdateCell
|
||||
=======================================
|
||||
|
||||
.. py:class:: mindspore.nn.FixedLossScaleUpdateCell(loss_scale_value)
|
||||
|
||||
固定梯度放大系数的神经元。
|
||||
|
||||
该类是 :class:`mindspore.nn.FixedLossScaleManager` 的 `get_update_cell` 方法的返回值。训练过程中，类 :class:`mindspore.TrainOneStepWithLossScaleCell` 会调用该Cell。
|
||||
|
||||
**参数：**
|
||||
|
||||
**loss_scale_value** (float)：初始梯度放大系数。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **loss_scale** (Tensor)：训练期间的梯度放大系数，shape为 :math:`()`，在当前类中，该值被忽略。
|
||||
- **overflow** (bool)：是否发生溢出。
|
||||
|
||||
**输出：**
|
||||
|
||||
Bool，即输入 `overflow`。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> import numpy as np
|
||||
>>> from mindspore import Tensor, Parameter, nn, ops
|
||||
>>>
|
||||
>>> class Net(nn.Cell):
|
||||
... def __init__(self, in_features, out_features)：
|
||||
... super(Net, self).__init__()
|
||||
... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
|
||||
... name='weight')
|
||||
... self.matmul = ops.MatMul()
|
||||
...
|
||||
... def construct(self, x)：
|
||||
... output = self.matmul(x, self.weight)
|
||||
... return output
|
||||
...
|
||||
>>> in_features, out_features = 16, 10
|
||||
>>> net = Net(in_features, out_features)
|
||||
>>> loss = nn.MSELoss()
|
||||
>>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
|
||||
>>> net_with_loss = nn.WithLossCell(net, loss)
|
||||
>>> manager = nn.FixedLossScaleUpdateCell(loss_scale_value=2**12)
|
||||
>>> train_network = nn.TrainOneStepWithLossScaleCell(net_with_loss, optimizer, scale_sense=manager)
|
||||
>>> input = Tensor(np.ones([out_features, in_features]), mindspore.float32)
|
||||
>>> labels = Tensor(np.ones([out_features,]), mindspore.float32)
|
||||
>>> output = train_network(input, labels)
|
||||
|
||||
|
||||
.. py:method:: get_loss_scale()
|
||||
|
||||
获取当前梯度放大系数。
|
||||
|
||||
|
|
@ -1,59 +1,59 @@
|
|||
mindspore.nn.ForwardValueAndGrad
|
||||
===================================
|
||||
|
||||
.. py:class:: mindspore.nn.ForwardValueAndGrad(network, weights=None, get_all=False, get_by_list=False, sens_param=False)
|
||||
|
||||
网络训练包类。
|
||||
|
||||
包括正向网络和梯度函数。该类生成的Cell使用'\*inputs'输入来训练。
|
||||
通过梯度函数来创建反向图，用以计算梯度。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **network** (Cell) - 训练网络。
|
||||
- **weights** (ParameterTuple) - 训练网络中需要计算梯度的的参数。
|
||||
- **get_all** (bool) - 如果为True，则计算网络输入对应的梯度。默认值：False。
|
||||
- **get_by_list** (bool) - 如果为True，则计算参数变量对应的梯度。如果 `get_all` 和 `get_by_list` 都为False，则计算第一个输入对应的梯度。如果 `get_all` 和 `get_by_list` 都为True，则以（（输入的梯度）,（参数的梯度））的形式同时获取输入和参数变量的梯度。默认值：False。
|
||||
- **sens_param** (bool) - 是否将sens作为输入。如果 `sens_param` 为False，则sens默认为'ones_like(outputs)'。默认值：False。如果 `sens_param` 为True，则需要指定sens的值。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **(\*inputs)** (Tuple(Tensor...))：shape为 :math:`(N, \ldots)` 的输入tuple。
|
||||
- **(sens)**：反向传播梯度的缩放值。如果网络有单个输出，则sens是tensor。如果网络有多个输出，则sens是tuple(tensor)。
|
||||
|
||||
**输出：**
|
||||
|
||||
- **forward value** - 网络运行的正向结果。
|
||||
- **gradients** (tuple(tensor)) - 网络反向传播的梯度。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> class Net(nn.Cell):
|
||||
... def __init__(self)：
|
||||
... super(Net, self).__init__()
|
||||
... self.weight = Parameter(Tensor(np.ones([2, 2]).astype(np.float32)), name="weight")
|
||||
... self.matmul = P.MatMul()
|
||||
...
|
||||
... def construct(self, x)：
|
||||
... out = self.matmul(x, self.weight)
|
||||
... return out
|
||||
...
|
||||
>>> net = Net()
|
||||
>>> criterion = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> net_with_criterion = nn.WithLossCell(net, criterion)
|
||||
>>> weight = ParameterTuple(net.trainable_params())
|
||||
>>> train_network = nn.ForwardValueAndGrad(net_with_criterion, weights=weight, get_all=True, get_by_list=True)
|
||||
>>> inputs = Tensor(np.ones([1, 2]).astype(np.float32))
|
||||
>>> labels = Tensor(np.zeros([1, 2]).astype(np.float32))
|
||||
>>> result = train_network(inputs, labels)
|
||||
>>> print(result)
|
||||
(Tensor(shape=[1], dtype=Float32, value=[0.00000000e+00]), ((Tensor(shape=[1, 2], dtype=Float32, value=
|
||||
[[1.00000000e+00, 1.00000000e+00]]), Tensor(shape=[1, 2], dtype=Float32, value=
|
||||
[[0.00000000e+00, 0.00000000e+00]])), (Tensor(shape=[2, 2], dtype=Float32, value=
|
||||
[[5.00000000e-01, 5.00000000e-01],
|
||||
[5.00000000e-01, 5.00000000e-01]]),)))
|
||||
mindspore.nn.ForwardValueAndGrad
|
||||
===================================
|
||||
|
||||
.. py:class:: mindspore.nn.ForwardValueAndGrad(network, weights=None, get_all=False, get_by_list=False, sens_param=False)
|
||||
|
||||
网络训练包类。
|
||||
|
||||
包括正向网络和梯度函数。该类生成的Cell使用'\*inputs'输入来训练。
|
||||
通过梯度函数来创建反向图，用以计算梯度。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **network** (Cell) - 训练网络。
|
||||
- **weights** (ParameterTuple) - 训练网络中需要计算梯度的的参数。
|
||||
- **get_all** (bool) - 如果为True，则计算网络输入对应的梯度。默认值：False。
|
||||
- **get_by_list** (bool) - 如果为True，则计算参数变量对应的梯度。如果 `get_all` 和 `get_by_list` 都为False，则计算第一个输入对应的梯度。如果 `get_all` 和 `get_by_list` 都为True，则以（（输入的梯度）,（参数的梯度））的形式同时获取输入和参数变量的梯度。默认值：False。
|
||||
- **sens_param** (bool) - 是否将sens作为输入。如果 `sens_param` 为False，则sens默认为'ones_like(outputs)'。默认值：False。如果 `sens_param` 为True，则需要指定sens的值。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **(\*inputs)** (Tuple(Tensor...))：shape为 :math:`(N, \ldots)` 的输入tuple。
|
||||
- **(sens)**：反向传播梯度的缩放值。如果网络有单个输出，则sens是tensor。如果网络有多个输出，则sens是tuple(tensor)。
|
||||
|
||||
**输出：**
|
||||
|
||||
- **forward value** - 网络运行的正向结果。
|
||||
- **gradients** (tuple(tensor)) - 网络反向传播的梯度。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> class Net(nn.Cell):
|
||||
... def __init__(self)：
|
||||
... super(Net, self).__init__()
|
||||
... self.weight = Parameter(Tensor(np.ones([2, 2]).astype(np.float32)), name="weight")
|
||||
... self.matmul = P.MatMul()
|
||||
...
|
||||
... def construct(self, x)：
|
||||
... out = self.matmul(x, self.weight)
|
||||
... return out
|
||||
...
|
||||
>>> net = Net()
|
||||
>>> criterion = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> net_with_criterion = nn.WithLossCell(net, criterion)
|
||||
>>> weight = ParameterTuple(net.trainable_params())
|
||||
>>> train_network = nn.ForwardValueAndGrad(net_with_criterion, weights=weight, get_all=True, get_by_list=True)
|
||||
>>> inputs = Tensor(np.ones([1, 2]).astype(np.float32))
|
||||
>>> labels = Tensor(np.zeros([1, 2]).astype(np.float32))
|
||||
>>> result = train_network(inputs, labels)
|
||||
>>> print(result)
|
||||
(Tensor(shape=[1], dtype=Float32, value=[0.00000000e+00]), ((Tensor(shape=[1, 2], dtype=Float32, value=
|
||||
[[1.00000000e+00, 1.00000000e+00]]), Tensor(shape=[1, 2], dtype=Float32, value=
|
||||
[[0.00000000e+00, 0.00000000e+00]])), (Tensor(shape=[2, 2], dtype=Float32, value=
|
||||
[[5.00000000e-01, 5.00000000e-01],
|
||||
[5.00000000e-01, 5.00000000e-01]]),)))
|
||||
|
||||
|
|
@ -1,59 +1,59 @@
|
|||
mindspore.nn.InverseDecayLR
|
||||
=============================
|
||||
|
||||
.. py:class:: mindspore.nn.InverseDecayLR(learning_rate, decay_rate, decay_steps, is_stair=False)
|
||||
|
||||
基于逆时衰减函数计算学习率。
|
||||
|
||||
对于当前step，计算decayed_learning_rate[current\_step]的公式为：
|
||||
|
||||
.. math::
|
||||
decayed\_learning\_rate[current\_step] = learning\_rate / (1 + decay\_rate * p)
|
||||
|
||||
其中，
|
||||
|
||||
.. math::
|
||||
p = \frac{current\_step}{decay\_steps}
|
||||
|
||||
如果 `is_stair` 为True，则公式为：
|
||||
|
||||
.. math::
|
||||
p = floor(\frac{current\_step}{decay\_steps})
|
||||
|
||||
**参数：**
|
||||
|
||||
- **learning_rate** (float)：学习率的初始值。
|
||||
- **decay_rate** (float)：衰减率。
|
||||
- **decay_steps** (int)：用于计算衰减学习率的值。
|
||||
- **is_stair** (bool)：如果为True，则学习率每 `decay_steps` 次衰减一次。默认值：False。
|
||||
|
||||
**输入：**
|
||||
|
||||
**global_step** (Tensor)：当前step数。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor。当前step的学习率值，shape为:math:`()`。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate` 或 `decay_rate` 不是float。
|
||||
- **TypeError**：`decay_steps` 不是int或 `is_stair` 不是bool。
|
||||
- **ValueError**：`decay_steps` 小于1。
|
||||
- **ValueError**：`learning_rate` 或 `decay_rate` 小于或等于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> learning_rate = 0.1
|
||||
>>> decay_rate = 0.9
|
||||
>>> decay_steps = 4
|
||||
>>> global_step = Tensor(2, mstype.int32)
|
||||
>>> inverse_decay_lr = nn.InverseDecayLR(learning_rate, decay_rate, decay_steps, True)
|
||||
>>> result = inverse_decay_lr(global_step)
|
||||
>>> print(result)
|
||||
0.1
|
||||
mindspore.nn.InverseDecayLR
|
||||
=============================
|
||||
|
||||
.. py:class:: mindspore.nn.InverseDecayLR(learning_rate, decay_rate, decay_steps, is_stair=False)
|
||||
|
||||
基于逆时衰减函数计算学习率。
|
||||
|
||||
对于当前step，计算decayed_learning_rate[current\_step]的公式为：
|
||||
|
||||
.. math::
|
||||
decayed\_learning\_rate[current\_step] = learning\_rate / (1 + decay\_rate * p)
|
||||
|
||||
其中，
|
||||
|
||||
.. math::
|
||||
p = \frac{current\_step}{decay\_steps}
|
||||
|
||||
如果 `is_stair` 为True，则公式为：
|
||||
|
||||
.. math::
|
||||
p = floor(\frac{current\_step}{decay\_steps})
|
||||
|
||||
**参数：**
|
||||
|
||||
- **learning_rate** (float)：学习率的初始值。
|
||||
- **decay_rate** (float)：衰减率。
|
||||
- **decay_steps** (int)：用于计算衰减学习率的值。
|
||||
- **is_stair** (bool)：如果为True，则学习率每 `decay_steps` 次衰减一次。默认值：False。
|
||||
|
||||
**输入：**
|
||||
|
||||
**global_step** (Tensor)：当前step数。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor。当前step的学习率值，shape为:math:`()`。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate` 或 `decay_rate` 不是float。
|
||||
- **TypeError**：`decay_steps` 不是int或 `is_stair` 不是bool。
|
||||
- **ValueError**：`decay_steps` 小于1。
|
||||
- **ValueError**：`learning_rate` 或 `decay_rate` 小于或等于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> learning_rate = 0.1
|
||||
>>> decay_rate = 0.9
|
||||
>>> decay_steps = 4
|
||||
>>> global_step = Tensor(2, mstype.int32)
|
||||
>>> inverse_decay_lr = nn.InverseDecayLR(learning_rate, decay_rate, decay_steps, True)
|
||||
>>> result = inverse_decay_lr(global_step)
|
||||
>>> print(result)
|
||||
0.1
|
||||
|
||||
|
|
@ -1,58 +1,58 @@
|
|||
mindspore.nn.Lamb
|
||||
==================
|
||||
|
||||
.. py:class:: mindspore.nn.LARS(*args, **kwargs)
|
||||
|
||||
使用LARSUpdate算子实现LARS算法。
|
||||
|
||||
LARS算法采用大量的优化技术。详见论文 `LARGE BATCH TRAINING OF CONVOLUTIONAL NETWORKS <https://arxiv.org/abs/1708.03888>`_。
|
||||
|
||||
更新公式如下：
|
||||
|
||||
.. math::
|
||||
|
||||
\begin{array}{ll} \\
|
||||
\lambda = \frac{\theta \text{ * } || \omega || } \\
|
||||
{|| g_{t} || \text{ + } \delta \text{ * } || \omega || } \\
|
||||
\lambda =
|
||||
\begin{cases}
|
||||
\min(\frac{\lambda}{\alpha }, 1)
|
||||
& \text{ if } clip = True \\
|
||||
\lambda
|
||||
& \text{ otherwise }
|
||||
\end{cases}\\
|
||||
g_{t+1} = \lambda * (g_{t} + \delta * \omega)
|
||||
\end{array}
|
||||
|
||||
:math:`\theta`表示`coefficient`，:math:`\omega`表示网络参数，:math:`g`表示`gradients`，:math:`t`表示当前step，:math:`\delta`表示`optimizer`配置的`weight_decay`，:math:`\alpha`表示`optimizer`配置的`learning_rate`，:math:`clip`表示`use_clip`。
|
||||
|
||||
|
||||
**参数：**
|
||||
|
||||
- **optimizer** (Optimizer)：待封装和修改梯度的MindSpore优化器。
|
||||
- **epsilon** (float)：将添加到分母中，提高数值稳定性。默认值：1e-05。
|
||||
- **coefficient** (float)：计算局部学习速率的信任系数。默认值：0.001。
|
||||
- **use_clip** (bool)：计算局部学习速率时是否裁剪。默认值：False。
|
||||
- **lars_filter** (Function)：用于指定使用LARS算法的网络参数。默认值：lambda x: 'LayerNorm' not in x.name and 'bias' not in x.name。
|
||||
|
||||
**输入：**
|
||||
|
||||
**gradients** (tuple[Tensor])：优化器中`params`的梯度，shape与优化器中的`params`相同。
|
||||
|
||||
|
||||
**输出：**
|
||||
|
||||
Union[Tensor[bool], tuple[Parameter]]，取决于`optimizer`的输出。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> opt = nn.Momentum(net.trainable_params(), 0.1, 0.9)
|
||||
>>> opt_lars = nn.LARS(opt, epsilon=1e-08, coefficient=0.02)
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=opt_lars, metrics=None)
|
||||
mindspore.nn.Lamb
|
||||
==================
|
||||
|
||||
.. py:class:: mindspore.nn.LARS(*args, **kwargs)
|
||||
|
||||
使用LARSUpdate算子实现LARS算法。
|
||||
|
||||
LARS算法采用大量的优化技术。详见论文 `LARGE BATCH TRAINING OF CONVOLUTIONAL NETWORKS <https://arxiv.org/abs/1708.03888>`_。
|
||||
|
||||
更新公式如下：
|
||||
|
||||
.. math::
|
||||
|
||||
\begin{array}{ll} \\
|
||||
\lambda = \frac{\theta \text{ * } || \omega || } \\
|
||||
{|| g_{t} || \text{ + } \delta \text{ * } || \omega || } \\
|
||||
\lambda =
|
||||
\begin{cases}
|
||||
\min(\frac{\lambda}{\alpha }, 1)
|
||||
& \text{ if } clip = True \\
|
||||
\lambda
|
||||
& \text{ otherwise }
|
||||
\end{cases}\\
|
||||
g_{t+1} = \lambda * (g_{t} + \delta * \omega)
|
||||
\end{array}
|
||||
|
||||
:math:`\theta` 表示 `coefficient` ，:math:`\omega` 表示网络参数，:math:`g` 表示 `gradients`，:math:`t` 表示当前step，:math:`\delta` 表示 `optimizer` 配置的 `weight_decay` ，:math:`\alpha` 表示 `optimizer` 配置的 `learning_rate` ，:math:`clip` 表示 `use_clip`。
|
||||
|
||||
|
||||
**参数：**
|
||||
|
||||
- **optimizer** (Optimizer)：待封装和修改梯度的MindSpore优化器。
|
||||
- **epsilon** (float)：将添加到分母中，提高数值稳定性。默认值：1e-05。
|
||||
- **coefficient** (float)：计算局部学习速率的信任系数。默认值：0.001。
|
||||
- **use_clip** (bool)：计算局部学习速率时是否裁剪。默认值：False。
|
||||
- **lars_filter** (Function)：用于指定使用LARS算法的网络参数。默认值：lambda x: 'LayerNorm' not in x.name and 'bias' not in x.name。
|
||||
|
||||
**输入：**
|
||||
|
||||
**gradients** (tuple[Tensor])：优化器中 `params` 的梯度，shape与优化器中的 `params` 相同。
|
||||
|
||||
|
||||
**输出：**
|
||||
|
||||
Union[Tensor[bool], tuple[Parameter]]，取决于 `optimizer` 的输出。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> opt = nn.Momentum(net.trainable_params(), 0.1, 0.9)
|
||||
>>> opt_lars = nn.LARS(opt, epsilon=1e-08, coefficient=0.02)
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=opt_lars, metrics=None)
|
||||
|
||||
|
|
@ -1,95 +1,94 @@
|
|||
mindspore.nn.Lamb
|
||||
==================
|
||||
|
||||
.. py:class:: mindspore.nn.Lamb(*args, **kwargs)
|
||||
|
||||
LAMB（Layer-wise Adaptive Moments optimizer for Batching training，用于批训练的分层自适应矩优化器）算法优化器。
|
||||
|
||||
LAMB是一种采用分层自适应批优化技术的优化算法。详见论文 `LARGE BATCH OPTIMIZATION FOR DEEP LEARNING: TRAINING BERT IN 76 MINUTES <https://arxiv.org/abs/1904.00962>`_。
|
||||
|
||||
LAMB优化器旨在不降低精度的情况下增加训练batch size，支持自适应逐元素更新和精确的分层校正。
|
||||
|
||||
|
||||
参数更新如下：
|
||||
|
||||
.. math::
|
||||
\begin{gather*}
|
||||
m_t = \beta_1 m_{t - 1}+ (1 - \beta_1)g_t\\
|
||||
v_t = \beta_2 v_{t - 1} + (1 - \beta_2)g_t^2\\
|
||||
m_t = \frac{m_t}{\beta_1^t}\\
|
||||
v_t = \frac{v_t}{\beta_2^t}\\
|
||||
r_t = \frac{m_t}{\sqrt{v_t}+\epsilon}\\
|
||||
w_t = w_{t-1} -\eta_t \frac{\| w_{t-1} \|}{\| r_t + \lambda w_{t-1} \|} (r_t + \lambda w_{t-1})
|
||||
\end{gather*}
|
||||
|
||||
其中，math:`m`代表第一个矩向量，:math:`v`代表第二个矩向量，:math:`\eta`表示学习率，:math:`\lambda`表示LAMB权重衰减率。
|
||||
|
||||
|
||||
.. note::
|
||||
.. include:: mindspore.nn.optim_note_weight_decay.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_note_loss_scale.rst
|
||||
|
||||
**参数：**
|
||||
|
||||
- **params** (Union[list[Parameter], list[dict]]): 必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、"grad_centralization"和"order_params"：
|
||||
|
||||
.. include:: mindspore.nn.optim_group_param.rst
|
||||
.. include:: mindspore.nn.optim_group_lr.rst
|
||||
.. include:: mindspore.nn.optim_group_weight_decay.rst
|
||||
.. include:: mindspore.nn.optim_group_gc.rst
|
||||
.. include:: mindspore.nn.optim_group_order.rst
|
||||
|
||||
- **learning_rate (Union[float, Tensor, Iterable, LearningRateSchedule]):
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_dynamic_lr.rst
|
||||
|
||||
- **beta1** (float)：第一矩的指数衰减率。参数范围（0.0,1.0）。默认值：0.9。
|
||||
- **beta2** (float)：第二矩的指数衰减率。参数范围（0.0,1.0）。默认值：0.999。
|
||||
- **eps** (float)：将添加到分母中，以提高数值稳定性。必须大于0。默认值：1e-6。
|
||||
- **weight_decay** (float)：权重衰减（L2 penalty）。必须大于等于0。默认值：0.0。
|
||||
|
||||
**输入：**
|
||||
|
||||
**gradients** (tuple[Tensor])：`params`的梯度，shape与`params`相同。
|
||||
|
||||
**输出：**
|
||||
|
||||
tuple[bool]，所有元素都为True。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate`不是int、float、Tensor、Iterable或LearningRateSchedule。
|
||||
- **TypeError**：`parameters`的元素不是Parameter或dict。
|
||||
- **TypeError**：`beta1`、`beta2`或`eps`不是float。
|
||||
- **TypeError**：`weight_decay`不是float或int。
|
||||
- **ValueError**：`eps`小于等于0。
|
||||
- **ValueError**：`beta1`、`beta2`不在（0.0,1.0）范围内。
|
||||
- **ValueError**：`weight_decay`小于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> #1) 所有参数使用相同的学习率和权重衰减
|
||||
>>> optim = nn.Lamb(params=net.trainable_params(), learning_rate=0.1)
|
||||
>>>
|
||||
>>> #2) 使用参数分组并设置不同的值
|
||||
>>> poly_decay_lr = learning_rate_schedule.PolynomialDecayLR(learning_rate=0.1, end_learning_rate=0.01,
|
||||
... decay_steps=4, power = 0.5)
|
||||
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
|
||||
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
|
||||
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01, 'grad_centralization':True},
|
||||
... {'params': no_conv_params, 'lr': poly_decay_lr},
|
||||
... {'order_params': net.trainable_params(0.01)}]
|
||||
>>> optim = nn.Lamb(group_params, learning_rate=0.1, weight_decay=0.0)
|
||||
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01、该组的梯度中心化配置True。
|
||||
>>> # no_conv_params参数组将使用该组的衰减学习率、优化器中的权重衰减0.0、梯度中心化使用默认值False。
|
||||
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
|
||||
>>>
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=optim)
|
||||
mindspore.nn.Lamb
|
||||
==================
|
||||
|
||||
.. py:class:: mindspore.nn.Lamb(*args, **kwargs)
|
||||
|
||||
LAMB（Layer-wise Adaptive Moments optimizer for Batching training，用于批训练的分层自适应矩优化器）算法优化器。
|
||||
|
||||
LAMB是一种采用分层自适应批优化技术的优化算法。详见论文 `LARGE BATCH OPTIMIZATION FOR DEEP LEARNING: TRAINING BERT IN 76 MINUTES <https://arxiv.org/abs/1904.00962>`_。
|
||||
|
||||
LAMB优化器旨在不降低精度的情况下增加训练batch size，支持自适应逐元素更新和精确的分层校正。
|
||||
|
||||
|
||||
参数更新如下：
|
||||
|
||||
.. math::
|
||||
\begin{gather*}
|
||||
m_t = \beta_1 m_{t - 1}+ (1 - \beta_1)g_t\\
|
||||
v_t = \beta_2 v_{t - 1} + (1 - \beta_2)g_t^2\\
|
||||
m_t = \frac{m_t}{\beta_1^t}\\
|
||||
v_t = \frac{v_t}{\beta_2^t}\\
|
||||
r_t = \frac{m_t}{\sqrt{v_t}+\epsilon}\\
|
||||
w_t = w_{t-1} -\eta_t \frac{\| w_{t-1} \|}{\| r_t + \lambda w_{t-1} \|} (r_t + \lambda w_{t-1})
|
||||
\end{gather*}
|
||||
|
||||
其中，math:`m` 代表第一个矩向量，:math:`v` 代表第二个矩向量，:math:`\eta` 表示学习率，:math:`\lambda` 表示LAMB权重衰减率。
|
||||
|
||||
.. note::
|
||||
.. include:: mindspore.nn.optim_note_weight_decay.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_note_loss_scale.rst
|
||||
|
||||
**参数：**
|
||||
|
||||
- **params** (Union[list[Parameter], list[dict]]): 必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、"grad_centralization"和"order_params"：
|
||||
|
||||
.. include:: mindspore.nn.optim_group_param.rst
|
||||
.. include:: mindspore.nn.optim_group_lr.rst
|
||||
.. include:: mindspore.nn.optim_group_weight_decay.rst
|
||||
.. include:: mindspore.nn.optim_group_gc.rst
|
||||
.. include:: mindspore.nn.optim_group_order.rst
|
||||
|
||||
- **learning_rate** (Union[float, Tensor, Iterable, LearningRateSchedule]):
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_dynamic_lr.rst
|
||||
|
||||
- **beta1** (float)：第一矩的指数衰减率。参数范围（0.0,1.0）。默认值：0.9。
|
||||
- **beta2** (float)：第二矩的指数衰减率。参数范围（0.0,1.0）。默认值：0.999。
|
||||
- **eps** (float)：将添加到分母中，以提高数值稳定性。必须大于0。默认值：1e-6。
|
||||
- **weight_decay** (float)：权重衰减（L2 penalty）。必须大于等于0。默认值：0.0。
|
||||
|
||||
**输入：**
|
||||
|
||||
**gradients** (tuple[Tensor])：`params` 的梯度，shape与 `params` 相同。
|
||||
|
||||
**输出：**
|
||||
|
||||
tuple[bool]，所有元素都为True。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
|
||||
- **TypeError**：`parameters` 的元素不是Parameter或dict。
|
||||
- **TypeError**：`beta1`、`beta2` 或 `eps` 不是float。
|
||||
- **TypeError**：`weight_decay` 不是float或int。
|
||||
- **ValueError**：`eps` 小于等于0。
|
||||
- **ValueError**：`beta1`、`beta2` 不在（0.0,1.0）范围内。
|
||||
- **ValueError**：`weight_decay` 小于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> #1) 所有参数使用相同的学习率和权重衰减
|
||||
>>> optim = nn.Lamb(params=net.trainable_params(), learning_rate=0.1)
|
||||
>>>
|
||||
>>> #2) 使用参数分组并设置不同的值
|
||||
>>> poly_decay_lr = learning_rate_schedule.PolynomialDecayLR(learning_rate=0.1, end_learning_rate=0.01,
|
||||
... decay_steps=4, power = 0.5)
|
||||
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
|
||||
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
|
||||
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01, 'grad_centralization':True},
|
||||
... {'params': no_conv_params, 'lr': poly_decay_lr},
|
||||
... {'order_params': net.trainable_params(0.01)}]
|
||||
>>> optim = nn.Lamb(group_params, learning_rate=0.1, weight_decay=0.0)
|
||||
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01、该组的梯度中心化配置True。
|
||||
>>> # no_conv_params参数组将使用该组的衰减学习率、优化器中的权重衰减0.0、梯度中心化使用默认值False。
|
||||
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
|
||||
>>>
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=optim)
|
||||
|
||||
|
|
@ -1,97 +1,97 @@
|
|||
mindspore.nn.LazyAdam
|
||||
======================
|
||||
|
||||
.. py:class:: mindspore.nn.LazyAdam(*args, **kwargs)
|
||||
|
||||
通过Adaptive Moment Estimation (Adam)算法更新梯度。请参阅论文 `Adam: A Method for Stochastic Optimization <https://arxiv.org/abs/1412.6980>`_。
|
||||
|
||||
当梯度稀疏时，此优化器将使用Lazy Adam算法。
|
||||
|
||||
更新公式如下：
|
||||
|
||||
.. math::
|
||||
\begin{array}{ll} \\
|
||||
m_{t+1} = \beta_1 * m_{t} + (1 - \beta_1) * g \\
|
||||
v_{t+1} = \beta_2 * v_{t} + (1 - \beta_2) * g * g \\
|
||||
l = \alpha * \frac{\sqrt{1-\beta_2^t}}{1-\beta_1^t} \\
|
||||
w_{t+1} = w_{t} - l * \frac{m_{t+1}}{\sqrt{v_{t+1}} + \epsilon}
|
||||
\end{array}
|
||||
|
||||
:math:`m` 代表第一个矩向量 `moment1` ，:math:`v` 代表第二个矩向量 `moment2` ，:math:`g` 代表 `gradients` ，:math:`l` 代表缩放因子，:math:`\beta_1,\beta_2` 代表 `beta1` 和 `beta2` ，:math:`t` 代表当前step，:math:`beta_1^t` 和 :math:`beta_2^t` 代表 `beta1_power` 和 `beta2_power` ， :math:`\alpha` 代表 `learning_rate` ， :math:`w` 代表 `params` ， :math:`\epsilon` 代表 `eps`。
|
||||
|
||||
|
||||
.. note::
|
||||
.. include:: mindspore.nn.optim_note_sparse.rst
|
||||
|
||||
需要注意的是，梯度稀疏时该优化器只更新网络参数的当前的索引位置，稀疏行为不等同于Adam算法。
|
||||
|
||||
.. include:: mindspore.nn.optim_note_weight_decay.rst
|
||||
|
||||
**参数：**
|
||||
|
||||
- **param** (Union[list[Parameter], list[dict]]) - 必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、"grad_centralization"和"order_params"：
|
||||
|
||||
.. include:: mindspore.nn.optim_group_param.rst
|
||||
.. include:: mindspore.nn.optim_group_lr.rst
|
||||
.. include:: mindspore.nn.optim_group_weight_decay.rst
|
||||
.. include:: mindspore.nn.optim_group_gc.rst
|
||||
.. include:: mindspore.nn.optim_group_order.rst
|
||||
|
||||
- **learning_rate (Union[float, Tensor, Iterable, LearningRateSchedule]): 默认值：1e-3。
|
||||
|
||||
.. include:: mindspore.nn.optim_dynamic_lr.rst
|
||||
|
||||
- **beta1 (float)：`moment1` 的指数衰减率。参数范围（0.0,1.0）。默认值：0.9。
|
||||
- **beta2 (float)：moment2` 的指数衰减率。参数范围（0.0,1.0）。默认值：0.999。
|
||||
- **eps (float)：将添加到分母中，以提高数值稳定性。必须大于0。默认值：1e-8。
|
||||
- **use_locking (bool)：是否对参数更新加锁保护。如果为True，则 `w` 、`m` 和 `v` 的Tensor更新将受到锁的保护。如果为False，则结果不可预测。默认值：False。
|
||||
- **use_nesterov (bool)：是否使用Nesterov Accelerated Gradient (NAG)算法更新梯度。如果为True，使用NAG更新梯度。如果为False，则在不使用NAG的情况下更新梯度。默认值：False。
|
||||
- **weight_decay (Union[float, int])：权重衰减（L2 penalty）。必须大于等于0。默认值：0.0。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_loss_scale.rst
|
||||
|
||||
**输入：**
|
||||
|
||||
**gradients** (tuple[Tensor])：`params` 的梯度，shape与 `params` 相同。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor[bool]，值为True。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
|
||||
- **TypeError**：`parameters` 的元素不是Parameter或字典。
|
||||
- **TypeError**：`beta1`、`beta2`、`eps` 或 `loss_scale` 不是float。
|
||||
- **TypeError**：`weight_decay` 不是float或int。
|
||||
- **TypeError**：`use_locking` 或 `use_nesterov` 不是bool。
|
||||
- **ValueError**：`loss_scale `或 `eps` 小于或等于0。
|
||||
- **ValueError**：`beta1`、`beta2` 不在（0.0,1.0）范围内。
|
||||
- **ValueError**：`weight_decay` 小于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> #1) 所有参数使用相同的学习率和权重衰减
|
||||
>>> optim = nn.LazyAdam(params=net.trainable_params())
|
||||
>>>
|
||||
>>> #2) 使用参数分组并设置不同的值
|
||||
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
|
||||
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
|
||||
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01, 'grad_centralization':True},
|
||||
... {'params': no_conv_params, 'lr': 0.01},
|
||||
... {'order_params': net.trainable_params()}]
|
||||
>>> optim = nn.LazyAdam(group_params, learning_rate=0.1, weight_decay=0.0)
|
||||
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01、该组的梯度中心化配置True。
|
||||
>>> # no_conv_params参数组将使用该组的学习率0.01、优化器中的权重衰减0.0、梯度中心化使用默认值False。
|
||||
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
|
||||
>>>
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=optim)
|
||||
|
||||
.. include:: mindspore.nn.optim_target_unique_for_sparse.rst
|
||||
mindspore.nn.LazyAdam
|
||||
======================
|
||||
|
||||
.. py:class:: mindspore.nn.LazyAdam(*args, **kwargs)
|
||||
|
||||
通过Adaptive Moment Estimation (Adam)算法更新梯度。请参阅论文 `Adam: A Method for Stochastic Optimization <https://arxiv.org/abs/1412.6980>`_。
|
||||
|
||||
当梯度稀疏时，此优化器将使用Lazy Adam算法。
|
||||
|
||||
更新公式如下：
|
||||
|
||||
.. math::
|
||||
\begin{array}{ll} \\
|
||||
m_{t+1} = \beta_1 * m_{t} + (1 - \beta_1) * g \\
|
||||
v_{t+1} = \beta_2 * v_{t} + (1 - \beta_2) * g * g \\
|
||||
l = \alpha * \frac{\sqrt{1-\beta_2^t}}{1-\beta_1^t} \\
|
||||
w_{t+1} = w_{t} - l * \frac{m_{t+1}}{\sqrt{v_{t+1}} + \epsilon}
|
||||
\end{array}
|
||||
|
||||
:math:`m` 代表第一个矩向量 `moment1` ，:math:`v` 代表第二个矩向量 `moment2` ，:math:`g` 代表 `gradients` ，:math:`l` 代表缩放因子，:math:`\beta_1,\beta_2` 代表 `beta1` 和 `beta2` ，:math:`t` 代表当前step，:math:`beta_1^t` 和 :math:`beta_2^t` 代表 `beta1_power` 和 `beta2_power` ， :math:`\alpha` 代表 `learning_rate` ， :math:`w` 代表 `params` ， :math:`\epsilon` 代表 `eps`。
|
||||
|
||||
|
||||
.. note::
|
||||
.. include:: mindspore.nn.optim_note_sparse.rst
|
||||
|
||||
需要注意的是，梯度稀疏时该优化器只更新网络参数的当前的索引位置，稀疏行为不等同于Adam算法。
|
||||
|
||||
.. include:: mindspore.nn.optim_note_weight_decay.rst
|
||||
|
||||
**参数：**
|
||||
|
||||
- **param** (Union[list[Parameter], list[dict]]) - 必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、"grad_centralization"和"order_params"：
|
||||
|
||||
.. include:: mindspore.nn.optim_group_param.rst
|
||||
.. include:: mindspore.nn.optim_group_lr.rst
|
||||
.. include:: mindspore.nn.optim_group_weight_decay.rst
|
||||
.. include:: mindspore.nn.optim_group_gc.rst
|
||||
.. include:: mindspore.nn.optim_group_order.rst
|
||||
|
||||
- **learning_rate** (Union[float, Tensor, Iterable, LearningRateSchedule]): 默认值：1e-3。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_dynamic_lr.rst
|
||||
|
||||
- **beta1** (float)：`moment1` 的指数衰减率。参数范围（0.0,1.0）。默认值：0.9。
|
||||
- **beta2** (float)：moment2` 的指数衰减率。参数范围（0.0,1.0）。默认值：0.999。
|
||||
- **eps** (float)：将添加到分母中，以提高数值稳定性。必须大于0。默认值：1e-8。
|
||||
- **use_locking** (bool)：是否对参数更新加锁保护。如果为True，则 `w` 、`m` 和 `v` 的Tensor更新将受到锁的保护。如果为False，则结果不可预测。默认值：False。
|
||||
- **use_nesterov** (bool)：是否使用Nesterov Accelerated Gradient (NAG)算法更新梯度。如果为True，使用NAG更新梯度。如果为False，则在不使用NAG的情况下更新梯度。默认值：False。
|
||||
- **weight_decay** (Union[float, int])：权重衰减（L2 penalty）。必须大于等于0。默认值：0.0。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_loss_scale.rst
|
||||
|
||||
**输入：**
|
||||
|
||||
**gradients** (tuple[Tensor])：`params` 的梯度，shape与 `params` 相同。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor[bool]，值为True。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
|
||||
- **TypeError**：`parameters` 的元素不是Parameter或字典。
|
||||
- **TypeError**：`beta1`、`beta2`、`eps` 或 `loss_scale` 不是float。
|
||||
- **TypeError**：`weight_decay` 不是float或int。
|
||||
- **TypeError**：`use_locking` 或 `use_nesterov` 不是bool。
|
||||
- **ValueError**：`loss_scale `或 `eps` 小于或等于0。
|
||||
- **ValueError**：`beta1`、`beta2` 不在（0.0,1.0）范围内。
|
||||
- **ValueError**：`weight_decay` 小于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> #1) 所有参数使用相同的学习率和权重衰减
|
||||
>>> optim = nn.LazyAdam(params=net.trainable_params())
|
||||
>>>
|
||||
>>> #2) 使用参数分组并设置不同的值
|
||||
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
|
||||
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
|
||||
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01, 'grad_centralization':True},
|
||||
... {'params': no_conv_params, 'lr': 0.01},
|
||||
... {'order_params': net.trainable_params()}]
|
||||
>>> optim = nn.LazyAdam(group_params, learning_rate=0.1, weight_decay=0.0)
|
||||
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01、该组的梯度中心化配置True。
|
||||
>>> # no_conv_params参数组将使用该组的学习率0.01、优化器中的权重衰减0.0、梯度中心化使用默认值False。
|
||||
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
|
||||
>>>
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=optim)
|
||||
|
||||
.. include:: mindspore.nn.optim_target_unique_for_sparse.rst
|
||||
|
||||
|
|
@ -1,59 +1,59 @@
|
|||
mindspore.nn.NaturalExpDecayLR
|
||||
===============================
|
||||
|
||||
.. py:class:: mindspore.nn.NaturalExpDecayLR(learning_rate, decay_rate, decay_steps, is_stair=False)
|
||||
|
||||
基于自然指数衰减函数计算学习率。
|
||||
|
||||
对于当前step，计算decayed_learning_rate[current_step]的公式为：
|
||||
|
||||
.. math::
|
||||
decayed\_learning\_rate[current\_step] = learning\_rate * e^{-decay\_rate * p}
|
||||
|
||||
其中，
|
||||
|
||||
.. math::
|
||||
p = \frac{current\_step}{decay\_steps}
|
||||
|
||||
如果 `is_stair` 为True，则公式为：
|
||||
|
||||
.. math::
|
||||
p = floor(\frac{current\_step}{decay\_steps})
|
||||
|
||||
**参数：**
|
||||
|
||||
- **learning_rate** (float)：学习率的初始值。
|
||||
- **decay_rate** (float)：衰减率。
|
||||
- **decay_steps** (int)：用于计算衰减学习率的值。
|
||||
- **is_stair** (bool)：如果为True，则学习率每 `decay_steps` 次衰减一次。默认值：False。
|
||||
|
||||
**输入：**
|
||||
|
||||
**global_step** （Tensor）：当前step数。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor。当前step的学习率值，shape为 :math:`()`。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate` 或 `decay_rate` 不是float。
|
||||
- **TypeError**：`decay_steps` 不是int或 `is_stair` 不是bool。
|
||||
- **ValueError**：`decay_steps` 小于1。
|
||||
- **ValueError**：`learning_rate` 或 `decay_rate` 小于或等于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> learning_rate = 0.1
|
||||
>>> decay_rate = 0.9
|
||||
>>> decay_steps = 4
|
||||
>>> global_step = Tensor(2, mstype.int32)
|
||||
>>> natural_exp_decay_lr = nn.NaturalExpDecayLR(learning_rate, decay_rate, decay_steps, True)
|
||||
>>> result = natural_exp_decay_lr(global_step)
|
||||
>>> print(result)
|
||||
0.1
|
||||
mindspore.nn.NaturalExpDecayLR
|
||||
===============================
|
||||
|
||||
.. py:class:: mindspore.nn.NaturalExpDecayLR(learning_rate, decay_rate, decay_steps, is_stair=False)
|
||||
|
||||
基于自然指数衰减函数计算学习率。
|
||||
|
||||
对于当前step，计算decayed_learning_rate[current_step]的公式为：
|
||||
|
||||
.. math::
|
||||
decayed\_learning\_rate[current\_step] = learning\_rate * e^{-decay\_rate * p}
|
||||
|
||||
其中，
|
||||
|
||||
.. math::
|
||||
p = \frac{current\_step}{decay\_steps}
|
||||
|
||||
如果 `is_stair` 为True，则公式为：
|
||||
|
||||
.. math::
|
||||
p = floor(\frac{current\_step}{decay\_steps})
|
||||
|
||||
**参数：**
|
||||
|
||||
- **learning_rate** (float)：学习率的初始值。
|
||||
- **decay_rate** (float)：衰减率。
|
||||
- **decay_steps** (int)：用于计算衰减学习率的值。
|
||||
- **is_stair** (bool)：如果为True，则学习率每 `decay_steps` 次衰减一次。默认值：False。
|
||||
|
||||
**输入：**
|
||||
|
||||
**global_step** （Tensor）：当前step数。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor。当前step的学习率值，shape为 :math:`()`。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate` 或 `decay_rate` 不是float。
|
||||
- **TypeError**：`decay_steps` 不是int或 `is_stair` 不是bool。
|
||||
- **ValueError**：`decay_steps` 小于1。
|
||||
- **ValueError**：`learning_rate` 或 `decay_rate` 小于或等于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> learning_rate = 0.1
|
||||
>>> decay_rate = 0.9
|
||||
>>> decay_steps = 4
|
||||
>>> global_step = Tensor(2, mstype.int32)
|
||||
>>> natural_exp_decay_lr = nn.NaturalExpDecayLR(learning_rate, decay_rate, decay_steps, True)
|
||||
>>> result = natural_exp_decay_lr(global_step)
|
||||
>>> print(result)
|
||||
0.1
|
||||
|
||||
|
|
@ -1,62 +1,62 @@
|
|||
mindspore.nn.polynomial_decay_lr
|
||||
====================================
|
||||
|
||||
.. py:class:: mindspore.nn.PolynomialDecayLR(learning_rate, end_learning_rate, decay_steps, power, update_decay_steps=False)
|
||||
|
||||
基于多项式衰减函数计算学习率。
|
||||
|
||||
对于当前step，计算decayed_learning_rate[current_step]的公式为：
|
||||
|
||||
.. math::
|
||||
decayed\_learning\_rate[current\_step] = (learning\_rate - end\_learning\_rate) *
|
||||
(1 - tmp\_step / tmp\_decay\_steps)^{power} + end\_learning\_rate
|
||||
|
||||
其中，
|
||||
|
||||
.. math::
|
||||
tmp\_step=min(current\_step, decay\_steps)
|
||||
|
||||
如果 `update_decay_steps` 为true，则每 `decay_steps` 更新 `tmp_decay_step` 的值。公式为：
|
||||
|
||||
.. math::
|
||||
tmp\_decay\_steps = decay\_steps * ceil(current\_step / decay\_steps)
|
||||
|
||||
**参数：**
|
||||
|
||||
- **learning_rate** (float)：学习率的初始值。
|
||||
- **end_learning_rate** (float)：学习率的最终值。
|
||||
- **decay_steps** (int)：用于计算衰减学习率的值。
|
||||
- **power** (float)：用于计算衰减学习率的值。该参数必须大于0。
|
||||
- **update_decay_steps** (bool)：如果为True，则学习率每 `decay_steps` 次衰减一次。默认值：False。
|
||||
|
||||
**输入：**
|
||||
|
||||
**global_step** （Tensor）：当前step数。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor。当前step的学习率值, shape为 :math:`()`。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate`,`end_learning_rate` 或 `power` 不是float。
|
||||
- **TypeError**：`decay_steps` 不是int或 `update_decay_steps` 不是bool。
|
||||
- **ValueError**：`end_learning_rate` 小于0或 `decay_steps` 小于1。
|
||||
- **ValueError**：`learning_rate` 或 `power` 小于或等于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> learning_rate = 0.1
|
||||
>>> end_learning_rate = 0.01
|
||||
>>> decay_steps = 4
|
||||
>>> power = 0.5
|
||||
>>> global_step = Tensor(2, mstype.int32)
|
||||
>>> polynomial_decay_lr = nn.PolynomialDecayLR(learning_rate, end_learning_rate, decay_steps, power)
|
||||
>>> result = polynomial_decay_lr(global_step)
|
||||
>>> print(result)
|
||||
0.07363961
|
||||
mindspore.nn.polynomial_decay_lr
|
||||
====================================
|
||||
|
||||
.. py:class:: mindspore.nn.PolynomialDecayLR(learning_rate, end_learning_rate, decay_steps, power, update_decay_steps=False)
|
||||
|
||||
基于多项式衰减函数计算学习率。
|
||||
|
||||
对于当前step，计算decayed_learning_rate[current_step]的公式为：
|
||||
|
||||
.. math::
|
||||
decayed\_learning\_rate[current\_step] = (learning\_rate - end\_learning\_rate) *
|
||||
(1 - tmp\_step / tmp\_decay\_steps)^{power} + end\_learning\_rate
|
||||
|
||||
其中，
|
||||
|
||||
.. math::
|
||||
tmp\_step=min(current\_step, decay\_steps)
|
||||
|
||||
如果 `update_decay_steps` 为true，则每 `decay_steps` 更新 `tmp_decay_step` 的值。公式为：
|
||||
|
||||
.. math::
|
||||
tmp\_decay\_steps = decay\_steps * ceil(current\_step / decay\_steps)
|
||||
|
||||
**参数：**
|
||||
|
||||
- **learning_rate** (float)：学习率的初始值。
|
||||
- **end_learning_rate** (float)：学习率的最终值。
|
||||
- **decay_steps** (int)：用于计算衰减学习率的值。
|
||||
- **power** (float)：用于计算衰减学习率的值。该参数必须大于0。
|
||||
- **update_decay_steps** (bool)：如果为True，则学习率每 `decay_steps` 次衰减一次。默认值：False。
|
||||
|
||||
**输入：**
|
||||
|
||||
**global_step** （Tensor）：当前step数。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor。当前step的学习率值, shape为 :math:`()`。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate`,`end_learning_rate` 或 `power` 不是float。
|
||||
- **TypeError**：`decay_steps` 不是int或 `update_decay_steps` 不是bool。
|
||||
- **ValueError**：`end_learning_rate` 小于0或 `decay_steps` 小于1。
|
||||
- **ValueError**：`learning_rate` 或 `power` 小于或等于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> learning_rate = 0.1
|
||||
>>> end_learning_rate = 0.01
|
||||
>>> decay_steps = 4
|
||||
>>> power = 0.5
|
||||
>>> global_step = Tensor(2, mstype.int32)
|
||||
>>> polynomial_decay_lr = nn.PolynomialDecayLR(learning_rate, end_learning_rate, decay_steps, power)
|
||||
>>> result = polynomial_decay_lr(global_step)
|
||||
>>> print(result)
|
||||
0.07363961
|
||||
|
||||
|
|
@ -1,94 +1,94 @@
|
|||
mindspore.nn.ProximalAdagrad
|
||||
==============================
|
||||
|
||||
.. py:class:: mindspore.nn.ProximalAdagrad(*args, **kwargs)
|
||||
|
||||
使用ApplyProximalAdagrad算子实现ProximalAdagrad算法。
|
||||
|
||||
ProximalAdagrad用于在线学习和随机优化。
|
||||
请参阅论文 `Efficient Learning using Forward-Backward Splitting <http://papers.nips.cc//paper/3793-efficient-learning-using-forward-backward-splitting.pdf>`_。
|
||||
|
||||
.. math::
|
||||
accum_{t+1} = accum_{t} + grad * grad
|
||||
|
||||
.. math::
|
||||
\text{prox_v} = var_{t} - lr * grad * \frac{1}{\sqrt{accum_{t+1}}}
|
||||
|
||||
.. math::
|
||||
var_{t+1} = \frac{sign(\text{prox_v})}{1 + lr * l2} * \max(\left| \text{prox_v} \right| - lr * l1, 0)
|
||||
|
||||
其中，grad、lr、var、accum和t分别表示 `grads`, `learning_rate`, `params` 、累加器和当前step。
|
||||
|
||||
.. note::
|
||||
.. include:: mindspore.nn.optim_note_sparse.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_note_weight_decay.rst
|
||||
|
||||
**参数：**
|
||||
|
||||
- **param** (Union[list[Parameter], list[dict]]) - 必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、"grad_centralization"和"order_params"：
|
||||
|
||||
.. include:: mindspore.nn.optim_group_param.rst
|
||||
.. include:: mindspore.nn.optim_group_lr.rst
|
||||
.. include:: mindspore.nn.optim_group_weight_decay.rst
|
||||
.. include:: mindspore.nn.optim_group_gc.rst
|
||||
.. include:: mindspore.nn.optim_group_order.rst
|
||||
|
||||
- **accum** (float)：累加器`accum`的初始值，起始值必须为零或正值。默认值：0.1。
|
||||
|
||||
- **learning_rate** (Union[float, Tensor, Iterable, LearningRateSchedule]): 默认值：1e-3。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_dynamic_lr.rst
|
||||
|
||||
- **l1** (float):l1正则化强度，必须大于或等于零。默认值：0.0。
|
||||
- **l2** (float):l2正则化强度，必须大于或等于零。默认值：0.0。
|
||||
- **use_locking** (bool)：如果为True，则更新操作使用锁保护。默认值：False。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_loss_scale.rst
|
||||
|
||||
- **weight_decay** (Union[float, int])：要乘以权重的权重衰减值，必须为零或正值。默认值：0.0。
|
||||
|
||||
**输入：**
|
||||
|
||||
**grads** (tuple[Tensor]) - 优化器中 `params` 的梯度，shape与优化器中的 `params` 相同。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor[bool]，值为True。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
|
||||
- **TypeError**：`parameters` 的元素不是Parameter或字典。
|
||||
- **TypeError**：`accum`、`l1`、`l2` 或 `loss_scale`不是float。
|
||||
- **TypeError**：`weight_decay` 不是float或int。
|
||||
- **ValueError**：`loss_scale` 小于或等于0。
|
||||
- **ValueError**：`accum`、`l1`、`l2` 或 `weight_decay` 小于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> #1) 所有参数使用相同的学习率和权重衰减
|
||||
>>> optim = nn.ProximalAdagrad(params=net.trainable_params())
|
||||
>>>
|
||||
>>> #2) 使用参数组并设置不同的值
|
||||
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
|
||||
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
|
||||
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01, 'grad_centralization':True},
|
||||
... {'params': no_conv_params, 'lr': 0.01},
|
||||
... {'order_params': net.trainable_params()}]
|
||||
>>> optim = nn.ProximalAdagrad(group_params, learning_rate=0.1, weight_decay=0.0)
|
||||
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01、该组的梯度中心化配置True。
|
||||
>>> # no_conv_params参数组将使用该组的学习率0.01、优化器中的权重衰减0.0、梯度中心化使用默认值False。
|
||||
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
|
||||
>>>
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=optim)
|
||||
|
||||
|
||||
.. include:: mindspore.nn.optim_target_unique_for_sparse.rst
|
||||
mindspore.nn.ProximalAdagrad
|
||||
==============================
|
||||
|
||||
.. py:class:: mindspore.nn.ProximalAdagrad(*args, **kwargs)
|
||||
|
||||
使用ApplyProximalAdagrad算子实现ProximalAdagrad算法。
|
||||
|
||||
ProximalAdagrad用于在线学习和随机优化。
|
||||
请参阅论文 `Efficient Learning using Forward-Backward Splitting <http://papers.nips.cc//paper/3793-efficient-learning-using-forward-backward-splitting.pdf>`_。
|
||||
|
||||
.. math::
|
||||
accum_{t+1} = accum_{t} + grad * grad
|
||||
|
||||
.. math::
|
||||
\text{prox_v} = var_{t} - lr * grad * \frac{1}{\sqrt{accum_{t+1}}}
|
||||
|
||||
.. math::
|
||||
var_{t+1} = \frac{sign(\text{prox_v})}{1 + lr * l2} * \max(\left| \text{prox_v} \right| - lr * l1, 0)
|
||||
|
||||
其中，grad、lr、var、accum和t分别表示 `grads`, `learning_rate`, `params` 、累加器和当前step。
|
||||
|
||||
.. note::
|
||||
.. include:: mindspore.nn.optim_note_sparse.rst
|
||||
|
||||
.. include:: mindspore.nn.optim_note_weight_decay.rst
|
||||
|
||||
**参数：**
|
||||
|
||||
- **param** (Union[list[Parameter], list[dict]]) - 必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、"grad_centralization"和"order_params"：
|
||||
|
||||
.. include:: mindspore.nn.optim_group_param.rst
|
||||
.. include:: mindspore.nn.optim_group_lr.rst
|
||||
.. include:: mindspore.nn.optim_group_weight_decay.rst
|
||||
.. include:: mindspore.nn.optim_group_gc.rst
|
||||
.. include:: mindspore.nn.optim_group_order.rst
|
||||
|
||||
- **accum** (float)：累加器`accum`的初始值，起始值必须为零或正值。默认值：0.1。
|
||||
|
||||
- **learning_rate** (Union[float, Tensor, Iterable, LearningRateSchedule]): 默认值：1e-3。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_dynamic_lr.rst
|
||||
|
||||
- **l1** (float):l1正则化强度，必须大于或等于零。默认值：0.0。
|
||||
- **l2** (float):l2正则化强度，必须大于或等于零。默认值：0.0。
|
||||
- **use_locking** (bool)：如果为True，则更新操作使用锁保护。默认值：False。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_loss_scale.rst
|
||||
|
||||
- **weight_decay** (Union[float, int])：要乘以权重的权重衰减值，必须为零或正值。默认值：0.0。
|
||||
|
||||
**输入：**
|
||||
|
||||
**grads** (tuple[Tensor]) - 优化器中 `params` 的梯度，shape与优化器中的 `params` 相同。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor[bool]，值为True。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
|
||||
- **TypeError**：`parameters` 的元素不是Parameter或字典。
|
||||
- **TypeError**：`accum`、`l1`、`l2` 或 `loss_scale` 不是float。
|
||||
- **TypeError**：`weight_decay` 不是float或int。
|
||||
- **ValueError**：`loss_scale` 小于或等于0。
|
||||
- **ValueError**：`accum`、`l1`、`l2` 或 `weight_decay` 小于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> #1) 所有参数使用相同的学习率和权重衰减
|
||||
>>> optim = nn.ProximalAdagrad(params=net.trainable_params())
|
||||
>>>
|
||||
>>> #2) 使用参数组并设置不同的值
|
||||
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
|
||||
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
|
||||
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01, 'grad_centralization':True},
|
||||
... {'params': no_conv_params, 'lr': 0.01},
|
||||
... {'order_params': net.trainable_params()}]
|
||||
>>> optim = nn.ProximalAdagrad(group_params, learning_rate=0.1, weight_decay=0.0)
|
||||
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01、该组的梯度中心化配置True。
|
||||
>>> # no_conv_params参数组将使用该组的学习率0.01、优化器中的权重衰减0.0、梯度中心化使用默认值False。
|
||||
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
|
||||
>>>
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=optim)
|
||||
|
||||
|
||||
.. include:: mindspore.nn.optim_target_unique_for_sparse.rst
|
||||
|
||||
|
|
@ -1,114 +1,114 @@
|
|||
mindspore.nn.RMSProp
|
||||
======================
|
||||
|
||||
.. py:class:: mindspore.nn.RMSProp(*args, **kwargs)
|
||||
|
||||
实现均方根传播（RMSProp）算法。
|
||||
|
||||
根据RMSProp算法更新 `params`，算法详见 [http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf] 第29页。
|
||||
|
||||
公式如下：
|
||||
|
||||
.. math::
|
||||
s_{t+1} = \rho s_{t} + (1 - \rho)(\nabla Q_{i}(w))^2
|
||||
|
||||
.. math::
|
||||
m_{t+1} = \beta m_{t} + \frac{\eta} {\sqrt{s_{t+1} + \epsilon}} \nabla Q_{i}(w)
|
||||
|
||||
.. math::
|
||||
w = w - m_{t+1}
|
||||
|
||||
第一个方程计算每个权重的平方梯度的移动平均。然后将梯度除以 :math:`\sqrt{ms_{t+1} + \epsilon}`。
|
||||
|
||||
如果centered为True：
|
||||
|
||||
.. math::
|
||||
g_{t+1} = \rho g_{t} + (1 - \rho)\nabla Q_{i}(w)
|
||||
|
||||
.. math::
|
||||
s_{t+1} = \rho s_{t} + (1 - \rho)(\nabla Q_{i}(w))^2
|
||||
|
||||
.. math::
|
||||
m_{t+1} = \beta m_{t} + \frac{\eta} {\sqrt{s_{t+1} - g_{t+1}^2 + \epsilon}} \nabla Q_{i}(w)
|
||||
|
||||
.. math::
|
||||
w = w - m_{t+1}
|
||||
|
||||
其中 :math:`w` 代表待更新的网络参数 `params`。
|
||||
:math:`g_{t+1}` 是平均梯度。
|
||||
:math:`s_{t+1}` 是均方梯度。
|
||||
:math:`m_{t+1}` 是moment，`w` 的delta。
|
||||
:math:`\rho` 代表 `decay`。:math:`\beta` 是动量项，表示 `momentum`。
|
||||
:math:`\epsilon` 是平滑项，可以避免除以零，表示 `epsilon`。
|
||||
:math:`\eta` 是学习率，表示 `learning_rate`。 :math:`\nabla Q_{i}(w)` 是梯度，表示 `gradients`。
|
||||
:math:`t` 表示当前step。
|
||||
|
||||
.. note::
|
||||
.. include:: mindspore.nn.optim_note_weight_decay.rst
|
||||
|
||||
**参数：**
|
||||
|
||||
- **params** (Union[list[Parameter], list[dict]])：必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、"grad_centralization"和"order_params"：
|
||||
|
||||
.. include:: mindspore.nn.optim_group_param.rst
|
||||
.. include:: mindspore.nn.optim_group_lr.rst
|
||||
.. include:: mindspore.nn.optim_group_weight_decay.rst
|
||||
.. include:: mindspore.nn.optim_group_gc.rst
|
||||
.. include:: mindspore.nn.optim_group_order.rst
|
||||
|
||||
- **learning_rate (Union[float, Tensor, Iterable, LearningRateSchedule])：默认值：0.1。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_dynamic_lr.rst
|
||||
|
||||
- **decay** (float)：衰减率。必须大于等于0。默认值：0.9。
|
||||
- **momentum** (float)：Float类型的超参数，表示移动平均的动量（momentum）。必须大于等于0。默认值：0.0。
|
||||
- **epsilon** (float)：将添加到分母中，以提高数值稳定性。取值大于0。默认值：1e-10。
|
||||
- **use_locking** (bool)：是否对参数更新加锁保护。默认值：False。
|
||||
- **centered** (bool)：如果为True，则梯度将通过梯度的估计方差进行归一。默认值：False。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_loss_scale.rst
|
||||
|
||||
- **weight_decay** (Union[float, int])：权重衰减（L2 penalty）。必须大于等于0。默认值：0.0。
|
||||
|
||||
**输入：**
|
||||
|
||||
**gradients** （tuple[Tensor]） - `params` 的梯度，shape与 `params` 相同。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor[bool]，值为True。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
|
||||
- **TypeError**：`decay` 、 `momentum` 、 `epsilon` 或 `loss_scale` 不是float。
|
||||
- **TypeError**：`parameters` 的元素不是Parameter或字典。
|
||||
- **TypeError**：`weight_decay` 不是float或int。
|
||||
- **TypeError**：`use_locking` 或 `centered` 不是bool。
|
||||
- **ValueError**：`epsilon` 小于或等于0。
|
||||
- **ValueError**：`decay` 或 `momentum` 小于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> #1) 所有参数使用相同的学习率和权重衰减
|
||||
>>> optim = nn.RMSProp(params=net.trainable_params(), learning_rate=0.1)
|
||||
>>>
|
||||
>>> #2) 使用参数分组并设置不同的值
|
||||
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
|
||||
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
|
||||
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01, 'grad_centralization':True},
|
||||
... {'params': no_conv_params, 'lr': 0.01},
|
||||
... {'order_params': net.trainable_params()}]
|
||||
>>> optim = nn.RMSProp(group_params, learning_rate=0.1, weight_decay=0.0)
|
||||
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01、该组的梯度中心化配置True。
|
||||
>>> # no_conv_params参数组将使用该组的学习率0.01、优化器中的权重衰减0.0、梯度中心化使用默认值False。
|
||||
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
|
||||
>>>
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=optim)
|
||||
mindspore.nn.RMSProp
|
||||
======================
|
||||
|
||||
.. py:class:: mindspore.nn.RMSProp(*args, **kwargs)
|
||||
|
||||
实现均方根传播（RMSProp）算法。
|
||||
|
||||
根据RMSProp算法更新 `params`，算法详见 [http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf] 第29页。
|
||||
|
||||
公式如下：
|
||||
|
||||
.. math::
|
||||
s_{t+1} = \rho s_{t} + (1 - \rho)(\nabla Q_{i}(w))^2
|
||||
|
||||
.. math::
|
||||
m_{t+1} = \beta m_{t} + \frac{\eta} {\sqrt{s_{t+1} + \epsilon}} \nabla Q_{i}(w)
|
||||
|
||||
.. math::
|
||||
w = w - m_{t+1}
|
||||
|
||||
第一个方程计算每个权重的平方梯度的移动平均。然后将梯度除以 :math:`\sqrt{ms_{t+1} + \epsilon}`。
|
||||
|
||||
如果centered为True：
|
||||
|
||||
.. math::
|
||||
g_{t+1} = \rho g_{t} + (1 - \rho)\nabla Q_{i}(w)
|
||||
|
||||
.. math::
|
||||
s_{t+1} = \rho s_{t} + (1 - \rho)(\nabla Q_{i}(w))^2
|
||||
|
||||
.. math::
|
||||
m_{t+1} = \beta m_{t} + \frac{\eta} {\sqrt{s_{t+1} - g_{t+1}^2 + \epsilon}} \nabla Q_{i}(w)
|
||||
|
||||
.. math::
|
||||
w = w - m_{t+1}
|
||||
|
||||
其中 :math:`w` 代表待更新的网络参数 `params`。
|
||||
:math:`g_{t+1}` 是平均梯度。
|
||||
:math:`s_{t+1}` 是均方梯度。
|
||||
:math:`m_{t+1}` 是moment，`w` 的delta。
|
||||
:math:`\rho` 代表 `decay`。:math:`\beta` 是动量项，表示 `momentum`。
|
||||
:math:`\epsilon` 是平滑项，可以避免除以零，表示 `epsilon`。
|
||||
:math:`\eta` 是学习率，表示 `learning_rate`。 :math:`\nabla Q_{i}(w)` 是梯度，表示 `gradients`。
|
||||
:math:`t` 表示当前step。
|
||||
|
||||
.. note::
|
||||
.. include:: mindspore.nn.optim_note_weight_decay.rst
|
||||
|
||||
**参数：**
|
||||
|
||||
- **params** (Union[list[Parameter], list[dict]])：必须是 `Parameter` 组成的列表或字典组成的列表。当列表元素是字典时，字典的键可以是"params"、"lr"、"weight_decay"、"grad_centralization"和"order_params"：
|
||||
|
||||
.. include:: mindspore.nn.optim_group_param.rst
|
||||
.. include:: mindspore.nn.optim_group_lr.rst
|
||||
.. include:: mindspore.nn.optim_group_weight_decay.rst
|
||||
.. include:: mindspore.nn.optim_group_gc.rst
|
||||
.. include:: mindspore.nn.optim_group_order.rst
|
||||
|
||||
- **learning_rate** (Union[float, Tensor, Iterable, LearningRateSchedule])：默认值：0.1。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_dynamic_lr.rst
|
||||
|
||||
- **decay** (float)：衰减率。必须大于等于0。默认值：0.9。
|
||||
- **momentum** (float)：Float类型的超参数，表示移动平均的动量（momentum）。必须大于等于0。默认值：0.0。
|
||||
- **epsilon** (float)：将添加到分母中，以提高数值稳定性。取值大于0。默认值：1e-10。
|
||||
- **use_locking** (bool)：是否对参数更新加锁保护。默认值：False。
|
||||
- **centered** (bool)：如果为True，则梯度将通过梯度的估计方差进行归一。默认值：False。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_loss_scale.rst
|
||||
|
||||
- **weight_decay** (Union[float, int])：权重衰减（L2 penalty）。必须大于等于0。默认值：0.0。
|
||||
|
||||
**输入：**
|
||||
|
||||
**gradients** （tuple[Tensor]） - `params` 的梯度，shape与 `params` 相同。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor[bool]，值为True。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`learning_rate` 不是int、float、Tensor、Iterable或LearningRateSchedule。
|
||||
- **TypeError**：`decay` 、 `momentum` 、 `epsilon` 或 `loss_scale` 不是float。
|
||||
- **TypeError**：`parameters` 的元素不是Parameter或字典。
|
||||
- **TypeError**：`weight_decay` 不是float或int。
|
||||
- **TypeError**：`use_locking` 或 `centered` 不是bool。
|
||||
- **ValueError**：`epsilon` 小于或等于0。
|
||||
- **ValueError**：`decay` 或 `momentum` 小于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> #1) 所有参数使用相同的学习率和权重衰减
|
||||
>>> optim = nn.RMSProp(params=net.trainable_params(), learning_rate=0.1)
|
||||
>>>
|
||||
>>> #2) 使用参数分组并设置不同的值
|
||||
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
|
||||
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
|
||||
>>> group_params = [{'params': conv_params, 'weight_decay': 0.01, 'grad_centralization':True},
|
||||
... {'params': no_conv_params, 'lr': 0.01},
|
||||
... {'order_params': net.trainable_params()}]
|
||||
>>> optim = nn.RMSProp(group_params, learning_rate=0.1, weight_decay=0.0)
|
||||
>>> # conv_params参数组将使用优化器中的学习率0.1、该组的权重衰减0.01、该组的梯度中心化配置True。
|
||||
>>> # no_conv_params参数组将使用该组的学习率0.01、优化器中的权重衰减0.0、梯度中心化使用默认值False。
|
||||
>>> # 优化器按照"order_params"配置的参数顺序更新参数。
|
||||
>>>
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=optim)
|
||||
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
mindspore.nn.SGD
|
||||
================
|
||||
|
||||
.. py:class:: mindspore.nn.SGD(*args, **kwargs)
|
||||
|
||||
实现随机梯度下降。动量可选。
|
||||
|
||||
SGD相关介绍参见 `SGD <https://en.wikipedia.org/wiki/Stochastic_gradient_dencent>`_ 。
|
||||
|
||||
Nesterov动量公式参见论文 `On the importance of initialization and momentum in deep learning <http://proceedings.mlr.press/v28/sutskever13.html>`_ 。
|
||||
|
||||
.. math::
|
||||
v_{t+1} = u \ast v_{t} + gradient \ast (1-dampening)
|
||||
|
||||
如果nesterov为True：
|
||||
|
||||
.. math::
|
||||
p_{t+1} = p_{t} - lr \ast (gradient + u \ast v_{t+1})
|
||||
|
||||
如果nesterov为False：
|
||||
|
||||
.. math::
|
||||
p_{t+1} = p_{t} - lr \ast v_{t+1}
|
||||
|
||||
需要注意的是，对于训练的第一步 :math:`v_{t+1} = gradient`。其中，p、v和u分别表示 `parameters`、`accum` 和 `momentum`。
|
||||
|
||||
.. note::
|
||||
|
||||
.. include:: mindspore.nn.optim_note_weight_decay.rst
|
||||
|
||||
**参数：**
|
||||
|
||||
- **params** (Union[list[Parameter], list[dict]]): 当 `params` 为会更新的 `Parameter` 列表时，`params` 中的元素必须为类 `Parameter`。当 `params` 为 `dict` 列表时，"params"、"lr"、"weight_decay"、"grad_centralization"和"order_params"为可以解析的键。
|
||||
.. include:: mindspore.nn.optim_group_param.rst
|
||||
.. include:: mindspore.nn.optim_group_lr.rst
|
||||
.. include:: mindspore.nn.optim_group_weight_decay.rst
|
||||
.. include:: mindspore.nn.optim_group_gc.rst
|
||||
.. include:: mindspore.nn.optim_group_order.rst
|
||||
|
||||
- **learning_rate** (Union[float, Tensor, Iterable, LearningRateSchedule]): 默认值：0.1。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_dynamic_lr.rst
|
||||
|
||||
- **momentum** (float): 浮点动量，必须大于等于0.0。默认值：0.0。
|
||||
- **dampening** (float): 浮点动量阻尼值，必须大于等于0.0。默认值：0.0。
|
||||
- **weight_decay** (float): 权重衰减（L2 penalty），必须大于等于0。默认值：0.0。
|
||||
- **nesterov** (bool): 启用Nesterov动量。如果使用Nesterov，动量必须为正，阻尼必须等于0.0。默认值：False。
|
||||
|
||||
.. include:: mindspore.nn.optim_arg_loss_scale.rst
|
||||
|
||||
**输入：**
|
||||
|
||||
**gradients** (tuple[Tensor])：`params` 的梯度，shape与 `params` 相同。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor[bool]，值为True。
|
||||
|
||||
**异常：**
|
||||
|
||||
**ValueError：** 动量、阻尼或重量衰减值小于0.0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> # 1) 所有参数使用相同的学习率和权重衰减
|
||||
>>> optim = nn.SGD(params=net.trainable_params())
|
||||
>>>
|
||||
>>> # 2) 使用参数组并设置不同的值
|
||||
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
|
||||
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
|
||||
>>> group_params = [{'params': conv_params,'grad_centralization':True},
|
||||
... {'params': no_conv_params, 'lr': 0.01},
|
||||
... {'order_params': net.trainable_params()}]
|
||||
>>> optim = nn.SGD(group_params, learning_rate=0.1, weight_decay=0.0)
|
||||
>>> # con_params的参数将使用默认学习率0.1、默认权重衰减0.0、梯度集中度为True。
|
||||
>>> #
|
||||
>>> # no_con_params的参数将使用学习率0.01、默认权重衰减0.0、梯度集中度为False。
|
||||
>>> #
|
||||
>>> # 优化器的最终参数顺序采用'order_params'的值。
|
||||
>>>
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=optim)
|
||||
|
||||
|
|
@ -1,88 +0,0 @@
|
|||
mindspore.nn.SGD
|
||||
================
|
||||
|
||||
.. py:class:: mindspore.nn.SGD(*args, **kwargs)
|
||||
|
||||
实现随机梯度下降。动量可选。
|
||||
|
||||
SGD相关介绍参见 `SGD <https://en.wikipedia.org/wiki/Stochastic_gradient_dencent>`_ 。
|
||||
|
||||
Nesterov动量公式参见论文 `On the importance of initialization and momentum in deep learning <http://proceedings.mlr.press/v28/sutskever13.html>`_ 。
|
||||
|
||||
.. math::
|
||||
v_{t+1} = u \ast v_{t} + gradient \ast (1-dampening)
|
||||
|
||||
如果nesterov为True：
|
||||
|
||||
.. math::
|
||||
p_{t+1} = p_{t} - lr \ast (gradient + u \ast v_{t+1})
|
||||
|
||||
如果nesterov为False：
|
||||
|
||||
.. math::
|
||||
p_{t+1} = p_{t} - lr \ast v_{t+1}
|
||||
|
||||
需要注意的是，对于训练的第一步 :math:`v_{t+1} = gradient`。其中，p、v和u分别表示 `parameters`、`accum` 和 `momentum`。
|
||||
|
||||
.. note::
|
||||
|
||||
.. include:: mindspore.nn.optim_note_weight_decay.rst
|
||||
|
||||
**参数：**
|
||||
|
||||
- **params** (Union[list[Parameter], list[dict]]): 当 `params` 为会更新的 `Parameter` 列表时，`params` 中的元素必须为类 `Parameter`。当 `params` 为 `dict` 列表时，"params"、"lr"、"weight_decay"、"grad_centralization"和"order_params"为可以解析的键。
|
||||
.. include:: mindspore.nn.optim_group_param.rst
|
||||
.. include:: mindspore.nn.optim_group_lr.rst
|
||||
.. include:: mindspore.nn.optim_group_weight_decay.rst
|
||||
.. include:: mindspore.nn.optim_group_gc.rst
|
||||
.. include:: mindspore.nn.optim_group_order.rst
|
||||
|
||||
- **learning_rate** (Union[float, Tensor, Iterable, LearningRateSchedule]): 默认值：0.1。
|
||||
.. include:: mindspore.nn.optim_arg_dynamic_lr.rst
|
||||
|
||||
- **momentum** (float): 浮点动量，必须大于等于0.0。默认值：0.0。
|
||||
- **dampening** (float): 浮点动量阻尼值，必须大于等于0.0。默认值：0.0。
|
||||
- **weight_decay** (float): 权重衰减（L2 penalty），必须大于等于0。默认值：0.0。
|
||||
- **nesterov** (bool): 启用Nesterov动量。如果使用Nesterov，动量必须为正，阻尼必须等于0.0。默认值：False。
|
||||
.. include:: mindspore.nn.optim_arg_loss_scale.rst
|
||||
|
||||
**输入：**
|
||||
|
||||
**gradients** (tuple[Tensor])：`params` 的梯度，shape与 `params` 相同。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor[bool]，值为True。
|
||||
|
||||
**异常：**
|
||||
|
||||
**ValueError：** 动量、阻尼或重量衰减值小于0.0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
.. code-block::
|
||||
|
||||
>>> net = Net()
|
||||
>>> # 1) 所有参数使用相同的学习率和权重衰减
|
||||
>>> optim = nn.SGD(params=net.trainable_params())
|
||||
>>>
|
||||
>>> # 2) 使用参数组并设置不同的值
|
||||
>>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
|
||||
>>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
|
||||
>>> group_params = [{'params': conv_params,'grad_centralization':True},
|
||||
... {'params': no_conv_params, 'lr': 0.01},
|
||||
... {'order_params': net.trainable_params()}]
|
||||
>>> optim = nn.SGD(group_params, learning_rate=0.1, weight_decay=0.0)
|
||||
>>> # con_params的参数将使用默认学习率0.1、默认权重衰减0.0、梯度集中度为True。
|
||||
>>> #
|
||||
>>> # no_con_params的参数将使用学习率0.01、默认权重衰减0.0、梯度集中度为False。
|
||||
>>> #
|
||||
>>> # 优化器的最终参数顺序采用'order_params'的值。
|
||||
>>>
|
||||
>>> loss = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> model = Model(net, loss_fn=loss, optimizer=optim)
|
||||
|
||||
|
|
@ -1,59 +1,59 @@
|
|||
mindspore.nn.TrainOneStepCell
|
||||
=============================
|
||||
|
||||
.. py:class:: mindspore.nn.TrainOneStepCell(network, optimizer, sens=1.0)
|
||||
|
||||
训练网络封装类。
|
||||
|
||||
封装 `network` 和 `optimizer` ，构建一个输入'\*inputs'的用于训练的Cell。
|
||||
执行函数 `construct` 中会构建反向图以更新网络参数。支持不同的并行训练模式。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **network** (Cell)：训练网络。只支持单输出网络。
|
||||
- **optimizer** (Union[Cell])：用于更新网络参数的优化器。
|
||||
- **sens** (numbers.Number)：反向传播的输入，缩放系数。默认值为1.0。
|
||||
|
||||
**输入：**
|
||||
|
||||
**(\*inputs)** (Tuple(Tensor)) - shape为 :math:`(N, \ldots)` 的Tensor组成的元组。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor，损失函数值，其shape通常为 :math:`()` 。
|
||||
|
||||
**异常：**
|
||||
|
||||
**TypeError**：`sens` 不是numbers.Number。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> loss_fn = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> optim = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
|
||||
>>> # 1）使用MindSpore提供的WithLossCell
|
||||
>>> loss_net = nn.WithLossCell(net, loss_fn)
|
||||
>>> train_net = nn.TrainOneStepCell(loss_net, optim)
|
||||
>>>
|
||||
>>> # 2）用户自定义的WithLossCell
|
||||
>>> class MyWithLossCell(Cell):
|
||||
... def __init__(self, backbone, loss_fn):
|
||||
... super(MyWithLossCell, self).__init__(auto_prefix=False)
|
||||
... self._backbone = backbone
|
||||
... self._loss_fn = loss_fn
|
||||
...
|
||||
... def construct(self, x, y, label):
|
||||
... out = self._backbone(x, y)
|
||||
... return self._loss_fn(out, label)
|
||||
...
|
||||
... @property
|
||||
... def backbone_network(self):
|
||||
... return self._backbone
|
||||
...
|
||||
>>> loss_net = MyWithLossCell(net, loss_fn)
|
||||
>>> train_net = nn.TrainOneStepCell(loss_net, optim)
|
||||
mindspore.nn.TrainOneStepCell
|
||||
=============================
|
||||
|
||||
.. py:class:: mindspore.nn.TrainOneStepCell(network, optimizer, sens=1.0)
|
||||
|
||||
训练网络封装类。
|
||||
|
||||
封装 `network` 和 `optimizer` ，构建一个输入'\*inputs'的用于训练的Cell。
|
||||
执行函数 `construct` 中会构建反向图以更新网络参数。支持不同的并行训练模式。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **network** (Cell)：训练网络。只支持单输出网络。
|
||||
- **optimizer** (Union[Cell])：用于更新网络参数的优化器。
|
||||
- **sens** (numbers.Number)：反向传播的输入，缩放系数。默认值为1.0。
|
||||
|
||||
**输入：**
|
||||
|
||||
**(\*inputs)** (Tuple(Tensor)) - shape为 :math:`(N, \ldots)` 的Tensor组成的元组。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor，损失函数值，其shape通常为 :math:`()` 。
|
||||
|
||||
**异常：**
|
||||
|
||||
**TypeError**：`sens` 不是numbers.Number。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> loss_fn = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> optim = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
|
||||
>>> # 1）使用MindSpore提供的WithLossCell
|
||||
>>> loss_net = nn.WithLossCell(net, loss_fn)
|
||||
>>> train_net = nn.TrainOneStepCell(loss_net, optim)
|
||||
>>>
|
||||
>>> # 2）用户自定义的WithLossCell
|
||||
>>> class MyWithLossCell(Cell):
|
||||
... def __init__(self, backbone, loss_fn):
|
||||
... super(MyWithLossCell, self).__init__(auto_prefix=False)
|
||||
... self._backbone = backbone
|
||||
... self._loss_fn = loss_fn
|
||||
...
|
||||
... def construct(self, x, y, label):
|
||||
... out = self._backbone(x, y)
|
||||
... return self._loss_fn(out, label)
|
||||
...
|
||||
... @property
|
||||
... def backbone_network(self):
|
||||
... return self._backbone
|
||||
...
|
||||
>>> loss_net = MyWithLossCell(net, loss_fn)
|
||||
>>> train_net = nn.TrainOneStepCell(loss_net, optim)
|
||||
|
||||
|
|
@ -1,129 +1,129 @@
|
|||
mindspore.nn.TrainOneStepWithLossScaleCell
|
||||
==========================================
|
||||
|
||||
.. py:class:: mindspore.nn.TrainOneStepWithLossScaleCell(network, optimizer, scale_sense)
|
||||
|
||||
使用梯度放大功能（loss scale）的训练网络。
|
||||
|
||||
实现了包含梯度放大功能的单次训练。它使用网络、优化器和用于更新梯度放大系数的Cell(或一个Tensor)作为参数。可在host侧或device侧更新梯度放大系数。
|
||||
如果需要在host侧更新，使用Tensor作为 `scale_sense` ，否则，使用可更新梯度放大系数的Cell实例作为 `scale_sense` 。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **network** (Cell)：训练网络。仅支持单输出网络。
|
||||
- **optimizer** (Cell)：用于更新网络参数的优化器。
|
||||
- **scale_sense** (Union[Tensor, Cell])：如果此值为Cell类型，`TrainOneStepWithLossScaleCell` 会调用它来更新梯度放大系数。如果此值为Tensor类型，可调用 `set_sense_scale` 来更新梯度放大系数，shape为 :math:`()` 或 :math:`(1,)` 。
|
||||
|
||||
**输入：**
|
||||
|
||||
**(*inputs)** (Tuple(Tensor))- shape为 :math:`(N, \ldots)` 的Tensor组成的元组。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tuple，包含三个Tensor，分别为损失函数值、溢出状态和当前梯度放大系数。
|
||||
|
||||
- **loss** （Tensor） - shape为 :math:`()` 的Tensor。
|
||||
- **overflow** （Tensor）- shape为 :math:`()` 的Tensor，类型为bool。
|
||||
- **loss scale** （Tensor）- shape为 :math:`()` 的Tensor。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`scale_sense` 既不是Cell，也不是Tensor。
|
||||
- **ValueError**：`scale_sense` 的shape既不是(1,)也不是()。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> import numpy as np
|
||||
>>> from mindspore import Tensor, Parameter, nn, ops
|
||||
>>> from mindspore import dtype as mstype
|
||||
>>>
|
||||
>>> class Net(nn.Cell):
|
||||
... def __init__(self, in_features, out_features):
|
||||
... super(Net, self).__init__()
|
||||
... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
|
||||
... name='weight')
|
||||
... self.matmul = ops.MatMul()
|
||||
...
|
||||
... def construct(self, x):
|
||||
... output = self.matmul(x, self.weight)
|
||||
... return output
|
||||
...
|
||||
>>> size, in_features, out_features = 16, 16, 10
|
||||
>>> #1）scale_sense类型为Cell时：
|
||||
>>> net = Net(in_features, out_features)
|
||||
>>> loss = nn.MSELoss()
|
||||
>>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
|
||||
>>> net_with_loss = nn.WithLossCell(net, loss)
|
||||
>>> manager = nn.DynamicLossScaleUpdateCell(loss_scale_value=2**12, scale_factor=2, scale_window=1000)
|
||||
>>> train_network = nn.TrainOneStepWithLossScaleCell(net_with_loss, optimizer, scale_sense=manager)
|
||||
>>> input = Tensor(np.ones([out_features, in_features]), mindspore.float32)
|
||||
>>> labels = Tensor(np.ones([out_features,]), mindspore.float32)
|
||||
>>> output = train_network(input, labels)
|
||||
>>>
|
||||
>>>> #2）当scale_sense类型为Tensor时：
|
||||
>>> net = Net(in_features, out_features)
|
||||
>>> loss = nn.MSELoss()
|
||||
>>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
|
||||
>>> net_with_loss = nn.WithLossCell(net, loss)
|
||||
>>> inputs = Tensor(np.ones([size, in_features]).astype(np.float32))
|
||||
>>> label = Tensor(np.zeros([size, out_features]).astype(np.float32))
|
||||
>>> scaling_sens = Tensor(np.full((1), np.finfo(np.float32).max), dtype=mstype.float32)
|
||||
>>> train_network = nn.TrainOneStepWithLossScaleCell(net_with_loss, optimizer, scale_sense=scaling_sens)
|
||||
>>> output = train_network(inputs, label)
|
||||
|
||||
.. py:method:: get_overflow_status(status, compute_output)
|
||||
|
||||
获取浮点溢出状态。
|
||||
|
||||
溢出检测的目标过程执行完成后，获取溢出结果。继承该类自定义训练网络时，可复用该接口。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **status** (object) - 用于检测溢出的状态实例。
|
||||
- **compute_output** - 对特定计算过程进行溢出检测时，将 `compute_output` 设置为该计算过程的输出，以确保在执行计算之前获取了 `status`。
|
||||
|
||||
**输出：**
|
||||
|
||||
bool，是否发生溢出。
|
||||
|
||||
|
||||
.. py:method:: process_loss_scale(overflow)
|
||||
|
||||
根据溢出状态计算梯度放大系数。继承该类自定义训练网络时，可复用该接口。
|
||||
|
||||
**输入：**
|
||||
|
||||
**overflow** (bool) - 是否发生溢出。
|
||||
|
||||
**输出：**
|
||||
|
||||
bool，溢出状态，即输入。
|
||||
|
||||
|
||||
.. py:method:: set_sense_scale(sens)
|
||||
|
||||
如果使用了Tensor类型的`scale_sense`，可调用此函数修改它的值。
|
||||
|
||||
**输入：**
|
||||
|
||||
**sens** （Tensor）- 新的梯度放大系数，其shape和类型需要与原始 `scale_sense` 相同。
|
||||
|
||||
.. py:method:: start_overflow_check(pre_cond, compute_input)
|
||||
|
||||
启动浮点溢出检测。创建并清除溢出检测状态。
|
||||
|
||||
指定参数 `pre_cond` 和 `compute_input` ，以确保在正确的时间清除溢出状态。以当前接口为例，我们需要在损失函数计算后进行清除状态，在梯度计算过程中检测溢出。在这种情况下，`pre_cond` 应为损失函数的输出，而 `compute_input` 应为梯度计算函数的输入。继承该类自定义训练网络时，可复用该接口。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **pre_cond** (Tensor) -启动溢出检测的先决条件。它决定溢出状态清除和先前处理的执行顺序。它确保函数 `start_overflow` 在执行完先决条件后清除状态。
|
||||
- **compute_input** (object) - 后续运算的输入。需要对特定的计算过程进行溢出检测。将 `compute_input` 设置这一计算过程的输入，以确保在执行该计算之前清除了溢出状态。
|
||||
|
||||
**输出：**
|
||||
|
||||
**Tuple** [object, object]，GPU后端的第一个值为False，而其他后端的第一个值是NPUAllocFloatStatus的实例。该值用于在 `get_overflow_status` 期间检测溢出。第二个值与 `compute_input` 的输入相同，用于控制执行序。
|
||||
mindspore.nn.TrainOneStepWithLossScaleCell
|
||||
==========================================
|
||||
|
||||
.. py:class:: mindspore.nn.TrainOneStepWithLossScaleCell(network, optimizer, scale_sense)
|
||||
|
||||
使用梯度放大功能（loss scale）的训练网络。
|
||||
|
||||
实现了包含梯度放大功能的单次训练。它使用网络、优化器和用于更新梯度放大系数的Cell(或一个Tensor)作为参数。可在host侧或device侧更新梯度放大系数。
|
||||
如果需要在host侧更新，使用Tensor作为 `scale_sense` ，否则，使用可更新梯度放大系数的Cell实例作为 `scale_sense` 。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **network** (Cell)：训练网络。仅支持单输出网络。
|
||||
- **optimizer** (Cell)：用于更新网络参数的优化器。
|
||||
- **scale_sense** (Union[Tensor, Cell])：如果此值为Cell类型，`TrainOneStepWithLossScaleCell` 会调用它来更新梯度放大系数。如果此值为Tensor类型，可调用 `set_sense_scale` 来更新梯度放大系数，shape为 :math:`()` 或 :math:`(1,)` 。
|
||||
|
||||
**输入：**
|
||||
|
||||
**(*inputs)** (Tuple(Tensor))- shape为 :math:`(N, \ldots)` 的Tensor组成的元组。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tuple，包含三个Tensor，分别为损失函数值、溢出状态和当前梯度放大系数。
|
||||
|
||||
- **loss** （Tensor） - shape为 :math:`()` 的Tensor。
|
||||
- **overflow** （Tensor）- shape为 :math:`()` 的Tensor，类型为bool。
|
||||
- **loss scale** （Tensor）- shape为 :math:`()` 的Tensor。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError**：`scale_sense` 既不是Cell，也不是Tensor。
|
||||
- **ValueError**：`scale_sense` 的shape既不是(1,)也不是()。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> import numpy as np
|
||||
>>> from mindspore import Tensor, Parameter, nn, ops
|
||||
>>> from mindspore import dtype as mstype
|
||||
>>>
|
||||
>>> class Net(nn.Cell):
|
||||
... def __init__(self, in_features, out_features):
|
||||
... super(Net, self).__init__()
|
||||
... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
|
||||
... name='weight')
|
||||
... self.matmul = ops.MatMul()
|
||||
...
|
||||
... def construct(self, x):
|
||||
... output = self.matmul(x, self.weight)
|
||||
... return output
|
||||
...
|
||||
>>> size, in_features, out_features = 16, 16, 10
|
||||
>>> #1）scale_sense类型为Cell时：
|
||||
>>> net = Net(in_features, out_features)
|
||||
>>> loss = nn.MSELoss()
|
||||
>>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
|
||||
>>> net_with_loss = nn.WithLossCell(net, loss)
|
||||
>>> manager = nn.DynamicLossScaleUpdateCell(loss_scale_value=2**12, scale_factor=2, scale_window=1000)
|
||||
>>> train_network = nn.TrainOneStepWithLossScaleCell(net_with_loss, optimizer, scale_sense=manager)
|
||||
>>> input = Tensor(np.ones([out_features, in_features]), mindspore.float32)
|
||||
>>> labels = Tensor(np.ones([out_features,]), mindspore.float32)
|
||||
>>> output = train_network(input, labels)
|
||||
>>>
|
||||
>>>> #2）当scale_sense类型为Tensor时：
|
||||
>>> net = Net(in_features, out_features)
|
||||
>>> loss = nn.MSELoss()
|
||||
>>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
|
||||
>>> net_with_loss = nn.WithLossCell(net, loss)
|
||||
>>> inputs = Tensor(np.ones([size, in_features]).astype(np.float32))
|
||||
>>> label = Tensor(np.zeros([size, out_features]).astype(np.float32))
|
||||
>>> scaling_sens = Tensor(np.full((1), np.finfo(np.float32).max), dtype=mstype.float32)
|
||||
>>> train_network = nn.TrainOneStepWithLossScaleCell(net_with_loss, optimizer, scale_sense=scaling_sens)
|
||||
>>> output = train_network(inputs, label)
|
||||
|
||||
.. py:method:: get_overflow_status(status, compute_output)
|
||||
|
||||
获取浮点溢出状态。
|
||||
|
||||
溢出检测的目标过程执行完成后，获取溢出结果。继承该类自定义训练网络时，可复用该接口。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **status** (object) - 用于检测溢出的状态实例。
|
||||
- **compute_output** - 对特定计算过程进行溢出检测时，将 `compute_output` 设置为该计算过程的输出，以确保在执行计算之前获取了 `status`。
|
||||
|
||||
**输出：**
|
||||
|
||||
bool，是否发生溢出。
|
||||
|
||||
|
||||
.. py:method:: process_loss_scale(overflow)
|
||||
|
||||
根据溢出状态计算梯度放大系数。继承该类自定义训练网络时，可复用该接口。
|
||||
|
||||
**输入：**
|
||||
|
||||
**overflow** (bool) - 是否发生溢出。
|
||||
|
||||
**输出：**
|
||||
|
||||
bool，溢出状态，即输入。
|
||||
|
||||
|
||||
.. py:method:: set_sense_scale(sens)
|
||||
|
||||
如果使用了Tensor类型的`scale_sense`，可调用此函数修改它的值。
|
||||
|
||||
**输入：**
|
||||
|
||||
**sens** （Tensor）- 新的梯度放大系数，其shape和类型需要与原始 `scale_sense` 相同。
|
||||
|
||||
.. py:method:: start_overflow_check(pre_cond, compute_input)
|
||||
|
||||
启动浮点溢出检测。创建并清除溢出检测状态。
|
||||
|
||||
指定参数 `pre_cond` 和 `compute_input` ，以确保在正确的时间清除溢出状态。以当前接口为例，我们需要在损失函数计算后进行清除状态，在梯度计算过程中检测溢出。在这种情况下，`pre_cond` 应为损失函数的输出，而 `compute_input` 应为梯度计算函数的输入。继承该类自定义训练网络时，可复用该接口。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **pre_cond** (Tensor) -启动溢出检测的先决条件。它决定溢出状态清除和先前处理的执行顺序。它确保函数 `start_overflow` 在执行完先决条件后清除状态。
|
||||
- **compute_input** (object) - 后续运算的输入。需要对特定的计算过程进行溢出检测。将 `compute_input` 设置这一计算过程的输入，以确保在执行该计算之前清除了溢出状态。
|
||||
|
||||
**输出：**
|
||||
|
||||
**Tuple** [object, object]，GPU后端的第一个值为False，而其他后端的第一个值是NPUAllocFloatStatus的实例。该值用于在 `get_overflow_status` 期间检测溢出。第二个值与 `compute_input` 的输入相同，用于控制执行序。
|
||||
|
||||
|
|
@ -1,36 +1,36 @@
|
|||
mindspore.nn.WithEvalCell
|
||||
=========================
|
||||
|
||||
.. py:class:: mindspore.nn.WithEvalCell(network, loss_fn, add_cast_fp32=False)
|
||||
|
||||
封装前向网络和损失函数，返回用于计算评估指标的损失函数值、前向输出和标签。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **network** (Cell)：前向网络。
|
||||
- **loss_fn** (Cell)：损失函数。
|
||||
- **add_cast_fp32** (bool)：是否将数据类型调整为float32。默认值：False。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **data** （Tensor） - shape为 :math:`(N, \ldots)` 的Tensor。
|
||||
- **label** （Tensor） - shape为 :math:`(N, \ldots)` 的Tensor。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tuple(Tensor)，包括标量损失函数、shape为 :math:`(N, \ldots)` 的网络输出和shape为 :math:`(N, \ldots)` 的标签。
|
||||
|
||||
**异常：**
|
||||
|
||||
**TypeError**： `add_cast_fp32` 不是bool。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> # 未包含损失函数的前向网络
|
||||
>>> net = Net()
|
||||
>>> loss_fn = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> eval_net = nn.WithEvalCell(net, loss_fn)
|
||||
mindspore.nn.WithEvalCell
|
||||
=========================
|
||||
|
||||
.. py:class:: mindspore.nn.WithEvalCell(network, loss_fn, add_cast_fp32=False)
|
||||
|
||||
封装前向网络和损失函数，返回用于计算评估指标的损失函数值、前向输出和标签。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **network** (Cell)：前向网络。
|
||||
- **loss_fn** (Cell)：损失函数。
|
||||
- **add_cast_fp32** (bool)：是否将数据类型调整为float32。默认值：False。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **data** （Tensor） - shape为 :math:`(N, \ldots)` 的Tensor。
|
||||
- **label** （Tensor） - shape为 :math:`(N, \ldots)` 的Tensor。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tuple(Tensor)，包括标量损失函数、shape为 :math:`(N, \ldots)` 的网络输出和shape为 :math:`(N, \ldots)` 的标签。
|
||||
|
||||
**异常：**
|
||||
|
||||
**TypeError**： `add_cast_fp32` 不是bool。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> # 未包含损失函数的前向网络
|
||||
>>> net = Net()
|
||||
>>> loss_fn = nn.SoftmaxCrossEntropyWithLogits()
|
||||
>>> eval_net = nn.WithEvalCell(net, loss_fn)
|
||||
|
|
@ -1,53 +1,53 @@
|
|||
mindspore.nn.WithLossCell
|
||||
=========================
|
||||
|
||||
.. py:class:: mindspore.nn.WithLossCell(backbone, loss_fn)
|
||||
|
||||
包含损失函数的Cell。
|
||||
|
||||
封装 `backbone` 和 `loss_fn` 。此Cell接受数据和标签作为输入，并将返回损失函数作为计算结果。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **backbone** (Cell)：要封装的目标网络。
|
||||
- **loss_fn** (Cell)：用于计算损失函数。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **data** （Tensor） - shape为 :math:`(N, \ldots)` 的Tensor。
|
||||
- **label** （Tensor） - shape为 :math:`(N, \ldots)` 的Tensor。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor，loss值，其shape通常为 :math:`()` 。
|
||||
|
||||
**异常：**
|
||||
|
||||
**TypeError**：`data` 或 `label` 的数据类型既不是float16也不是float32。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> loss_fn = nn.SoftmaxCrossEntropyWithLogits(sparse=False)
|
||||
>>> net_with_criterion = nn.WithLossCell(net, loss_fn)
|
||||
>>>
|
||||
>>> batch_size = 2
|
||||
>>> data = Tensor(np.ones([batch_size, 1, 32, 32]).astype(np.float32) * 0.01)
|
||||
>>> label = Tensor(np.ones([batch_size, 10]).astype(np.float32))
|
||||
>>>
|
||||
>>> output_data = net_with_criterion(data, label)
|
||||
|
||||
|
||||
.. py:method:: backbone_network
|
||||
:property:
|
||||
|
||||
获取骨干网络。
|
||||
|
||||
**返回：**
|
||||
|
||||
Cell，骨干网络。
|
||||
mindspore.nn.WithLossCell
|
||||
=========================
|
||||
|
||||
.. py:class:: mindspore.nn.WithLossCell(backbone, loss_fn)
|
||||
|
||||
包含损失函数的Cell。
|
||||
|
||||
封装 `backbone` 和 `loss_fn` 。此Cell接受数据和标签作为输入，并将返回损失函数作为计算结果。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **backbone** (Cell)：要封装的目标网络。
|
||||
- **loss_fn** (Cell)：用于计算损失函数。
|
||||
|
||||
**输入：**
|
||||
|
||||
- **data** （Tensor） - shape为 :math:`(N, \ldots)` 的Tensor。
|
||||
- **label** （Tensor） - shape为 :math:`(N, \ldots)` 的Tensor。
|
||||
|
||||
**输出：**
|
||||
|
||||
Tensor，loss值，其shape通常为 :math:`()` 。
|
||||
|
||||
**异常：**
|
||||
|
||||
**TypeError**：`data` 或 `label` 的数据类型既不是float16也不是float32。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU`` ``CPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> loss_fn = nn.SoftmaxCrossEntropyWithLogits(sparse=False)
|
||||
>>> net_with_criterion = nn.WithLossCell(net, loss_fn)
|
||||
>>>
|
||||
>>> batch_size = 2
|
||||
>>> data = Tensor(np.ones([batch_size, 1, 32, 32]).astype(np.float32) * 0.01)
|
||||
>>> label = Tensor(np.ones([batch_size, 10]).astype(np.float32))
|
||||
>>>
|
||||
>>> output_data = net_with_criterion(data, label)
|
||||
|
||||
|
||||
.. py:method:: backbone_network
|
||||
:property:
|
||||
|
||||
获取骨干网络。
|
||||
|
||||
**返回：**
|
||||
|
||||
Cell，骨干网络。
|
||||
|
||||
|
|
@ -1,38 +1,38 @@
|
|||
mindspore.nn.cosine_decay_lr
|
||||
==============================
|
||||
|
||||
.. py:class:: mindspore.nn.cosine_decay_lr(min_lr, max_lr, total_step, step_per_epoch, decay_epoch)
|
||||
|
||||
基于余弦衰减函数计算学习率。
|
||||
|
||||
对于第i步，计算decayed_learning_rate[i]的公式为：
|
||||
|
||||
.. math::
|
||||
decayed\_learning\_rate[i] = min\_lr + 0.5 * (max\_lr - min\_lr) *
|
||||
(1 + cos(\frac{current\_epoch}{decay\_epoch}\pi))
|
||||
|
||||
其中 :math:`current\_epoch=floor(\frac{i}{step\_per\_epoch})`。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **min_lr** (float)：学习率的最小值。
|
||||
- **max_lr** (float)：学习率的最大值。
|
||||
- **total_step** (int)：step总数。
|
||||
- **step_per_epoch** (int)：每个epoch的step数。
|
||||
- **decay_epoch** (int)：用于计算衰减学习率的值。
|
||||
|
||||
**返回：**
|
||||
|
||||
list[float]。列表大小为`total_step`。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> min_lr = 0.01
|
||||
>>> max_lr = 0.1
|
||||
>>> total_step = 6
|
||||
>>> step_per_epoch = 2
|
||||
>>> decay_epoch = 2
|
||||
>>> output = cosine_decay_lr(min_lr, max_lr, total_step, step_per_epoch, decay_epoch)
|
||||
>>> print(output)
|
||||
[0.1, 0.1, 0.05500000000000001, 0.05500000000000001, 0.01, 0.01]
|
||||
mindspore.nn.cosine_decay_lr
|
||||
==============================
|
||||
|
||||
.. py:class:: mindspore.nn.cosine_decay_lr(min_lr, max_lr, total_step, step_per_epoch, decay_epoch)
|
||||
|
||||
基于余弦衰减函数计算学习率。
|
||||
|
||||
对于第i步，计算decayed_learning_rate[i]的公式为：
|
||||
|
||||
.. math::
|
||||
decayed\_learning\_rate[i] = min\_lr + 0.5 * (max\_lr - min\_lr) *
|
||||
(1 + cos(\frac{current\_epoch}{decay\_epoch}\pi))
|
||||
|
||||
其中 :math:`current\_epoch=floor(\frac{i}{step\_per\_epoch})`。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **min_lr** (float)：学习率的最小值。
|
||||
- **max_lr** (float)：学习率的最大值。
|
||||
- **total_step** (int)：step总数。
|
||||
- **step_per_epoch** (int)：每个epoch的step数。
|
||||
- **decay_epoch** (int)：用于计算衰减学习率的值。
|
||||
|
||||
**返回：**
|
||||
|
||||
list[float]。列表大小为`total_step`。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> min_lr = 0.01
|
||||
>>> max_lr = 0.1
|
||||
>>> total_step = 6
|
||||
>>> step_per_epoch = 2
|
||||
>>> decay_epoch = 2
|
||||
>>> output = cosine_decay_lr(min_lr, max_lr, total_step, step_per_epoch, decay_epoch)
|
||||
>>> print(output)
|
||||
[0.1, 0.1, 0.05500000000000001, 0.05500000000000001, 0.01, 0.01]
|
||||
|
||||
|
|
@ -1,38 +1,38 @@
|
|||
mindspore.nn.exponential_decay_lr
|
||||
=======================================
|
||||
|
||||
.. py:class:: mindspore.nn.exponential_decay_lr(learning_rate, decay_rate, total_step, step_per_epoch, decay_epoch, is_stair=False)
|
||||
|
||||
基于指数衰减函数计算学习率。
|
||||
|
||||
对于第i步，计算decayed_learning_rate[i]的公式为：
|
||||
|
||||
.. math::
|
||||
decayed\_learning\_rate[i] = learning\_rate * decay\_rate^{\frac{current\_epoch}{decay\_epoch}}
|
||||
|
||||
其中 :math:`current\_epoch=floor(\frac{i}{step\_per\_epoch})`。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **learning_rate (float)：学习率的初始值。
|
||||
- **decay_rate (float)：衰减率。
|
||||
- **total_step (int)：step总数。
|
||||
- **step_per_epoch (int)：每个 epoch的step数。
|
||||
- **decay_epoch (int)：用于计算衰减学习率的值。
|
||||
- **is_stair (bool)：如果为True，则学习率每 `decay_epoch` 次衰减一次。默认值：False。
|
||||
|
||||
**返回：**
|
||||
|
||||
list[float]。列表的大小为`total_step`。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> learning_rate = 0.1
|
||||
>>> decay_rate = 0.9
|
||||
>>> total_step = 6
|
||||
>>> step_per_epoch = 2
|
||||
>>> decay_epoch = 1
|
||||
>>> output = exponential_decay_lr(learning_rate, decay_rate, total_step, step_per_epoch, decay_epoch)
|
||||
>>> print(output)
|
||||
[0.1, 0.1, 0.09000000000000001, 0.09000000000000001, 0.08100000000000002, 0.08100000000000002]
|
||||
mindspore.nn.exponential_decay_lr
|
||||
=======================================
|
||||
|
||||
.. py:class:: mindspore.nn.exponential_decay_lr(learning_rate, decay_rate, total_step, step_per_epoch, decay_epoch, is_stair=False)
|
||||
|
||||
基于指数衰减函数计算学习率。
|
||||
|
||||
对于第i步，计算decayed_learning_rate[i]的公式为：
|
||||
|
||||
.. math::
|
||||
decayed\_learning\_rate[i] = learning\_rate * decay\_rate^{\frac{current\_epoch}{decay\_epoch}}
|
||||
|
||||
其中 :math:`current\_epoch=floor(\frac{i}{step\_per\_epoch})`。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **learning_rate** (float)：学习率的初始值。
|
||||
- **decay_rate** (float)：衰减率。
|
||||
- **total_step** (int)：step总数。
|
||||
- **step_per_epoch** (int)：每个 epoch的step数。
|
||||
- **decay_epoch** (int)：用于计算衰减学习率的值。
|
||||
- **is_stair** (bool)：如果为True，则学习率每 `decay_epoch` 次衰减一次。默认值：False。
|
||||
|
||||
**返回：**
|
||||
|
||||
list[float]。列表的大小为`total_step`。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> learning_rate = 0.1
|
||||
>>> decay_rate = 0.9
|
||||
>>> total_step = 6
|
||||
>>> step_per_epoch = 2
|
||||
>>> decay_epoch = 1
|
||||
>>> output = exponential_decay_lr(learning_rate, decay_rate, total_step, step_per_epoch, decay_epoch)
|
||||
>>> print(output)
|
||||
[0.1, 0.1, 0.09000000000000001, 0.09000000000000001, 0.08100000000000002, 0.08100000000000002]
|
||||
|
||||
|
|
@ -1,38 +1,38 @@
|
|||
mindspore.nn.inverse_decay_l
|
||||
=============================
|
||||
|
||||
.. py:class:: mindspore.nn.inverse_decay_lr(learning_rate, decay_rate, total_step, step_per_epoch, decay_epoch, is_stair=False)
|
||||
|
||||
基于逆时间衰减函数计算学习率。
|
||||
|
||||
对于第i步，计算decayed_learning_rate[i]的公式为：
|
||||
|
||||
.. math::
|
||||
decayed\_learning\_rate[i] = learning\_rate / (1 + decay\_rate * current\_epoch / decay\_epoch)
|
||||
|
||||
其中，:math:`current\_epoch=floor(\frac{i}{step\_per\_epoch})`。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **learning_rate** (float)：学习率的初始值。
|
||||
- **decay_rate** (float)：衰减率。
|
||||
- **total_step** (int)：step总数。
|
||||
- **step_per_epoch** (int)：每个epoch的step数。
|
||||
- **decay_epoch** (int)：用于计算衰减学习率的值。
|
||||
- **is_stair** (bool)：如果为True，则学习率每 `decay_epoch` 次衰减一次。默认值：False。
|
||||
|
||||
**返回：**
|
||||
|
||||
list[float]。列表大小为 `total_step` 。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> learning_rate = 0.1
|
||||
>>> decay_rate = 0.5
|
||||
>>> total_step = 6
|
||||
>>> step_per_epoch = 1
|
||||
>>> decay_epoch = 1
|
||||
>>> output = inverse_decay_lr(learning_rate, decay_rate, total_step, step_per_epoch, decay_epoch, True)
|
||||
>>> print(output)
|
||||
[0.1, 0.06666666666666667, 0.05, 0.04, 0.03333333333333333, 0.028571428571428574]
|
||||
mindspore.nn.inverse_decay_l
|
||||
=============================
|
||||
|
||||
.. py:class:: mindspore.nn.inverse_decay_lr(learning_rate, decay_rate, total_step, step_per_epoch, decay_epoch, is_stair=False)
|
||||
|
||||
基于逆时间衰减函数计算学习率。
|
||||
|
||||
对于第i步，计算decayed_learning_rate[i]的公式为：
|
||||
|
||||
.. math::
|
||||
decayed\_learning\_rate[i] = learning\_rate / (1 + decay\_rate * current\_epoch / decay\_epoch)
|
||||
|
||||
其中，:math:`current\_epoch=floor(\frac{i}{step\_per\_epoch})`。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **learning_rate** (float)：学习率的初始值。
|
||||
- **decay_rate** (float)：衰减率。
|
||||
- **total_step** (int)：step总数。
|
||||
- **step_per_epoch** (int)：每个epoch的step数。
|
||||
- **decay_epoch** (int)：用于计算衰减学习率的值。
|
||||
- **is_stair** (bool)：如果为True，则学习率每 `decay_epoch` 次衰减一次。默认值：False。
|
||||
|
||||
**返回：**
|
||||
|
||||
list[float]。列表大小为 `total_step` 。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> learning_rate = 0.1
|
||||
>>> decay_rate = 0.5
|
||||
>>> total_step = 6
|
||||
>>> step_per_epoch = 1
|
||||
>>> decay_epoch = 1
|
||||
>>> output = inverse_decay_lr(learning_rate, decay_rate, total_step, step_per_epoch, decay_epoch, True)
|
||||
>>> print(output)
|
||||
[0.1, 0.06666666666666667, 0.05, 0.04, 0.03333333333333333, 0.028571428571428574]
|
||||
|
||||
|
|
@ -1,38 +1,38 @@
|
|||
mindspore.nn.natural_exp_decay_lr
|
||||
=================================
|
||||
|
||||
.. py:class:: mindspore.nn.natural_exp_decay_lr(learning_rate, decay_rate, total_step, step_per_epoch, decay_epoch, is_stair=False)
|
||||
|
||||
基于自然指数衰减函数计算学习率。
|
||||
|
||||
对于第i步，计算decayed_learning_rate[i]的公式为：
|
||||
|
||||
.. math::
|
||||
decayed\_learning\_rate[i] = learning\_rate * e^{-decay\_rate * current\_epoch}
|
||||
|
||||
其中 :math:`current\_epoch=floor(\frac{i}{step\_per\_epoch})` 。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **learning_rate** (float)：学习率的初始值。
|
||||
- **decay_rate** (float)：衰减率。
|
||||
- **total_step** (int)：step总数。
|
||||
- **step_per_epoch** (int)：每个epoch的step数。
|
||||
- **decay_epoch** (int)：用于计算衰减学习率的值。
|
||||
- **is_stair** (bool)：如果为True，则学习率每 `decay_epoch` 次衰减一次。默认值：False。
|
||||
|
||||
**返回：**
|
||||
|
||||
list[float]. `total_step`表示列表的大小。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> learning_rate = 0.1
|
||||
>>> decay_rate = 0.9
|
||||
>>> total_step = 6
|
||||
>>> step_per_epoch = 2
|
||||
>>> decay_epoch = 2
|
||||
>>> output = natural_exp_decay_lr(learning_rate, decay_rate, total_step, step_per_epoch, decay_epoch, True)
|
||||
>>> print(output)
|
||||
[0.1, 0.1, 0.1, 0.1, 0.016529888822158657, 0.016529888822158657]
|
||||
mindspore.nn.natural_exp_decay_lr
|
||||
=================================
|
||||
|
||||
.. py:class:: mindspore.nn.natural_exp_decay_lr(learning_rate, decay_rate, total_step, step_per_epoch, decay_epoch, is_stair=False)
|
||||
|
||||
基于自然指数衰减函数计算学习率。
|
||||
|
||||
对于第i步，计算decayed_learning_rate[i]的公式为：
|
||||
|
||||
.. math::
|
||||
decayed\_learning\_rate[i] = learning\_rate * e^{-decay\_rate * current\_epoch}
|
||||
|
||||
其中 :math:`current\_epoch=floor(\frac{i}{step\_per\_epoch})` 。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **learning_rate** (float)：学习率的初始值。
|
||||
- **decay_rate** (float)：衰减率。
|
||||
- **total_step** (int)：step总数。
|
||||
- **step_per_epoch** (int)：每个epoch的step数。
|
||||
- **decay_epoch** (int)：用于计算衰减学习率的值。
|
||||
- **is_stair** (bool)：如果为True，则学习率每 `decay_epoch` 次衰减一次。默认值：False。
|
||||
|
||||
**返回：**
|
||||
|
||||
list[float] - `total_step` 表示列表的大小。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> learning_rate = 0.1
|
||||
>>> decay_rate = 0.9
|
||||
>>> total_step = 6
|
||||
>>> step_per_epoch = 2
|
||||
>>> decay_epoch = 2
|
||||
>>> output = natural_exp_decay_lr(learning_rate, decay_rate, total_step, step_per_epoch, decay_epoch, True)
|
||||
>>> print(output)
|
||||
[0.1, 0.1, 0.1, 0.1, 0.016529888822158657, 0.016529888822158657]
|
||||
|
||||
|
|
@ -1,29 +1,29 @@
|
|||
mindspore.nn.piecewise_constant_lr
|
||||
====================================
|
||||
|
||||
.. py:class:: mindspore.nn.piecewise_constant_lr(milestone, learning_rates)
|
||||
|
||||
获取分段常量学习率。
|
||||
|
||||
通过给定的 `milestone` 和 `learning_rates` 计算学习率。设 `milestone` 的值为 :math:`(M_1, M_2, ..., M_t, ..., M_N)` ， `learning_rates` 的值为 :math:`(x_1, x_2, ..., x_t, ..., x_N)` 。N是 `milestone` 的长度。
|
||||
设 `y` 为输出学习率， 那么对于第i步，计算y[i]的公式为：
|
||||
|
||||
.. math::
|
||||
y[i] = x_t,\ for\ i \in [M_{t-1}, M_t)
|
||||
|
||||
**参数：**
|
||||
|
||||
- **milestone** (Union[list[int], tuple[int]])：milestone列表。此列表是一个单调递增的列表。类表中的元素必须大于0。
|
||||
- **learning_rates** (Union[list[float], tuple[float]])：学习率列表。
|
||||
|
||||
**返回：**
|
||||
|
||||
list[float]。列表的大小为 :math:`M_N`。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> milestone = [2, 5, 10]
|
||||
>>> learning_rates = [0.1, 0.05, 0.01]
|
||||
>>> output = piecewise_constant_lr(milestone, learning_rates)
|
||||
>>> print(output)
|
||||
[0.1, 0.1, 0.05, 0.05, 0.05, 0.01, 0.01, 0.01, 0.01, 0.01]
|
||||
mindspore.nn.piecewise_constant_lr
|
||||
====================================
|
||||
|
||||
.. py:class:: mindspore.nn.piecewise_constant_lr(milestone, learning_rates)
|
||||
|
||||
获取分段常量学习率。
|
||||
|
||||
通过给定的 `milestone` 和 `learning_rates` 计算学习率。设 `milestone` 的值为 :math:`(M_1, M_2, ..., M_t, ..., M_N)` ， `learning_rates` 的值为 :math:`(x_1, x_2, ..., x_t, ..., x_N)` 。N是 `milestone` 的长度。
|
||||
设 `y` 为输出学习率， 那么对于第i步，计算y[i]的公式为：
|
||||
|
||||
.. math::
|
||||
y[i] = x_t,\ for\ i \in [M_{t-1}, M_t)
|
||||
|
||||
**参数：**
|
||||
|
||||
- **milestone** (Union[list[int], tuple[int]])：milestone列表。此列表是一个单调递增的列表。类表中的元素必须大于0。
|
||||
- **learning_rates** (Union[list[float], tuple[float]])：学习率列表。
|
||||
|
||||
**返回：**
|
||||
|
||||
list[float]。列表的大小为 :math:`M_N`。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> milestone = [2, 5, 10]
|
||||
>>> learning_rates = [0.1, 0.05, 0.01]
|
||||
>>> output = piecewise_constant_lr(milestone, learning_rates)
|
||||
>>> print(output)
|
||||
[0.1, 0.1, 0.05, 0.05, 0.05, 0.01, 0.01, 0.01, 0.01, 0.01]
|
||||
|
|
@ -1,55 +1,55 @@
|
|||
mindspore.nn.polynomial_decay_lr
|
||||
====================================
|
||||
|
||||
.. py:class:: mindspore.nn.polynomial_decay_lr(learning_rate, end_learning_rate, total_step, step_per_epoch, decay_epoch, power, update_decay_epoch=False)
|
||||
|
||||
基于多项式衰减函数计算学习率。
|
||||
|
||||
对于第i步，计算decayed_learning_rate[i]的公式为：
|
||||
|
||||
.. math::
|
||||
decayed\_learning\_rate[i] = (learning\_rate - end\_learning\_rate) *
|
||||
(1 - tmp\_epoch / tmp\_decay\_epoch)^{power} + end\_learning\_rate
|
||||
|
||||
其中，
|
||||
|
||||
.. math::
|
||||
tmp\_epoch = min(current\_epoch, decay\_epoch)
|
||||
|
||||
.. math::
|
||||
current\_epoch=floor(\frac{i}{step\_per\_epoch})
|
||||
|
||||
.. math::
|
||||
tmp\_decay\_epoch = decay\_epoch
|
||||
|
||||
如果 `update_decay_epoch` 为True，则每个epoch更新 `tmp_decay_epoch` 的值。公式为：
|
||||
|
||||
.. math::
|
||||
tmp\_decay\_epoch = decay\_epoch * ceil(current\_epoch / decay\_epoch)
|
||||
|
||||
**参数：**
|
||||
|
||||
- **learning_rate** (float)：学习率的初始值。
|
||||
- **end_learning_rate** (float)：学习率的最终值。
|
||||
- **total_step** (int)：step总数。
|
||||
- **step_per_epoch** (int)：每个epoch的step数。
|
||||
- **decay_epoch** (int)：用于计算衰减学习率的值。
|
||||
- **power** (float)：用于计算衰减学习率的值。该参数必须大于0。
|
||||
- **update_decay_epoch** (bool)：如果为True，则更新 `decay_epoch` 。默认值：False。
|
||||
|
||||
**返回：**
|
||||
|
||||
list[float]。列表的大小为 `total_step`。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> learning_rate = 0.1
|
||||
>>> end_learning_rate = 0.01
|
||||
>>> total_step = 6
|
||||
>>> step_per_epoch = 2
|
||||
>>> decay_epoch = 2
|
||||
>>> power = 0.5
|
||||
>>> r = polynomial_decay_lr(learning_rate, end_learning_rate, total_step, step_per_epoch, decay_epoch, power)
|
||||
>>> print(r)
|
||||
[0.1, 0.1, 0.07363961030678928, 0.07363961030678928, 0.01, 0.01]
|
||||
mindspore.nn.polynomial_decay_lr
|
||||
====================================
|
||||
|
||||
.. py:class:: mindspore.nn.polynomial_decay_lr(learning_rate, end_learning_rate, total_step, step_per_epoch, decay_epoch, power, update_decay_epoch=False)
|
||||
|
||||
基于多项式衰减函数计算学习率。
|
||||
|
||||
对于第i步，计算decayed_learning_rate[i]的公式为：
|
||||
|
||||
.. math::
|
||||
decayed\_learning\_rate[i] = (learning\_rate - end\_learning\_rate) *
|
||||
(1 - tmp\_epoch / tmp\_decay\_epoch)^{power} + end\_learning\_rate
|
||||
|
||||
其中，
|
||||
|
||||
.. math::
|
||||
tmp\_epoch = min(current\_epoch, decay\_epoch)
|
||||
|
||||
.. math::
|
||||
current\_epoch=floor(\frac{i}{step\_per\_epoch})
|
||||
|
||||
.. math::
|
||||
tmp\_decay\_epoch = decay\_epoch
|
||||
|
||||
如果 `update_decay_epoch` 为True，则每个epoch更新 `tmp_decay_epoch` 的值。公式为：
|
||||
|
||||
.. math::
|
||||
tmp\_decay\_epoch = decay\_epoch * ceil(current\_epoch / decay\_epoch)
|
||||
|
||||
**参数：**
|
||||
|
||||
- **learning_rate** (float)：学习率的初始值。
|
||||
- **end_learning_rate** (float)：学习率的最终值。
|
||||
- **total_step** (int)：step总数。
|
||||
- **step_per_epoch** (int)：每个epoch的step数。
|
||||
- **decay_epoch** (int)：用于计算衰减学习率的值。
|
||||
- **power** (float)：用于计算衰减学习率的值。该参数必须大于0。
|
||||
- **update_decay_epoch** (bool)：如果为True，则更新 `decay_epoch` 。默认值：False。
|
||||
|
||||
**返回：**
|
||||
|
||||
list[float]。列表的大小为 `total_step`。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> learning_rate = 0.1
|
||||
>>> end_learning_rate = 0.01
|
||||
>>> total_step = 6
|
||||
>>> step_per_epoch = 2
|
||||
>>> decay_epoch = 2
|
||||
>>> power = 0.5
|
||||
>>> r = polynomial_decay_lr(learning_rate, end_learning_rate, total_step, step_per_epoch, decay_epoch, power)
|
||||
>>> print(r)
|
||||
[0.1, 0.1, 0.07363961030678928, 0.07363961030678928, 0.01, 0.01]
|
||||
|
||||
|
|
@ -1,35 +1,35 @@
|
|||
mindspore.nn.warmup_lr
|
||||
=======================
|
||||
|
||||
.. py:function:: mindspore.nn.warmup_lr(learning_rate, total_step, step_per_epoch, warmup_epoch)
|
||||
|
||||
预热学习率。
|
||||
|
||||
对于第i步，计算warmup_learning_rate[i]的公式为：
|
||||
|
||||
.. math::
|
||||
warmup\_learning\_rate[i] = learning\_rate * tmp\_epoch / warmup\_epoch
|
||||
|
||||
其中 :math:`tmp\_epoch=min(current\_epoch, warmup\_epoch),\ current\_epoch=floor(\frac{i}{step\_per\_epoch})`
|
||||
|
||||
**参数：**
|
||||
|
||||
- **learning_rate** (float)：学习率的初始值。
|
||||
- **total_step** (int)：step总数。
|
||||
- **step_per_epoch** (int)：每个epoch的step数。
|
||||
- **warmup_epoch** (int)：预热学习率的epoch数。
|
||||
|
||||
**返回：**
|
||||
|
||||
list[float] - `total_step` 表示列表的大小。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> learning_rate = 0.1
|
||||
>>> total_step = 6
|
||||
>>> step_per_epoch = 2
|
||||
>>> warmup_epoch = 2
|
||||
>>> output = warmup_lr(learning_rate, total_step, step_per_epoch, warmup_epoch)
|
||||
>>> print(output)
|
||||
[0.0, 0.0, 0.05, 0.05, 0.1, 0.1]
|
||||
mindspore.nn.warmup_lr
|
||||
=======================
|
||||
|
||||
.. py:function:: mindspore.nn.warmup_lr(learning_rate, total_step, step_per_epoch, warmup_epoch)
|
||||
|
||||
预热学习率。
|
||||
|
||||
对于第i步，计算warmup_learning_rate[i]的公式为：
|
||||
|
||||
.. math::
|
||||
warmup\_learning\_rate[i] = learning\_rate * tmp\_epoch / warmup\_epoch
|
||||
|
||||
其中 :math:`tmp\_epoch=min(current\_epoch, warmup\_epoch),\ current\_epoch=floor(\frac{i}{step\_per\_epoch})`
|
||||
|
||||
**参数：**
|
||||
|
||||
- **learning_rate** (float)：学习率的初始值。
|
||||
- **total_step** (int)：step总数。
|
||||
- **step_per_epoch** (int)：每个epoch的step数。
|
||||
- **warmup_epoch** (int)：预热学习率的epoch数。
|
||||
|
||||
**返回：**
|
||||
|
||||
list[float] - `total_step` 表示列表的大小。
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> learning_rate = 0.1
|
||||
>>> total_step = 6
|
||||
>>> step_per_epoch = 2
|
||||
>>> warmup_epoch = 2
|
||||
>>> output = warmup_lr(learning_rate, total_step, step_per_epoch, warmup_epoch)
|
||||
>>> print(output)
|
||||
[0.0, 0.0, 0.05, 0.05, 0.1, 0.1]
|
||||
|
||||
|
|
@ -1,22 +1,22 @@
|
|||
mindspore.load_distributed_checkpoint
|
||||
======================================
|
||||
|
||||
.. py:method:: mindspore.load_distributed_checkpoint(network, checkpoint_filenames, predict_strategy=None, train_strategy_filename=None, strict_load=False, dec_key=None, dec_mode='AES-GCM')
|
||||
|
||||
给分布式预测加载checkpoint文件到网络，用于分布式推理。关于分布式推理的细节，请参考：'<https://www.mindspore.cn/docs/programming_guide/zh-CN/master/distributed_inference.html>' 。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **network** (Cell)：分布式预测网络。
|
||||
- **checkpoint_filenames** (list[str])：checkpoint文件的名称，按rank id 顺序排列。
|
||||
- **predict_strategy** (dict)：预测时参数的切分策略。
|
||||
- **train_strategy_filename** (str)：训练策略proto文件名。默认值：None。
|
||||
- **strict_load** (bool)：表示是否严格加载参数到网络。如果值为False，则当checkpoint文件中参数名称的后缀与网络中的参数相同时，加载参数到网络。当类型不一致时，对相同类型的参数进行类型转换，如从float32到float16。默认值：False。
|
||||
- **dec_key** (Union[None, bytes])：用于解密的字节类型key。如果value为None，则不需要解密。默认值：None。
|
||||
- **dec_mode** (str)：仅当dec_key不设为None时，该参数有效。指定了解密模式，目前支持AES-GCM和AES-CBC。默认值：AES-GCM。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError：** 输入类型不符合要求。
|
||||
- **ValueError：** 无法加载checkpoint文件到网络。
|
||||
mindspore.load_distributed_checkpoint
|
||||
======================================
|
||||
|
||||
.. py:method:: mindspore.load_distributed_checkpoint(network, checkpoint_filenames, predict_strategy=None, train_strategy_filename=None, strict_load=False, dec_key=None, dec_mode='AES-GCM')
|
||||
|
||||
给分布式预测加载checkpoint文件到网络，用于分布式推理。关于分布式推理的细节，请参考：'<https://www.mindspore.cn/docs/programming_guide/zh-CN/master/distributed_inference.html>' 。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **network** (Cell)：分布式预测网络。
|
||||
- **checkpoint_filenames** (list[str])：checkpoint文件的名称，按rank id 顺序排列。
|
||||
- **predict_strategy** (dict)：预测时参数的切分策略。
|
||||
- **train_strategy_filename** (str)：训练策略proto文件名。默认值：None。
|
||||
- **strict_load** (bool)：表示是否严格加载参数到网络。如果值为False，则当checkpoint文件中参数名称的后缀与网络中的参数相同时，加载参数到网络。当类型不一致时，对相同类型的参数进行类型转换，如从float32到float16。默认值：False。
|
||||
- **dec_key** (Union[None, bytes])：用于解密的字节类型key。如果value为None，则不需要解密。默认值：None。
|
||||
- **dec_mode** (str)：仅当dec_key不设为None时，该参数有效。指定了解密模式，目前支持AES-GCM和AES-CBC。默认值：AES-GCM。
|
||||
|
||||
**异常：**
|
||||
|
||||
- **TypeError：** 输入类型不符合要求。
|
||||
- **ValueError：** 无法加载checkpoint文件到网络。
|
||||
|
||||
|
|
@ -1,105 +1,105 @@
|
|||
mindspore.nn.DistributedGradReducer
|
||||
===================================
|
||||
|
||||
.. py:class:: mindspore.nn.DistributedGradReducer(parameters, mean=True, degree=None, fusion_type=1, group='hccl_world_group')
|
||||
|
||||
分布式优化器。
|
||||
|
||||
对反向梯度进行AllReduce运算。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **parameters** (list)：需要更新的参数。
|
||||
- **mean** (bool)：当mean为True时，对AllReduce之后的梯度求均值。默认值：False。
|
||||
- **degree** (int)：平均系数，通常等于设备编号。默认值：None。
|
||||
- **fusion_type** (int)：AllReduce算子的融合类型。默认值：1。
|
||||
|
||||
**异常：**
|
||||
|
||||
**ValueError**：如果degree不是int或小于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> #此示例应与多个进程一起运行。
|
||||
>>> #请参考Mindpore.cn上的“教程>分布式训练”。
|
||||
>>> import numpy as np
|
||||
>>> from mindspore.communication import init
|
||||
>>> from mindspore import ops
|
||||
>>> from mindspore import context
|
||||
>>> from mindspore.context import ParallelMode
|
||||
>>> from mindspore import Parameter, Tensor
|
||||
>>> from mindspore import nn
|
||||
>>>
|
||||
>>> context.set_context(mode=context.GRAPH_MODE)
|
||||
>>> init()
|
||||
>>> context.reset_auto_parallel_context()
|
||||
>>> context.set_auto_parallel_context(parallel_mode=ParallelMode.DATA_PARALLEL)
|
||||
>>>
|
||||
>>> class TrainingWrapper(nn.Cell):
|
||||
... def __init__(self, network, optimizer, sens=1.0):
|
||||
... super(TrainingWrapper, self).__init__(auto_prefix=False)
|
||||
... self.network = network
|
||||
... self.network.add_flags(defer_inline=True)
|
||||
... self.weights = optimizer.parameters
|
||||
... self.optimizer = optimizer
|
||||
... self.grad = ops.GradOperation(get_by_list=True, sens_param=True)
|
||||
... self.sens = sens
|
||||
... self.reducer_flag = False
|
||||
... self.grad_reducer = None
|
||||
... self.parallel_mode = context.get_auto_parallel_context("parallel_mode")
|
||||
... if self.parallel_mode in [ParallelMode.DATA_PARALLEL, ParallelMode.HYBRID_PARALLEL]:
|
||||
... self.reducer_flag = True
|
||||
... if self.reducer_flag:
|
||||
... mean = context.get_auto_parallel_context("gradients_mean")
|
||||
... degree = context.get_auto_parallel_context("device_num")
|
||||
... self.grad_reducer = nn.DistributedGradReducer(optimizer.parameters, mean, degree)
|
||||
...
|
||||
... def construct(self, *args):
|
||||
... weights = self.weights
|
||||
... loss = self.network(*args)
|
||||
... sens = ops.Fill()(ops.DType()(loss), ops.Shape()(loss), self.sens)
|
||||
... grads = self.grad(self.network, weights)(*args, sens)
|
||||
... if self.reducer_flag:
|
||||
... # apply grad reducer on grads
|
||||
... grads = self.grad_reducer(grads)
|
||||
... return ops.Depend(loss, self.optimizer(grads))
|
||||
>>>
|
||||
>>> class Net(nn.Cell):
|
||||
... def __init__(self, in_features, out_features)：
|
||||
... super(Net, self).__init__()
|
||||
... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
|
||||
... name='weight')
|
||||
... self.matmul = ops.MatMul()
|
||||
...
|
||||
... def construct(self, x)：
|
||||
... output = self.matmul(x, self.weight)
|
||||
... return output
|
||||
>>>
|
||||
>>> size, in_features, out_features = 16, 16, 10
|
||||
>>> network = Net(in_features, out_features)
|
||||
>>> loss = nn.MSELoss()
|
||||
>>> net_with_loss = nn.WithLossCell(network, loss)
|
||||
>>> optimizer = nn.Momentum(net_with_loss.trainable_params(), learning_rate=0.1, momentum=0.9)
|
||||
>>> train_cell = TrainingWrapper(net_with_loss, optimizer)
|
||||
>>> inputs = Tensor(np.ones([size, in_features]).astype(np.float32))
|
||||
>>> label = Tensor(np.zeros([size, out_features]).astype(np.float32))
|
||||
>>> grads = train_cell(inputs, label)
|
||||
>>> print(grads)
|
||||
256.0
|
||||
|
||||
.. py:method:: construct(grads)
|
||||
|
||||
某些情况下，梯度的数据精度可以与float16和float32混合。因此，AllReduce的结果不可靠。要解决这个问题，必须在AllReduce之前强制转换为float32，并在操作之后再强制转换为float32。
|
||||
|
||||
**参数：**
|
||||
|
||||
**grads** (Union[Tensor, tuple[Tensor]])：操作前的梯度Tensor或tuple。
|
||||
|
||||
**返回：**
|
||||
|
||||
**new_grads** (Union[Tensor, tuple[Tensor]])，操作后的梯度Tensor或tuple。
|
||||
mindspore.nn.DistributedGradReducer
|
||||
===================================
|
||||
|
||||
.. py:class:: mindspore.nn.DistributedGradReducer(parameters, mean=True, degree=None, fusion_type=1, group='hccl_world_group')
|
||||
|
||||
分布式优化器。
|
||||
|
||||
对反向梯度进行AllReduce运算。
|
||||
|
||||
**参数：**
|
||||
|
||||
- **parameters** (list)：需要更新的参数。
|
||||
- **mean** (bool)：当mean为True时，对AllReduce之后的梯度求均值。默认值：False。
|
||||
- **degree** (int)：平均系数，通常等于设备编号。默认值：None。
|
||||
- **fusion_type** (int)：AllReduce算子的融合类型。默认值：1。
|
||||
|
||||
**异常：**
|
||||
|
||||
**ValueError**：如果degree不是int或小于0。
|
||||
|
||||
**支持平台：**
|
||||
|
||||
``Ascend`` ``GPU``
|
||||
|
||||
**样例：**
|
||||
|
||||
>>> #此示例应与多个进程一起运行。
|
||||
>>> #请参考Mindpore.cn上的“教程>分布式训练”。
|
||||
>>> import numpy as np
|
||||
>>> from mindspore.communication import init
|
||||
>>> from mindspore import ops
|
||||
>>> from mindspore import context
|
||||
>>> from mindspore.context import ParallelMode
|
||||
>>> from mindspore import Parameter, Tensor
|
||||
>>> from mindspore import nn
|
||||
>>>
|
||||
>>> context.set_context(mode=context.GRAPH_MODE)
|
||||
>>> init()
|
||||
>>> context.reset_auto_parallel_context()
|
||||
>>> context.set_auto_parallel_context(parallel_mode=ParallelMode.DATA_PARALLEL)
|
||||
>>>
|
||||
>>> class TrainingWrapper(nn.Cell):
|
||||
... def __init__(self, network, optimizer, sens=1.0):
|
||||
... super(TrainingWrapper, self).__init__(auto_prefix=False)
|
||||
... self.network = network
|
||||
... self.network.add_flags(defer_inline=True)
|
||||
... self.weights = optimizer.parameters
|
||||
... self.optimizer = optimizer
|
||||
... self.grad = ops.GradOperation(get_by_list=True, sens_param=True)
|
||||
... self.sens = sens
|
||||
... self.reducer_flag = False
|
||||
... self.grad_reducer = None
|
||||
... self.parallel_mode = context.get_auto_parallel_context("parallel_mode")
|
||||
... if self.parallel_mode in [ParallelMode.DATA_PARALLEL, ParallelMode.HYBRID_PARALLEL]:
|
||||
... self.reducer_flag = True
|
||||
... if self.reducer_flag:
|
||||
... mean = context.get_auto_parallel_context("gradients_mean")
|
||||
... degree = context.get_auto_parallel_context("device_num")
|
||||
... self.grad_reducer = nn.DistributedGradReducer(optimizer.parameters, mean, degree)
|
||||
...
|
||||
... def construct(self, *args):
|
||||
... weights = self.weights
|
||||
... loss = self.network(*args)
|
||||
... sens = ops.Fill()(ops.DType()(loss), ops.Shape()(loss), self.sens)
|
||||
... grads = self.grad(self.network, weights)(*args, sens)
|
||||
... if self.reducer_flag:
|
||||
... # apply grad reducer on grads
|
||||
... grads = self.grad_reducer(grads)
|
||||
... return ops.Depend(loss, self.optimizer(grads))
|
||||
>>>
|
||||
>>> class Net(nn.Cell):
|
||||
... def __init__(self, in_features, out_features)：
|
||||
... super(Net, self).__init__()
|
||||
... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)),
|
||||
... name='weight')
|
||||
... self.matmul = ops.MatMul()
|
||||
...
|
||||
... def construct(self, x)：
|
||||
... output = self.matmul(x, self.weight)
|
||||
... return output
|
||||
>>>
|
||||
>>> size, in_features, out_features = 16, 16, 10
|
||||
>>> network = Net(in_features, out_features)
|
||||
>>> loss = nn.MSELoss()
|
||||
>>> net_with_loss = nn.WithLossCell(network, loss)
|
||||
>>> optimizer = nn.Momentum(net_with_loss.trainable_params(), learning_rate=0.1, momentum=0.9)
|
||||
>>> train_cell = TrainingWrapper(net_with_loss, optimizer)
|
||||
>>> inputs = Tensor(np.ones([size, in_features]).astype(np.float32))
|
||||
>>> label = Tensor(np.zeros([size, out_features]).astype(np.float32))
|
||||
>>> grads = train_cell(inputs, label)
|
||||
>>> print(grads)
|
||||
256.0
|
||||
|
||||
.. py:method:: construct(grads)
|
||||
|
||||
某些情况下，梯度的数据精度可以与float16和float32混合。因此，AllReduce的结果不可靠。要解决这个问题，必须在AllReduce之前强制转换为float32，并在操作之后再强制转换为float32。
|
||||
|
||||
**参数：**
|
||||
|
||||
**grads** (Union[Tensor, tuple[Tensor]])：操作前的梯度Tensor或tuple。
|
||||
|
||||
**返回：**
|
||||
|
||||
**new_grads** (Union[Tensor, tuple[Tensor]])，操作后的梯度Tensor或tuple。
|
||||
|
||||
|
|
@ -1,17 +1,17 @@
|
|||
.. py:class:: mindspore.nn.PipelineCell(network, micro_size)
|
||||
|
||||
将MiniBatch切分成更细粒度的MicroBatch，用于流水线并行的训练中。
|
||||
|
||||
.. note::
|
||||
micro_size必须大于或等于流水线stage的个数。
|
||||
|
||||
** 参数：**
|
||||
|
||||
- **network** (Cell)：要修饰的目标网络。
|
||||
- **micro_size** (int)：MicroBatch大小。
|
||||
|
||||
**示例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> net = PipelineCell(net, 4)
|
||||
.. py:class:: mindspore.nn.PipelineCell(network, micro_size)
|
||||
|
||||
将MiniBatch切分成更细粒度的MicroBatch，用于流水线并行的训练中。
|
||||
|
||||
.. note::
|
||||
micro_size必须大于或等于流水线stage的个数。
|
||||
|
||||
** 参数：**
|
||||
|
||||
- **network** (Cell)：要修饰的目标网络。
|
||||
- **micro_size** (int)：MicroBatch大小。
|
||||
|
||||
**示例：**
|
||||
|
||||
>>> net = Net()
|
||||
>>> net = PipelineCell(net, 4)
|
||||
|
||||
Loading…
Reference in New Issue