From 7a962c2b56e1482ced85bcec2c1157b3de764691 Mon Sep 17 00:00:00 2001 From: yingchen Date: Sat, 4 Dec 2021 15:18:50 +0800 Subject: [PATCH] udpate api --- ...pore.context.txt => mindspore.context.rst} | 704 ++++++++---------- ....get_level.txt => mindspore.get_level.rst} | 38 +- ...onfig.txt => mindspore.get_log_config.rst} | 50 +- ...fload.txt => mindspore.nn.AdamOffload.rst} | 186 ++--- ...y.txt => mindspore.nn.AdamWeightDecay.rst} | 183 +++-- ...ndspore.nn.DynamicLossScaleUpdateCell.rst} | 124 +-- ...pore.nn.FTRL.txt => mindspore.nn.FTRL.rst} | 206 ++--- ...mindspore.nn.FixedLossScaleUpdateCell.rst} | 114 +-- .../mindspore.nn.ForwardValueAndGrad.rst} | 116 +-- ...LR.txt => mindspore.nn.InverseDecayLR.rst} | 116 +-- ...pore.nn.LARS.txt => mindspore.nn.LARS.rst} | 114 +-- ...pore.nn.Lamb.txt => mindspore.nn.Lamb.rst} | 187 +++-- ...LazyAdam.txt => mindspore.nn.LazyAdam.rst} | 192 ++--- ...txt => mindspore.nn.NaturalExpDecayLR.rst} | 116 +-- ...txt => mindspore.nn.PolynomialDecayLR.rst} | 122 +-- ...d.txt => mindspore.nn.ProximalAdagrad.rst} | 186 ++--- ...n.RMSProp.txt => mindspore.nn.RMSProp.rst} | 226 +++--- docs/api/api_python/nn/mindspore.nn.SGD.rst | 88 +++ docs/api/api_python/nn/mindspore.nn.SGD.txt | 88 --- ....txt => mindspore.nn.TrainOneStepCell.rst} | 116 +-- ...pore.nn.TrainOneStepWithLossScaleCell.rst} | 256 +++---- ...Cell.txt => mindspore.nn.WithEvalCell.rst} | 72 +- ...Cell.txt => mindspore.nn.WithLossCell.rst} | 104 +-- ...r.txt => mindspore.nn.cosine_decay_lr.rst} | 74 +- ... => mindspore.nn.exponential_decay_lr.rst} | 74 +- ....txt => mindspore.nn.inverse_decay_lr.rst} | 74 +- ... => mindspore.nn.natural_exp_decay_lr.rst} | 74 +- ...=> mindspore.nn.piecewise_constant_lr.rst} | 58 +- ...t => mindspore.nn.polynomial_decay_lr.rst} | 108 +-- ...rmup_lr.txt => mindspore.nn.warmup_lr.rst} | 68 +- ...mindspore.load_distributed_checkpoint.rst} | 42 +- ...> mindspore.nn.DistributedGradReducer.rst} | 208 +++--- ...Cell.txt => mindspore.nn.PipelineCell.rst} | 32 +- 33 files changed, 2229 insertions(+), 2287 deletions(-) rename docs/api/api_python/mindspore/{mindspore.context.txt => mindspore.context.rst} (79%) rename docs/api/api_python/mindspore/{mindspore.get_level.txt => mindspore.get_level.rst} (94%) rename docs/api/api_python/mindspore/{mindspore.get_log_config.txt => mindspore.get_log_config.rst} (96%) rename docs/api/api_python/nn/{mindspore.nn.AdamOffload.txt => mindspore.nn.AdamOffload.rst} (94%) rename docs/api/api_python/nn/{mindspore.nn.AdamWeightDecay.txt => mindspore.nn.AdamWeightDecay.rst} (92%) rename docs/api/api_python/nn/{mindspore.nn.DynamicLossScaleUpdateCell.txt => mindspore.nn.DynamicLossScaleUpdateCell.rst} (96%) rename docs/api/api_python/nn/{mindspore.nn.FTRL.txt => mindspore.nn.FTRL.rst} (96%) rename docs/api/api_python/nn/{mindspore.nn.FixedLossScaleUpdateCell.txt => mindspore.nn.FixedLossScaleUpdateCell.rst} (95%) rename docs/api/api_python/{mindspore.nn/mindspore.nn.ForwardValueAndGrad.txt => nn/mindspore.nn.ForwardValueAndGrad.rst} (97%) rename docs/api/api_python/nn/{mindspore.nn.InverseDecayLR.txt => mindspore.nn.InverseDecayLR.rst} (96%) rename docs/api/api_python/nn/{mindspore.nn.LARS.txt => mindspore.nn.LARS.rst} (77%) rename docs/api/api_python/nn/{mindspore.nn.Lamb.txt => mindspore.nn.Lamb.rst} (80%) rename docs/api/api_python/nn/{mindspore.nn.LazyAdam.txt => mindspore.nn.LazyAdam.rst} (78%) rename docs/api/api_python/nn/{mindspore.nn.NaturalExpDecayLR.txt => mindspore.nn.NaturalExpDecayLR.rst} (96%) rename docs/api/api_python/nn/{mindspore.nn.PolynomialDecayLR.txt => mindspore.nn.PolynomialDecayLR.rst} (97%) rename docs/api/api_python/nn/{mindspore.nn.ProximalAdagrad.txt => mindspore.nn.ProximalAdagrad.rst} (95%) rename docs/api/api_python/nn/{mindspore.nn.RMSProp.txt => mindspore.nn.RMSProp.rst} (95%) create mode 100644 docs/api/api_python/nn/mindspore.nn.SGD.rst delete mode 100644 docs/api/api_python/nn/mindspore.nn.SGD.txt rename docs/api/api_python/nn/{mindspore.nn.TrainOneStepCell.txt => mindspore.nn.TrainOneStepCell.rst} (96%) rename docs/api/api_python/nn/{mindspore.nn.TrainOneStepWithLossScaleCell.txt => mindspore.nn.TrainOneStepWithLossScaleCell.rst} (97%) rename docs/api/api_python/nn/{mindspore.nn.WithEvalCell.txt => mindspore.nn.WithEvalCell.rst} (96%) rename docs/api/api_python/nn/{mindspore.nn.WithLossCell.txt => mindspore.nn.WithLossCell.rst} (95%) rename docs/api/api_python/nn/{mindspore.nn.cosine_decay_lr.txt => mindspore.nn.cosine_decay_lr.rst} (96%) rename docs/api/api_python/nn/{mindspore.nn.exponential_decay_lr.txt => mindspore.nn.exponential_decay_lr.rst} (70%) rename docs/api/api_python/nn/{mindspore.nn.inverse_decay_lr.txt => mindspore.nn.inverse_decay_lr.rst} (97%) rename docs/api/api_python/nn/{mindspore.nn.natural_exp_decay_lr.txt => mindspore.nn.natural_exp_decay_lr.rst} (93%) rename docs/api/api_python/nn/{mindspore.nn.piecewise_constant_lr.txt => mindspore.nn.piecewise_constant_lr.rst} (94%) rename docs/api/api_python/nn/{mindspore.nn.polynomial_decay_lr.txt => mindspore.nn.polynomial_decay_lr.rst} (96%) rename docs/api/api_python/nn/{mindspore.nn.warmup_lr.txt => mindspore.nn.warmup_lr.rst} (96%) rename docs/api/api_python/parallel/{mindspore.load_distributed_checkpoint.txt => mindspore.load_distributed_checkpoint.rst} (98%) rename docs/api/api_python/parallel/{mindspore.nn.DistributedGradReducer.txt => mindspore.nn.DistributedGradReducer.rst} (97%) rename docs/api/api_python/parallel/{mindspore.nn.PipelineCell.txt => mindspore.nn.PipelineCell.rst} (95%) diff --git a/docs/api/api_python/mindspore/mindspore.context.txt b/docs/api/api_python/mindspore/mindspore.context.rst similarity index 79% rename from docs/api/api_python/mindspore/mindspore.context.txt rename to docs/api/api_python/mindspore/mindspore.context.rst index 14039b36417..62a799e4141 100644 --- a/docs/api/api_python/mindspore/mindspore.context.txt +++ b/docs/api/api_python/mindspore/mindspore.context.rst @@ -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的顺序没有区别。（自动选择）。 - - - 有关启用算子调优工具设置的更多信息，请查看 `使能算子调优工具 `_。 - - - **check_bprop** (bool)：表示是否检查反向传播节点，以确保反向传播节点输出的形状(shape)和数据类型与输入参数相同。默认值：False。 - - **max_call_depth** (int)：指定函数调用的最大深度。其值必须为正整数。默认值：1000。当嵌套Cell太深或子图数量太多时，需要设置 `max_call_depth` 参数。如果 `max_call_depth` 的值比以前的大，则应把系统最大堆栈深度设得更大，否则可能会因为系统堆栈溢出而引发 `core dumped` 异常。 - - **enable_sparse** (bool)：表示是否启用稀疏特征。默认值：False。有关稀疏特征和稀疏张量的详细信息，请查看 `稀疏张量 `_。 - - **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的顺序没有区别。（自动选择）。 + + + 有关启用算子调优工具设置的更多信息，请查看 `使能算子调优工具 `_。 + + - **check_bprop** (bool)：表示是否检查反向传播节点，以确保反向传播节点输出的形状(shape)和数据类型与输入参数相同。默认值：False。 + - **max_call_depth** (int)：指定函数调用的最大深度。其值必须为正整数。默认值：1000。当嵌套Cell太深或子图数量太多时，需要设置 `max_call_depth` 参数。如果 `max_call_depth` 的值比以前的大，则应把系统最大堆栈深度设得更大，否则可能会因为系统堆栈溢出而引发 `core dumped` 异常。 + - **enable_sparse** (bool)：表示是否启用稀疏特征。默认值：False。有关稀疏特征和稀疏张量的详细信息，请查看 `稀疏张量 `_。 + - **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() diff --git a/docs/api/api_python/mindspore/mindspore.get_level.txt b/docs/api/api_python/mindspore/mindspore.get_level.rst similarity index 94% rename from docs/api/api_python/mindspore/mindspore.get_level.txt rename to docs/api/api_python/mindspore/mindspore.get_level.rst index 0deb87e3b52..9f291fe5eda 100644 --- a/docs/api/api_python/mindspore/mindspore.get_level.txt +++ b/docs/api/api_python/mindspore/mindspore.get_level.rst @@ -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' \ No newline at end of file diff --git a/docs/api/api_python/mindspore/mindspore.get_log_config.txt b/docs/api/api_python/mindspore/mindspore.get_log_config.rst similarity index 96% rename from docs/api/api_python/mindspore/mindspore.get_log_config.txt rename to docs/api/api_python/mindspore/mindspore.get_log_config.rst index 8383626fdb8..5f3801312ad 100644 --- a/docs/api/api_python/mindspore/mindspore.get_log_config.txt +++ b/docs/api/api_python/mindspore/mindspore.get_log_config.rst @@ -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'} \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.AdamOffload.txt b/docs/api/api_python/nn/mindspore.nn.AdamOffload.rst similarity index 94% rename from docs/api/api_python/nn/mindspore.nn.AdamOffload.txt rename to docs/api/api_python/nn/mindspore.nn.AdamOffload.rst index c3fb837f9d6..43ad26edcc2 100644 --- a/docs/api/api_python/nn/mindspore.nn.AdamOffload.txt +++ b/docs/api/api_python/nn/mindspore.nn.AdamOffload.rst @@ -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 `_。 - - 更新公式如下： - - .. 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 `_。 + + 更新公式如下： + + .. 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) \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.AdamWeightDecay.txt b/docs/api/api_python/nn/mindspore.nn.AdamWeightDecay.rst similarity index 92% rename from docs/api/api_python/nn/mindspore.nn.AdamWeightDecay.txt rename to docs/api/api_python/nn/mindspore.nn.AdamWeightDecay.rst index 32392d3ec83..55604d5555b 100644 --- a/docs/api/api_python/nn/mindspore.nn.AdamWeightDecay.txt +++ b/docs/api/api_python/nn/mindspore.nn.AdamWeightDecay.rst @@ -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) \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.DynamicLossScaleUpdateCell.txt b/docs/api/api_python/nn/mindspore.nn.DynamicLossScaleUpdateCell.rst similarity index 96% rename from docs/api/api_python/nn/mindspore.nn.DynamicLossScaleUpdateCell.txt rename to docs/api/api_python/nn/mindspore.nn.DynamicLossScaleUpdateCell.rst index 01fe341e050..6b9fe89c279 100644 --- a/docs/api/api_python/nn/mindspore.nn.DynamicLossScaleUpdateCell.txt +++ b/docs/api/api_python/nn/mindspore.nn.DynamicLossScaleUpdateCell.rst @@ -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() + + 获取当前梯度放大系数。 \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.FTRL.txt b/docs/api/api_python/nn/mindspore.nn.FTRL.rst similarity index 96% rename from docs/api/api_python/nn/mindspore.nn.FTRL.txt rename to docs/api/api_python/nn/mindspore.nn.FTRL.rst index 3584b0c471b..9d57b410907 100644 --- a/docs/api/api_python/nn/mindspore.nn.FTRL.txt +++ b/docs/api/api_python/nn/mindspore.nn.FTRL.rst @@ -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 `_。工程文档参阅 `Ad Click Prediction: a View from the Trenches `_。 - - - 更新公式如下： - - .. 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 `_。工程文档参阅 `Ad Click Prediction: a View from the Trenches `_。 + + + 更新公式如下： + + .. 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 \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.FixedLossScaleUpdateCell.txt b/docs/api/api_python/nn/mindspore.nn.FixedLossScaleUpdateCell.rst similarity index 95% rename from docs/api/api_python/nn/mindspore.nn.FixedLossScaleUpdateCell.txt rename to docs/api/api_python/nn/mindspore.nn.FixedLossScaleUpdateCell.rst index 8720dd1d722..34ec82c1c8a 100644 --- a/docs/api/api_python/nn/mindspore.nn.FixedLossScaleUpdateCell.txt +++ b/docs/api/api_python/nn/mindspore.nn.FixedLossScaleUpdateCell.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() + + 获取当前梯度放大系数。 \ No newline at end of file diff --git a/docs/api/api_python/mindspore.nn/mindspore.nn.ForwardValueAndGrad.txt b/docs/api/api_python/nn/mindspore.nn.ForwardValueAndGrad.rst similarity index 97% rename from docs/api/api_python/mindspore.nn/mindspore.nn.ForwardValueAndGrad.txt rename to docs/api/api_python/nn/mindspore.nn.ForwardValueAndGrad.rst index e026786402f..04079bcf5b0 100644 --- a/docs/api/api_python/mindspore.nn/mindspore.nn.ForwardValueAndGrad.txt +++ b/docs/api/api_python/nn/mindspore.nn.ForwardValueAndGrad.rst @@ -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]]),))) \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.InverseDecayLR.txt b/docs/api/api_python/nn/mindspore.nn.InverseDecayLR.rst similarity index 96% rename from docs/api/api_python/nn/mindspore.nn.InverseDecayLR.txt rename to docs/api/api_python/nn/mindspore.nn.InverseDecayLR.rst index 4ae48c64d7f..1c4c7075a45 100644 --- a/docs/api/api_python/nn/mindspore.nn.InverseDecayLR.txt +++ b/docs/api/api_python/nn/mindspore.nn.InverseDecayLR.rst @@ -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 \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.LARS.txt b/docs/api/api_python/nn/mindspore.nn.LARS.rst similarity index 77% rename from docs/api/api_python/nn/mindspore.nn.LARS.txt rename to docs/api/api_python/nn/mindspore.nn.LARS.rst index 40198206a3e..d52d19024e4 100644 --- a/docs/api/api_python/nn/mindspore.nn.LARS.txt +++ b/docs/api/api_python/nn/mindspore.nn.LARS.rst @@ -1,58 +1,58 @@ -mindspore.nn.Lamb -================== - -.. py:class:: mindspore.nn.LARS(*args, **kwargs) - - 使用LARSUpdate算子实现LARS算法。 - - LARS算法采用大量的优化技术。详见论文 `LARGE BATCH TRAINING OF CONVOLUTIONAL NETWORKS `_。 - - 更新公式如下： - - .. 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 `_。 + + 更新公式如下： + + .. 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) \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.Lamb.txt b/docs/api/api_python/nn/mindspore.nn.Lamb.rst similarity index 80% rename from docs/api/api_python/nn/mindspore.nn.Lamb.txt rename to docs/api/api_python/nn/mindspore.nn.Lamb.rst index ca540ca9643..69110ce8849 100644 --- a/docs/api/api_python/nn/mindspore.nn.Lamb.txt +++ b/docs/api/api_python/nn/mindspore.nn.Lamb.rst @@ -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 `_。 - - 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 `_。 + + 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) \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.LazyAdam.txt b/docs/api/api_python/nn/mindspore.nn.LazyAdam.rst similarity index 78% rename from docs/api/api_python/nn/mindspore.nn.LazyAdam.txt rename to docs/api/api_python/nn/mindspore.nn.LazyAdam.rst index 8082513da44..394d0b01c3a 100644 --- a/docs/api/api_python/nn/mindspore.nn.LazyAdam.txt +++ b/docs/api/api_python/nn/mindspore.nn.LazyAdam.rst @@ -1,97 +1,97 @@ -mindspore.nn.LazyAdam -====================== - -.. py:class:: mindspore.nn.LazyAdam(*args, **kwargs) - - 通过Adaptive Moment Estimation (Adam)算法更新梯度。请参阅论文 `Adam: A Method for Stochastic Optimization `_。 - - 当梯度稀疏时，此优化器将使用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 `_。 + + 当梯度稀疏时，此优化器将使用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 \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.NaturalExpDecayLR.txt b/docs/api/api_python/nn/mindspore.nn.NaturalExpDecayLR.rst similarity index 96% rename from docs/api/api_python/nn/mindspore.nn.NaturalExpDecayLR.txt rename to docs/api/api_python/nn/mindspore.nn.NaturalExpDecayLR.rst index a01bfc06e32..fb6aeea79d3 100644 --- a/docs/api/api_python/nn/mindspore.nn.NaturalExpDecayLR.txt +++ b/docs/api/api_python/nn/mindspore.nn.NaturalExpDecayLR.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 \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.PolynomialDecayLR.txt b/docs/api/api_python/nn/mindspore.nn.PolynomialDecayLR.rst similarity index 97% rename from docs/api/api_python/nn/mindspore.nn.PolynomialDecayLR.txt rename to docs/api/api_python/nn/mindspore.nn.PolynomialDecayLR.rst index e88ed52a55e..ad14c426f2d 100644 --- a/docs/api/api_python/nn/mindspore.nn.PolynomialDecayLR.txt +++ b/docs/api/api_python/nn/mindspore.nn.PolynomialDecayLR.rst @@ -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 \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.ProximalAdagrad.txt b/docs/api/api_python/nn/mindspore.nn.ProximalAdagrad.rst similarity index 95% rename from docs/api/api_python/nn/mindspore.nn.ProximalAdagrad.txt rename to docs/api/api_python/nn/mindspore.nn.ProximalAdagrad.rst index 543093e6b39..aa9d3e6a4ac 100644 --- a/docs/api/api_python/nn/mindspore.nn.ProximalAdagrad.txt +++ b/docs/api/api_python/nn/mindspore.nn.ProximalAdagrad.rst @@ -1,94 +1,94 @@ -mindspore.nn.ProximalAdagrad -============================== - -.. py:class:: mindspore.nn.ProximalAdagrad(*args, **kwargs) - - 使用ApplyProximalAdagrad算子实现ProximalAdagrad算法。 - - ProximalAdagrad用于在线学习和随机优化。 - 请参阅论文 `Efficient Learning using Forward-Backward Splitting `_。 - - .. 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 `_。 + + .. 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 \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.RMSProp.txt b/docs/api/api_python/nn/mindspore.nn.RMSProp.rst similarity index 95% rename from docs/api/api_python/nn/mindspore.nn.RMSProp.txt rename to docs/api/api_python/nn/mindspore.nn.RMSProp.rst index 511129ff703..3c98b9e393e 100644 --- a/docs/api/api_python/nn/mindspore.nn.RMSProp.txt +++ b/docs/api/api_python/nn/mindspore.nn.RMSProp.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) \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.SGD.rst b/docs/api/api_python/nn/mindspore.nn.SGD.rst new file mode 100644 index 00000000000..3bfc5e16917 --- /dev/null +++ b/docs/api/api_python/nn/mindspore.nn.SGD.rst @@ -0,0 +1,88 @@ +mindspore.nn.SGD +================ + +.. py:class:: mindspore.nn.SGD(*args, **kwargs) + + 实现随机梯度下降。动量可选。 + + SGD相关介绍参见 `SGD `_ 。 + + Nesterov动量公式参见论文 `On the importance of initialization and momentum in deep learning `_ 。 + + .. 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) + \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.SGD.txt b/docs/api/api_python/nn/mindspore.nn.SGD.txt deleted file mode 100644 index 00ef719883f..00000000000 --- a/docs/api/api_python/nn/mindspore.nn.SGD.txt +++ /dev/null @@ -1,88 +0,0 @@ -mindspore.nn.SGD -================ - -.. py:class:: mindspore.nn.SGD(*args, **kwargs) - - 实现随机梯度下降。动量可选。 - - SGD相关介绍参见 `SGD `_ 。 - - Nesterov动量公式参见论文 `On the importance of initialization and momentum in deep learning `_ 。 - - .. 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) - \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.TrainOneStepCell.txt b/docs/api/api_python/nn/mindspore.nn.TrainOneStepCell.rst similarity index 96% rename from docs/api/api_python/nn/mindspore.nn.TrainOneStepCell.txt rename to docs/api/api_python/nn/mindspore.nn.TrainOneStepCell.rst index 5cc54128b3e..756eabd3fd0 100644 --- a/docs/api/api_python/nn/mindspore.nn.TrainOneStepCell.txt +++ b/docs/api/api_python/nn/mindspore.nn.TrainOneStepCell.rst @@ -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) \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.TrainOneStepWithLossScaleCell.txt b/docs/api/api_python/nn/mindspore.nn.TrainOneStepWithLossScaleCell.rst similarity index 97% rename from docs/api/api_python/nn/mindspore.nn.TrainOneStepWithLossScaleCell.txt rename to docs/api/api_python/nn/mindspore.nn.TrainOneStepWithLossScaleCell.rst index 407d142222d..dc7312b9ac9 100644 --- a/docs/api/api_python/nn/mindspore.nn.TrainOneStepWithLossScaleCell.txt +++ b/docs/api/api_python/nn/mindspore.nn.TrainOneStepWithLossScaleCell.rst @@ -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` 的输入相同，用于控制执行序。 \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.WithEvalCell.txt b/docs/api/api_python/nn/mindspore.nn.WithEvalCell.rst similarity index 96% rename from docs/api/api_python/nn/mindspore.nn.WithEvalCell.txt rename to docs/api/api_python/nn/mindspore.nn.WithEvalCell.rst index cb4b60f661e..84073b09e87 100644 --- a/docs/api/api_python/nn/mindspore.nn.WithEvalCell.txt +++ b/docs/api/api_python/nn/mindspore.nn.WithEvalCell.rst @@ -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) diff --git a/docs/api/api_python/nn/mindspore.nn.WithLossCell.txt b/docs/api/api_python/nn/mindspore.nn.WithLossCell.rst similarity index 95% rename from docs/api/api_python/nn/mindspore.nn.WithLossCell.txt rename to docs/api/api_python/nn/mindspore.nn.WithLossCell.rst index 15979b36127..2f35359e605 100644 --- a/docs/api/api_python/nn/mindspore.nn.WithLossCell.txt +++ b/docs/api/api_python/nn/mindspore.nn.WithLossCell.rst @@ -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，骨干网络。 \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.cosine_decay_lr.txt b/docs/api/api_python/nn/mindspore.nn.cosine_decay_lr.rst similarity index 96% rename from docs/api/api_python/nn/mindspore.nn.cosine_decay_lr.txt rename to docs/api/api_python/nn/mindspore.nn.cosine_decay_lr.rst index 499f021797b..a5cb6ce3fc9 100644 --- a/docs/api/api_python/nn/mindspore.nn.cosine_decay_lr.txt +++ b/docs/api/api_python/nn/mindspore.nn.cosine_decay_lr.rst @@ -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] \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.exponential_decay_lr.txt b/docs/api/api_python/nn/mindspore.nn.exponential_decay_lr.rst similarity index 70% rename from docs/api/api_python/nn/mindspore.nn.exponential_decay_lr.txt rename to docs/api/api_python/nn/mindspore.nn.exponential_decay_lr.rst index 80a8db40302..f15fd4e3526 100644 --- a/docs/api/api_python/nn/mindspore.nn.exponential_decay_lr.txt +++ b/docs/api/api_python/nn/mindspore.nn.exponential_decay_lr.rst @@ -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] \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.inverse_decay_lr.txt b/docs/api/api_python/nn/mindspore.nn.inverse_decay_lr.rst similarity index 97% rename from docs/api/api_python/nn/mindspore.nn.inverse_decay_lr.txt rename to docs/api/api_python/nn/mindspore.nn.inverse_decay_lr.rst index 1c1221d3781..1779b45f3e8 100644 --- a/docs/api/api_python/nn/mindspore.nn.inverse_decay_lr.txt +++ b/docs/api/api_python/nn/mindspore.nn.inverse_decay_lr.rst @@ -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] \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.natural_exp_decay_lr.txt b/docs/api/api_python/nn/mindspore.nn.natural_exp_decay_lr.rst similarity index 93% rename from docs/api/api_python/nn/mindspore.nn.natural_exp_decay_lr.txt rename to docs/api/api_python/nn/mindspore.nn.natural_exp_decay_lr.rst index 085e6acf804..f9c7ded9ec0 100644 --- a/docs/api/api_python/nn/mindspore.nn.natural_exp_decay_lr.txt +++ b/docs/api/api_python/nn/mindspore.nn.natural_exp_decay_lr.rst @@ -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] \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.piecewise_constant_lr.txt b/docs/api/api_python/nn/mindspore.nn.piecewise_constant_lr.rst similarity index 94% rename from docs/api/api_python/nn/mindspore.nn.piecewise_constant_lr.txt rename to docs/api/api_python/nn/mindspore.nn.piecewise_constant_lr.rst index b1cb99922fa..df59f6588ce 100644 --- a/docs/api/api_python/nn/mindspore.nn.piecewise_constant_lr.txt +++ b/docs/api/api_python/nn/mindspore.nn.piecewise_constant_lr.rst @@ -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] diff --git a/docs/api/api_python/nn/mindspore.nn.polynomial_decay_lr.txt b/docs/api/api_python/nn/mindspore.nn.polynomial_decay_lr.rst similarity index 96% rename from docs/api/api_python/nn/mindspore.nn.polynomial_decay_lr.txt rename to docs/api/api_python/nn/mindspore.nn.polynomial_decay_lr.rst index 1051b876e78..d89ba4db0b1 100644 --- a/docs/api/api_python/nn/mindspore.nn.polynomial_decay_lr.txt +++ b/docs/api/api_python/nn/mindspore.nn.polynomial_decay_lr.rst @@ -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] \ No newline at end of file diff --git a/docs/api/api_python/nn/mindspore.nn.warmup_lr.txt b/docs/api/api_python/nn/mindspore.nn.warmup_lr.rst similarity index 96% rename from docs/api/api_python/nn/mindspore.nn.warmup_lr.txt rename to docs/api/api_python/nn/mindspore.nn.warmup_lr.rst index 44a48614e24..e43c37f353f 100644 --- a/docs/api/api_python/nn/mindspore.nn.warmup_lr.txt +++ b/docs/api/api_python/nn/mindspore.nn.warmup_lr.rst @@ -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] \ No newline at end of file diff --git a/docs/api/api_python/parallel/mindspore.load_distributed_checkpoint.txt b/docs/api/api_python/parallel/mindspore.load_distributed_checkpoint.rst similarity index 98% rename from docs/api/api_python/parallel/mindspore.load_distributed_checkpoint.txt rename to docs/api/api_python/parallel/mindspore.load_distributed_checkpoint.rst index 902e6c24fae..20a8e97a69d 100644 --- a/docs/api/api_python/parallel/mindspore.load_distributed_checkpoint.txt +++ b/docs/api/api_python/parallel/mindspore.load_distributed_checkpoint.rst @@ -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文件到网络，用于分布式推理。关于分布式推理的细节，请参考：'' 。 - - **参数：** - - - **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文件到网络，用于分布式推理。关于分布式推理的细节，请参考：'' 。 + + **参数：** + + - **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文件到网络。 \ No newline at end of file diff --git a/docs/api/api_python/parallel/mindspore.nn.DistributedGradReducer.txt b/docs/api/api_python/parallel/mindspore.nn.DistributedGradReducer.rst similarity index 97% rename from docs/api/api_python/parallel/mindspore.nn.DistributedGradReducer.txt rename to docs/api/api_python/parallel/mindspore.nn.DistributedGradReducer.rst index 1e9ea063d95..bdfacceabad 100644 --- a/docs/api/api_python/parallel/mindspore.nn.DistributedGradReducer.txt +++ b/docs/api/api_python/parallel/mindspore.nn.DistributedGradReducer.rst @@ -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。 \ No newline at end of file diff --git a/docs/api/api_python/parallel/mindspore.nn.PipelineCell.txt b/docs/api/api_python/parallel/mindspore.nn.PipelineCell.rst similarity index 95% rename from docs/api/api_python/parallel/mindspore.nn.PipelineCell.txt rename to docs/api/api_python/parallel/mindspore.nn.PipelineCell.rst index 824efaec590..7ccbcdaa3cf 100644 --- a/docs/api/api_python/parallel/mindspore.nn.PipelineCell.txt +++ b/docs/api/api_python/parallel/mindspore.nn.PipelineCell.rst @@ -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) \ No newline at end of file