Note
This recipe requires PyTorch 2.3.0 or later.
Note
\u672c\u6559\u7a0b\u9700\u8981 PyTorch 2.3.0 \u6216\u66f4\u9ad8\u7248\u672c\u3002
![](\"file://../../_static/img/thumbnails/tensorboard_scalars.png\")
\n\nThis dashboard shows how the loss and accuracy change with every epoch. \nYou can use it to also track training speed, learning rate, and other \nscalar values. It\u2019s helpful to compare these metrics across different \ntraining runs to improve your model.\n\n\n"
+ "## \u8fd0\u884cTensorBoard\n\n\u901a\u8fc7\u547d\u4ee4\u884c\u5b89\u88c5TensorBoard\u4ee5\u53ef\u89c6\u5316\u60a8\u8bb0\u5f55\u7684\u6570\u636e\n\n```sh\npip install tensorboard\n```\n\u73b0\u5728,\u542f\u52a8TensorBoard,\u6307\u5b9a\u60a8\u4e4b\u524d\u4f7f\u7528\u7684\u6839\u65e5\u5fd7\u76ee\u5f55\u3002\n\u53c2\u6570 ``logdir`` \u6307\u5411TensorBoard\u5c06\u67e5\u627e\u53ef\u663e\u793a\u7684\u4e8b\u4ef6\u6587\u4ef6\u7684\u76ee\u5f55\u3002\nTensorBoard\u5c06\u9012\u5f52\u904d\u5386 ``logdir`` \u6839\u76ee\u5f55\u4e0b\u7684\u76ee\u5f55\u7ed3\u6784,\u5bfb\u627e ``.*tfevents.*`` \u6587\u4ef6\u3002\n\n```sh\ntensorboard --logdir=runs\n```\n\u8f6c\u5230\u5b83\u63d0\u4f9b\u7684URL\u6216 [http://localhost:6006/](http://localhost:6006/)\n\n\n\n\u6b64\u4eea\u8868\u677f\u663e\u793a\u4e86\u635f\u5931\u548c\u51c6\u786e\u7387\u5982\u4f55\u968f\u7740\u6bcf\u4e2aepoch\u800c\u53d8\u5316\u3002\n\u60a8\u53ef\u4ee5\u4f7f\u7528\u5b83\u6765\u8ddf\u8e2a\u8bad\u7ec3\u901f\u5ea6\u3001\u5b66\u4e60\u7387\u548c\u5176\u4ed6\u6807\u91cf\u503c\u3002\n\u6bd4\u8f83\u4e0d\u540c\u8bad\u7ec3\u8fd0\u884c\u7684\u8fd9\u4e9b\u6307\u6807\u6709\u52a9\u4e8e\u6539\u8fdb\u60a8\u7684\u6a21\u578b\u3002\n\n\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "## Learn More\n\n- [torch.utils.tensorboard](https://pytorch.org/docs/stable/tensorboard.html) docs\n- [Visualizing models, data, and training with TensorBoard](https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html) tutorial\n\n\n"
+ "## \u4e86\u89e3\u66f4\u591a\n\n- [torch.utils.tensorboard](https://pytorch.org/docs/stable/tensorboard.html) \u6587\u6863\n- [\u4f7f\u7528TensorBoard\u53ef\u89c6\u5316\u6a21\u578b\u3001\u6570\u636e\u548c\u8bad\u7ec3](https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html) \u6559\u7a0b\n\n\n"
]
}
],
diff --git a/docs/_downloads/db0de66558b1ca13e18495862bf4b024/swap_tensors.py b/docs/_downloads/db0de66558b1ca13e18495862bf4b024/swap_tensors.py
index d3b90c6..d0f3007 100644
--- a/docs/_downloads/db0de66558b1ca13e18495862bf4b024/swap_tensors.py
+++ b/docs/_downloads/db0de66558b1ca13e18495862bf4b024/swap_tensors.py
@@ -1,81 +1,77 @@
"""
-Extension points in ``nn.Module`` for ``load_state_dict`` and tensor subclasses
+在 ``nn.Module`` 中为 ``load_state_dict`` 和张量子类提供扩展点
===============================================================================
-**Author:** `Mikayla Gawarecki Note
Limitations on the approach taken here\n\n\n This recipe provides a quick introduction to the dynamic quantization\n features in PyTorch and the workflow for using it. Our focus is on\n explaining the specific functions used to convert the model. We will\n make a number of significant simplifications in the interest of brevity\n and clarity
Note
\u672c\u793a\u4f8b\u4e2d\u91c7\u7528\u7684\u65b9\u6cd5\u7684\u5c40\u9650\u6027\n\n \u672c\u793a\u4f8b\u63d0\u4f9b\u4e86\u5bf9 PyTorch \u4e2d\u52a8\u6001\u91cf\u5316\u529f\u80fd\u7684\u5feb\u901f\u4ecb\u7ecd,\u4ee5\u53ca\u4f7f\u7528\u5b83\u7684\u5de5\u4f5c\u6d41\u7a0b\u3002\u6211\u4eec\u7684\u91cd\u70b9\u662f\u89e3\u91ca\u7528\u4e8e\u8f6c\u6362\u6a21\u578b\u7684\u7279\u5b9a\u51fd\u6570\u3002\u4e3a\u4e86\u7b80\u6d01\u548c\u6e05\u6670,\u6211\u4eec\u505a\u51fa\u4e86\u4e00\u4e9b\u91cd\u5927\u7b80\u5316,\u5305\u62ec:
Note
This recipe requires PyTorch 2.1.0 or later.
Note
\u672c\u6559\u7a0b\u9700\u8981 PyTorch 2.1.0 \u6216\u66f4\u9ad8\u7248\u672c\u3002
+
.. only:: html
.. image:: /recipes/recipes/images/thumb/sphx_glr_tensorboard_with_pytorch_thumb.png
- :alt: How to use TensorBoard with PyTorch
+ :alt: 如何在PyTorch中使用TensorBoard
:ref:`sphx_glr_recipes_recipes_tensorboard_with_pytorch.py`
.. raw:: html
-
@@ -159,52 +159,52 @@ PyTorch Recipes
.. raw:: html
- How to use TensorBoard with PyTorch
+ 如何在PyTorch中使用TensorBoard
+
.. only:: html
- .. image:: /recipes/recipes/images/thumb/sphx_glr_warmstarting_model_using_parameters_from_a_different_model_thumb.png
- :alt: PyTorch 使用不同模型的参数对模型进行热启动
+ .. image:: /recipes/recipes/images/thumb/sphx_glr_reasoning_about_shapes_thumb.png
+ :alt: 在PyTorch中推理形状
- :ref:`sphx_glr_recipes_recipes_warmstarting_model_using_parameters_from_a_different_model.py`
+ :ref:`sphx_glr_recipes_recipes_reasoning_about_shapes.py`
.. raw:: html
-
.. raw:: html
- PyTorch 使用不同模型的参数对模型进行热启动
+ 在PyTorch中推理形状
+
.. only:: html
- .. image:: /recipes/recipes/images/thumb/sphx_glr_saving_and_loading_a_general_checkpoint_thumb.png
- :alt: PyTorch 保存和加载通用检查点
+ .. image:: /recipes/recipes/images/thumb/sphx_glr_warmstarting_model_using_parameters_from_a_different_model_thumb.png
+ :alt: PyTorch 使用不同模型的参数对模型进行热启动
- :ref:`sphx_glr_recipes_recipes_saving_and_loading_a_general_checkpoint.py`
+ :ref:`sphx_glr_recipes_recipes_warmstarting_model_using_parameters_from_a_different_model.py`
.. raw:: html
-
.. raw:: html
- PyTorch 保存和加载通用检查点
+ PyTorch 使用不同模型的参数对模型进行热启动
+
.. only:: html
- .. image:: /recipes/recipes/images/thumb/sphx_glr_reasoning_about_shapes_thumb.png
- :alt: Reasoning about Shapes in PyTorch
+ .. image:: /recipes/recipes/images/thumb/sphx_glr_saving_and_loading_a_general_checkpoint_thumb.png
+ :alt: PyTorch 保存和加载通用检查点
- :ref:`sphx_glr_recipes_recipes_reasoning_about_shapes.py`
+ :ref:`sphx_glr_recipes_recipes_saving_and_loading_a_general_checkpoint.py`
.. raw:: html
-
@@ -278,103 +278,103 @@ PyTorch Recipes
.. raw:: html
- Reasoning about Shapes in PyTorch
+ PyTorch 保存和加载通用检查点
+
.. only:: html
- .. image:: /recipes/recipes/images/thumb/sphx_glr_module_load_state_dict_tips_thumb.png
- :alt: Tips for Loading an ``nn.Module`` from a Checkpoint
+ .. image:: /recipes/recipes/images/thumb/sphx_glr_timer_quick_start_thumb.png
+ :alt: Timer快速入门
- :ref:`sphx_glr_recipes_recipes_module_load_state_dict_tips.py`
+ :ref:`sphx_glr_recipes_recipes_timer_quick_start.py`
.. raw:: html
-
.. raw:: html
- Tips for Loading an ``nn.Module`` from a Checkpoint
+ Timer快速入门
+
.. only:: html
- .. image:: /recipes/recipes/images/thumb/sphx_glr_timer_quick_start_thumb.png
- :alt: Timer快速入门
+ .. image:: /recipes/recipes/images/thumb/sphx_glr_Captum_Recipe_thumb.png
+ :alt: 使用 Captum 进行模型可解释性
- :ref:`sphx_glr_recipes_recipes_timer_quick_start.py`
+ :ref:`sphx_glr_recipes_recipes_Captum_Recipe.py`
.. raw:: html
-
.. raw:: html
- Timer快速入门
+ 使用 Captum 进行模型可解释性
+
.. only:: html
- .. image:: /recipes/recipes/images/thumb/sphx_glr_zeroing_out_gradients_thumb.png
- :alt: PyTorch 中清零梯度
+ .. image:: /recipes/recipes/images/thumb/sphx_glr_dynamic_quantization_thumb.png
+ :alt: 动态量化
- :ref:`sphx_glr_recipes_recipes_zeroing_out_gradients.py`
+ :ref:`sphx_glr_recipes_recipes_dynamic_quantization.py`
.. raw:: html
-
.. raw:: html
- PyTorch 中清零梯度
+ 动态量化
+
.. only:: html
- .. image:: /recipes/recipes/images/thumb/sphx_glr_dynamic_quantization_thumb.png
- :alt: Dynamic Quantization
+ .. image:: /recipes/recipes/images/thumb/sphx_glr_zeroing_out_gradients_thumb.png
+ :alt: PyTorch 中清零梯度
- :ref:`sphx_glr_recipes_recipes_dynamic_quantization.py`
+ :ref:`sphx_glr_recipes_recipes_zeroing_out_gradients.py`
.. raw:: html
-
.. raw:: html
- Dynamic Quantization
+ PyTorch 中清零梯度
+
.. only:: html
- .. image:: /recipes/recipes/images/thumb/sphx_glr_Captum_Recipe_thumb.png
- :alt: Model Interpretability using Captum
+ .. image:: /recipes/recipes/images/thumb/sphx_glr_module_load_state_dict_tips_thumb.png
+ :alt: 从检查点加载 ``nn.Module`` 的技巧
- :ref:`sphx_glr_recipes_recipes_Captum_Recipe.py`
+ :ref:`sphx_glr_recipes_recipes_module_load_state_dict_tips.py`
.. raw:: html
-
.. raw:: html
- Model Interpretability using Captum
+ 从检查点加载 ``nn.Module`` 的技巧
+
.. only:: html
.. image:: /recipes/recipes/images/thumb/sphx_glr_swap_tensors_thumb.png
- :alt: Extension points in ``nn.Module`` for ``load_state_dict`` and tensor subclasses
+ :alt: 在 ``nn.Module`` 中为 ``load_state_dict`` 和张量子类提供扩展点
:ref:`sphx_glr_recipes_recipes_swap_tensors.py`
.. raw:: html
-
@@ -414,7 +414,7 @@ PyTorch Recipes
.. raw:: html
- Extension points in ``nn.Module`` for ``load_state_dict`` and tensor subclasses
+ 在 ``nn.Module`` 中为 ``load_state_dict`` 和张量子类提供扩展点
+
.. only:: html
@@ -442,18 +442,18 @@ PyTorch Recipes
/recipes/recipes/saving_and_loading_models_for_inference
/recipes/recipes/what_is_state_dict
/recipes/recipes/loading_data_recipe
+ /recipes/recipes/reasoning_about_shapes
/recipes/recipes/warmstarting_model_using_parameters_from_a_different_model
/recipes/recipes/saving_and_loading_a_general_checkpoint
- /recipes/recipes/reasoning_about_shapes
/recipes/recipes/save_load_across_devices
/recipes/recipes/defining_a_neural_network
/recipes/recipes/saving_multiple_models_in_one_file
/recipes/recipes/tuning_guide
- /recipes/recipes/module_load_state_dict_tips
/recipes/recipes/timer_quick_start
- /recipes/recipes/zeroing_out_gradients
- /recipes/recipes/dynamic_quantization
/recipes/recipes/Captum_Recipe
+ /recipes/recipes/dynamic_quantization
+ /recipes/recipes/zeroing_out_gradients
+ /recipes/recipes/module_load_state_dict_tips
/recipes/recipes/swap_tensors
/recipes/recipes/profiler_recipe
/recipes/recipes/amp_recipe
diff --git a/docs/_sources/recipes/recipes/module_load_state_dict_tips.rst.txt b/docs/_sources/recipes/recipes/module_load_state_dict_tips.rst.txt
index ff5df56..4a0970f 100644
--- a/docs/_sources/recipes/recipes/module_load_state_dict_tips.rst.txt
+++ b/docs/_sources/recipes/recipes/module_load_state_dict_tips.rst.txt
@@ -18,31 +18,38 @@
.. _sphx_glr_recipes_recipes_module_load_state_dict_tips.py:
-Tips for Loading an ``nn.Module`` from a Checkpoint
+从检查点加载 ``nn.Module`` 的技巧
===================================================
-**Author:** `Mikayla Gawarecki `_
+**作者:** `Mikayla Gawarecki `_
-If you're loading a checkpoint and want to reduce compute and memory as much as possible,
-this tutorial shares some recommended practices. In particular, we will discuss
+如果你要加载一个检查点并希望尽可能减少计算和内存的使用，本教程将分享一些推荐的做法。特别是我们将讨论以下几点:
-1. The ``mmap`` keyword argument on ``torch.load``
-2. The ``torch.device()`` context manager
-3. The ``assign`` keyword argument on ``nn.Module.load_state_dict()``
+1. ``torch.load`` 中的 ``mmap`` 关键字参数
+2. ``torch.device()`` 上下文管理器
+3. ``nn.Module.load_state_dict()`` 中的 ``assign`` 关键字参数
.. note::
- This recipe requires PyTorch 2.1.0 or later.
+ 本教程需要 PyTorch 2.1.0 或更高版本。
-.. GENERATED FROM PYTHON SOURCE LINES 20-21
+.. GENERATED FROM PYTHON SOURCE LINES 15-18
+
+.. code-block:: default
+
+
+ import time
-Let us consider a simple ``nn.Module`` that contains a list of Linear layers:
-.. GENERATED FROM PYTHON SOURCE LINES 21-37
+.. GENERATED FROM PYTHON SOURCE LINES 19-20
+
+让我们考虑一个简单的 ``nn.Module``，它包含一个线性层列表:
+
+.. GENERATED FROM PYTHON SOURCE LINES 20-36
.. code-block:: default
import torch
from torch import nn
- import time
+
class SomeModule(torch.nn.Module):
def __init__(self, size):
@@ -54,164 +61,152 @@ Let us consider a simple ``nn.Module`` that contains a list of Linear layers:
m = SomeModule(1000)
- torch.save(m.state_dict(), 'checkpoint.pth')
+ torch.save(m.state_dict(), "checkpoint.pth")
-.. GENERATED FROM PYTHON SOURCE LINES 38-41
+.. GENERATED FROM PYTHON SOURCE LINES 37-38
-The following snippet demonstrates the use of the the ``mmap`` keyword argument
-to ``torch.load``, the ``torch.device()`` context manager and the ``assign``
-keyword argument to ``nn.Module.load_state_dict()``.
+以下代码片段演示了如何使用 ``torch.load`` 中的 ``mmap`` 关键字参数、``torch.device()`` 上下文管理器和 ``nn.Module.load_state_dict()`` 中的 ``assign`` 关键字参数。
-.. GENERATED FROM PYTHON SOURCE LINES 41-47
+.. GENERATED FROM PYTHON SOURCE LINES 38-44
.. code-block:: default
- state_dict = torch.load('checkpoint.pth', mmap=True)
- with torch.device('meta'):
- meta_m = SomeModule(1000)
+ state_dict = torch.load("checkpoint.pth", mmap=True)
+ with torch.device("meta"):
+ meta_m = SomeModule(1000)
meta_m.load_state_dict(state_dict, assign=True)
-.. GENERATED FROM PYTHON SOURCE LINES 48-49
+.. GENERATED FROM PYTHON SOURCE LINES 45-46
-Compare the snippet below to the one above:
+将下面的代码片段与上面的进行比较:
-.. GENERATED FROM PYTHON SOURCE LINES 49-54
+.. GENERATED FROM PYTHON SOURCE LINES 46-51
.. code-block:: default
- state_dict = torch.load('checkpoint.pth')
+ state_dict = torch.load("checkpoint.pth")
m = SomeModule(1000)
m.load_state_dict(state_dict)
-.. GENERATED FROM PYTHON SOURCE LINES 55-58
+.. GENERATED FROM PYTHON SOURCE LINES 52-53
-The second example does not use any of the features listed above and will be
-less compute and memory efficient for loading a checkpoint. In the following
-sections, we will discuss each of the features in further detail.
+第二个示例没有使用上面列出的任何特性，因此在加载检查点时计算和内存效率会较低。在下面的部分中，我们将详细讨论每个特性。
-.. GENERATED FROM PYTHON SOURCE LINES 60-72
+.. GENERATED FROM PYTHON SOURCE LINES 55-61
-Using ``torch.load(mmap=True)``
+使用 ``torch.load(mmap=True)``
-------------------------------
-First, let us consider what happens when we load the checkpoint with ``torch.load``.
-When we save a checkpoint with ``torch.save``, tensor storages are tagged with the device they are
-saved on. With ``torch.load``, tensor storages will be loaded to the device
-they were tagged with (unless this behavior is overridden using the
-``map_location`` flag). For ease of explanation, let us assume that the tensors
-were saved on CPU. This means that on the first line all tensor storages will be
-loaded into CPU RAM, which can be undesirable when:
+首先，让我们考虑使用 ``torch.load`` 加载检查点时会发生什么。
+当我们使用 ``torch.save`` 保存检查点时，张量存储会被标记为保存时所在的设备。
+使用 ``torch.load`` 时，张量存储将被加载到它们被标记的设备上(除非使用 ``map_location`` 标志覆盖此行为)。
+为了解释方便，我们假设张量是保存在 CPU 上的。这意味着在第一行中，所有张量存储将被加载到 CPU 内存中，在以下情况下这是不可取的:
-* CPU RAM is smaller than the size of the checkpoint.
-* Waiting for the entire checkpoint to be loaded into RAM before performing, for example, some per-tensor processing.
-
-.. GENERATED FROM PYTHON SOURCE LINES 72-78
+.. GENERATED FROM PYTHON SOURCE LINES 61-70
.. code-block:: default
+ # * CPU 内存小于检查点的大小。
+ # * 在执行一些每张量处理之前等待整个检查点被加载到内存中。
+
start_time = time.time()
- state_dict = torch.load('checkpoint.pth')
+ state_dict = torch.load("checkpoint.pth")
end_time = time.time()
- print(f"loading time without mmap={end_time - start_time}")
+ print(f"不使用 mmap 的加载时间={end_time - start_time}")
-.. GENERATED FROM PYTHON SOURCE LINES 79-85
+.. GENERATED FROM PYTHON SOURCE LINES 71-75
-The ``mmap`` keyword argument to ``torch.load`` attempts to solve the above two
-problems. As its name implies, the ``mmap`` keyword argument to ``torch.load``
-makes use of an `mmap call `_
-which maps a file on disk into virtual memory and lets the OS handle loading and
-unloading into physical memory automatically. When this flag is passed, tensor
-storages will be memory-mapped.
+``torch.load`` 中的 ``mmap`` 关键字参数试图解决上述两个问题。
+顾名思义，``torch.load`` 中的 ``mmap`` 关键字参数使用了 `mmap 调用 `_,
+它将磁盘上的文件映射到虚拟内存中,并让操作系统自动处理加载和卸载到物理内存。
+当传递此标志时,张量存储将被内存映射。
-.. GENERATED FROM PYTHON SOURCE LINES 85-91
+.. GENERATED FROM PYTHON SOURCE LINES 75-82
.. code-block:: default
start_time = time.time()
- state_dict = torch.load('checkpoint.pth', mmap=True)
+ state_dict = torch.load("checkpoint.pth", mmap=True)
end_time = time.time()
- print(f"loading time with mmap={end_time - start_time}")
+ print(f"使用 mmap 的加载时间={end_time - start_time}")
+
-.. GENERATED FROM PYTHON SOURCE LINES 92-94
+.. GENERATED FROM PYTHON SOURCE LINES 83-84
-As mentioned above, one can use this argument to do per-tensor processing on a
-checkpoint without loading all tensor storages into CPU memory upfront. For example:
+如上所述,可以使用此参数在不将所有张量存储加载到 CPU 内存中的情况下对检查点执行每张量处理。例如:
-.. GENERATED FROM PYTHON SOURCE LINES 94-108
+.. GENERATED FROM PYTHON SOURCE LINES 84-100
.. code-block:: default
def my_special_routine(t, device):
- # this could be a much fancier operation
+ # 这可能是一个更复杂的操作
return t.to(dtype=torch.bfloat16, device=device)
+
def my_processing_function(key, device):
t = state_dict[key]
processed_t = my_special_routine(t, device)
del t
state_dict[key] = processed_t
+
for key in state_dict.keys():
- device = torch.device('cuda')
+ device = torch.device("cuda")
my_processing_function(key, device)
-.. GENERATED FROM PYTHON SOURCE LINES 109-112
+.. GENERATED FROM PYTHON SOURCE LINES 101-104
-Using ``torch.device('meta')``
+使用 ``torch.device('meta')``
------------------------------
-Next, let's consider the creation of the module.
+接下来,让我们考虑模块的创建。
-.. GENERATED FROM PYTHON SOURCE LINES 112-114
+.. GENERATED FROM PYTHON SOURCE LINES 104-106
.. code-block:: default
m = SomeModule(1000)
-.. GENERATED FROM PYTHON SOURCE LINES 115-132
+.. GENERATED FROM PYTHON SOURCE LINES 107-109
-This allocates memory for all parameters/buffers and initializes them per
-the default initialization schemes defined in ``SomeModule.__init__()``, which
-is wasteful when we want to load a checkpoint for the following reasons:
+这将为所有参数/缓冲区分配内存并根据 ``SomeModule.__init__()`` 中定义的默认初始化方案对其进行初始化,
+当我们想要加载检查点时,这是浪费的,原因如下:
-* The result of the initialization kernels will be overwritten by ``load_state_dict()`` without ever being used, so
- initialization is wasteful.
-* We are allocating memory for these parameters/buffers in RAM while ``torch.load`` of the saved state dictionary also
- allocates memory in RAM for the parameters/buffers in the checkpoint.
+.. GENERATED FROM PYTHON SOURCE LINES 109-122
-In order to solve these two problems, we can use the ``torch.device()``
-context manager with ``device='meta'`` when we instantiate the ``nn.Module()``.
+.. code-block:: default
-The `torch.device() `_
-context manager makes sure that factory calls will be performed as if they
-were passed the specified ``device`` as an argument. Tensors on ``torch.device('meta')`` do not
-carry data. However, they possess all other metadata a tensor carries such as ``.size()``, ``.stride()``,
-``.requires_grad``, and others.
-.. GENERATED FROM PYTHON SOURCE LINES 132-135
+ # * 初始化内核的结果将被 ``load_state_dict()`` 覆盖而从未被使用,因此初始化是浪费的。
+ # * 我们在 RAM 中为这些参数/缓冲区分配了内存,而 ``torch.load`` 保存的状态字典也在 RAM 中为检查点中的参数/缓冲区分配了内存。
-.. code-block:: default
+ # 为了解决这两个问题,我们可以在实例化 ``nn.Module()`` 时使用 ``device='meta'`` 的 ``torch.device()`` 上下文管理器。
- with torch.device('meta'):
- new_m = SomeModule(1000)
+ # `torch.device() `_
+ # 上下文管理器确保工厂调用将被视为传递了指定的 ``device`` 作为参数。
+ # 在 ``torch.device('meta')`` 上的张量不携带数据。
+ # 但是,它们具有张量所携带的其他元数据,如 ``.size()``, ``.stride()``, ``.requires_grad`` 等。
+ with torch.device("meta"):
+ new_m = SomeModule(1000)
-.. GENERATED FROM PYTHON SOURCE LINES 136-139
+.. GENERATED FROM PYTHON SOURCE LINES 123-126
-Using ``load_state_dict(assign=True)``
+使用 ``load_state_dict(assign=True)``
--------------------------------------
-Next, we consider the loading of the state dictionary.
+接下来,我们考虑加载状态字典。
-.. GENERATED FROM PYTHON SOURCE LINES 139-142
+.. GENERATED FROM PYTHON SOURCE LINES 126-129
.. code-block:: default
@@ -219,45 +214,38 @@ Next, we consider the loading of the state dictionary.
m.load_state_dict(state_dict)
-.. GENERATED FROM PYTHON SOURCE LINES 143-155
+.. GENERATED FROM PYTHON SOURCE LINES 130-132
-``nn.Module.load_state_dict()`` is usually implemented via an in-place
-``param_in_model.copy_(param_in_state_dict)``. This means that the parameter/buffer
-with the corresponding key in the state dictionary is copied into the
-parameter/buffer in the ``nn.Module``.
+``nn.Module.load_state_dict()`` 通常是通过 ``param_in_model.copy_(param_in_state_dict)`` 的就地复制实现的。
+这意味着状态字典中对应键的参数/缓冲区将被复制到 ``nn.Module`` 中的参数/缓冲区。
-However, an in-place copy into a tensor on the ``meta`` device is a no-op.
-In order to avoid this, we can pass the ``assign=True`` keyword argument to
-``load_state_dict()``.
+.. GENERATED FROM PYTHON SOURCE LINES 132-147
-A caveat here is that since optimizers hold a reference to
-``nn.Module.parameters()``, the optimizer must be initialized after the module
-is loaded from state dict if ``assign=True`` is passed.
+.. code-block:: default
-.. GENERATED FROM PYTHON SOURCE LINES 155-165
-.. code-block:: default
+ # 然而,对 ``meta`` 设备上的张量进行就地复制是无操作的。
+ # 为了避免这种情况,我们可以在 ``load_state_dict()`` 中传递 ``assign=True`` 关键字参数。
+ # 这里的一个警告是,由于优化器持有对 ``nn.Module.parameters()`` 的引用,
+ # 如果传递了 ``assign=True``,则必须在从状态字典加载模块后初始化优化器。
- # As of PyTorch 2.3.0, one can use ``torch.__future__.set_swap_module_params_on_conversion`` to
- # avoid this caveat. This `recipe `_
- # provides more details.
+ # 从 PyTorch 2.3.0 开始,可以使用 ``torch.__future__.set_swap_module_params_on_conversion`` 来避免这个警告。
+ # 这个 `教程 `_ 提供了更多细节。
new_m.load_state_dict(state_dict, assign=True)
- # Before 2.3.0, this MUST be done AFTER the load_state_dict with assign.
- # In versions >= 2.3.0, one can consider setting ``torch.__future__.set_swap_module_params_on_conversion``
+ # 在 2.3.0 之前,这一步必须在 load_state_dict 使用 assign 之后完成。
+ # 在版本 >= 2.3.0 中,可以考虑设置 ``torch.__future__.set_swap_module_params_on_conversion``
opt = torch.optim.SGD(new_m.parameters(), lr=1e-3)
-.. GENERATED FROM PYTHON SOURCE LINES 166-173
+.. GENERATED FROM PYTHON SOURCE LINES 148-153
-Conclusion
+结论
-------------
-To recap, in this tutorial we learned about ``torch.load(mmap=True)``, the
-``torch.device()`` context manager with ``device=meta``, and
-``nn.Module.load_state_dict(assign=True)`` as well as how these tools could
-be used to aid when loading a model from a checkpoint.
+总结一下,在本教程中,我们学习了 ``torch.load(mmap=True)``、``device='meta'`` 的 ``torch.device()`` 上下文管理器和 ``nn.Module.load_state_dict(assign=True)``
+以及如何在从检查点加载模型时使用这些工具来提高效率。
.. rst-class:: sphx-glr-timing
diff --git a/docs/_sources/recipes/recipes/reasoning_about_shapes.rst.txt b/docs/_sources/recipes/recipes/reasoning_about_shapes.rst.txt
index e5b67d8..768c242 100644
--- a/docs/_sources/recipes/recipes/reasoning_about_shapes.rst.txt
+++ b/docs/_sources/recipes/recipes/reasoning_about_shapes.rst.txt
@@ -18,29 +18,25 @@
.. _sphx_glr_recipes_recipes_reasoning_about_shapes.py:
-Reasoning about Shapes in PyTorch
+在PyTorch中推理形状
=================================
-When writing models with PyTorch, it is commonly the case that the parameters
-to a given layer depend on the shape of the output of the previous layer. For
-example, the ``in_features`` of an ``nn.Linear`` layer must match the
-``size(-1)`` of the input. For some layers, the shape computation involves
-complex equations, for example convolution operations.
+在使用PyTorch编写模型时,通常会遇到某一层的参数取决于前一层输出的形状的情况。例如,
+``nn.Linear``层的``in_features``必须与输入的``size(-1)``相匹配。对于某些层,形状计算涉及复杂的等式,例如卷积运算。
-One way around this is to run the forward pass with random inputs, but this is
-wasteful in terms of memory and compute.
+一种解决方法是使用随机输入进行前向传播,但这在内存和计算方面是浪费的。
-Instead, we can make use of the ``meta`` device to determine the output shapes
-of a layer without materializing any data.
+相反,我们可以使用``meta``设备来确定层的输出形状,而无需实际化任何数据。
-.. GENERATED FROM PYTHON SOURCE LINES 17-31
+.. GENERATED FROM PYTHON SOURCE LINES 12-27
.. code-block:: default
- import torch
import timeit
+ import torch
+
t = torch.rand(2, 3, 10, 10, device="meta")
conv = torch.nn.Conv2d(3, 5, 2, device="meta")
start = timeit.default_timer()
@@ -48,16 +44,15 @@ of a layer without materializing any data.
end = timeit.default_timer()
print(out)
- print(f"Time taken: {end-start}")
+ print(f"所需时间: {end-start}")
-.. GENERATED FROM PYTHON SOURCE LINES 32-34
+.. GENERATED FROM PYTHON SOURCE LINES 28-29
-Observe that since data is not materialized, passing arbitrarily large
-inputs will not significantly alter the time taken for shape computation.
+观察到,由于没有实际化数据,即使传入任意大的输入,用于形状计算的时间也不会显著改变。
-.. GENERATED FROM PYTHON SOURCE LINES 34-44
+.. GENERATED FROM PYTHON SOURCE LINES 29-39
.. code-block:: default
@@ -68,15 +63,15 @@ inputs will not significantly alter the time taken for shape computation.
end = timeit.default_timer()
print(out)
- print(f"Time taken: {end-start}")
+ print(f"所需时间: {end-start}")
-.. GENERATED FROM PYTHON SOURCE LINES 45-46
+.. GENERATED FROM PYTHON SOURCE LINES 40-41
-Consider an arbitrary network such as the following:
+考虑以下任意网络:
-.. GENERATED FROM PYTHON SOURCE LINES 46-71
+.. GENERATED FROM PYTHON SOURCE LINES 41-66
.. code-block:: default
@@ -98,7 +93,7 @@ Consider an arbitrary network such as the following:
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
- x = torch.flatten(x, 1) # flatten all dimensions except batch
+ x = torch.flatten(x, 1) # 展平除批次维度外的所有维度
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
@@ -106,22 +101,21 @@ Consider an arbitrary network such as the following:
-.. GENERATED FROM PYTHON SOURCE LINES 72-74
+.. GENERATED FROM PYTHON SOURCE LINES 67-68
-We can view the intermediate shapes within an entire network by registering a
-forward hook to each layer that prints the shape of the output.
+我们可以通过为每一层注册一个前向钩子来打印输出的形状,从而查看整个网络中间层的形状。
-.. GENERATED FROM PYTHON SOURCE LINES 74-89
+.. GENERATED FROM PYTHON SOURCE LINES 68-83
.. code-block:: default
+
def fw_hook(module, input, output):
- print(f"Shape of output to {module} is {output.shape}.")
+ print(f"{module}的输出形状为{output.shape}。")
- # Any tensor created within this torch.device context manager will be
- # on the meta device.
+ # 在此torch.device上下文管理器中创建的任何张量都将在meta设备上。
with torch.device("meta"):
net = Net()
inp = torch.randn((1024, 3, 32, 32))
diff --git a/docs/_sources/recipes/recipes/swap_tensors.rst.txt b/docs/_sources/recipes/recipes/swap_tensors.rst.txt
index 64f007f..2d1f324 100644
--- a/docs/_sources/recipes/recipes/swap_tensors.rst.txt
+++ b/docs/_sources/recipes/recipes/swap_tensors.rst.txt
@@ -18,102 +18,98 @@
.. _sphx_glr_recipes_recipes_swap_tensors.py:
-Extension points in ``nn.Module`` for ``load_state_dict`` and tensor subclasses
+在 ``nn.Module`` 中为 ``load_state_dict`` 和张量子类提供扩展点
===============================================================================
-**Author:** `Mikayla Gawarecki `_
+**作者:** `Mikayla Gawarecki `_
-This recipe introduces a new utility function ``torch.utils.swap_tensors``
-as well as two new extension points where it has been integrated in
-``nn.Module``:
+本教程介绍了一个新的实用函数 ``torch.utils.swap_tensors``，
+以及在 ``nn.Module`` 中集成它的两个新扩展点:
-* ``nn.Module.to()`` and related methods
+* ``nn.Module.to()`` 和相关方法
* ``nn.Module.load_state_dict()``
.. note::
- This recipe requires PyTorch 2.3.0 or later.
+ 本教程需要 PyTorch 2.3.0 或更高版本。
-.. GENERATED FROM PYTHON SOURCE LINES 18-22
+.. GENERATED FROM PYTHON SOURCE LINES 17-21
``torch.utils.swap_tensors``
----------------------------
-``torch.utils.swap_tensors`` (hereafter referred to as ``swap_tensors``) is a
-utility function that takes in two Python tensors and swaps them.
+``torch.utils.swap_tensors``(以下简称为 ``swap_tensors``) 是一个
+实用函数,它接受两个 Python 张量并交换它们。
-.. GENERATED FROM PYTHON SOURCE LINES 22-31
+.. GENERATED FROM PYTHON SOURCE LINES 21-31
.. code-block:: default
import torch
import torch.nn as nn
+
t1 = torch.arange(2)
t2 = torch.arange(3)
- print(f"Before swapping, t1: {t1}, t2: {t2}")
+ print(f"交换前, t1: {t1}, t2: {t2}")
torch.utils.swap_tensors(t1, t2)
- print(f"After swapping, t1: {t1}, t2: {t2}")
+ print(f"交换后, t1: {t1}, t2: {t2}")
-.. GENERATED FROM PYTHON SOURCE LINES 32-45
+.. GENERATED FROM PYTHON SOURCE LINES 32-43
-More specifically, ``swap_tensors`` swaps the Python ``__class__``, ``__dict__``
-and ``__slots__`` of the two tensors, as well as their associated ``at::Tensor``.
+更具体地说,``swap_tensors`` 交换了两个张量的 Python ``__class__``、``__dict__``
+和 ``__slots__``,以及它们相关的 ``at::Tensor``。
-Application to ``nn.Module``
+应用于 ``nn.Module``
----------------------------
-This utility is pertinent to ``nn.Module`` when a Python object outside
-of the module holds a reference to parameters of the module. If an ``nn.Module``
-modifies any of its parameters out of place, the object holding references to
-the parameters will not see the change. A classic example of this is the
-optimizer, which holds a reference to the parameters of the ``nn.Module``.
-This leads to a silent correctness issue where the ``optimizer.step()`` will
-run without error but the weights of the ``nn.Module`` will not be updated.
+当 ``nn.Module`` 之外的 Python 对象持有该模块参数的引用时,此实用函数就很有用。
+如果 ``nn.Module`` 就地修改了任何参数,持有这些参数引用的对象将无法看到更改。
+一个典型的例子是优化器,它持有 ``nn.Module`` 参数的引用。
+这会导致一个潜在的正确性问题,即 ``optimizer.step()`` 会无错误运行,
+但 ``nn.Module`` 的权重不会被更新。
-.. GENERATED FROM PYTHON SOURCE LINES 45-54
+.. GENERATED FROM PYTHON SOURCE LINES 43-52
.. code-block:: default
mod = torch.nn.Linear(1, 2, bias=False)
optimizer = torch.optim.SGD(mod.parameters())
- print(f"weight in mod: {mod.weight}")
- print(f"weight in optimizer: {optimizer.param_groups[0]['params']}")
+ print(f"mod 中的权重: {mod.weight}")
+ print(f"优化器中的权重: {optimizer.param_groups[0]['params']}")
mod.weight = torch.nn.Parameter(2 * mod.weight)
- print(f"weight in mod: {mod.weight}")
- print(f"weight in optimizer: {optimizer.param_groups[0]['params']}")
+ print(f"mod 中的权重: {mod.weight}")
+ print(f"优化器中的权重: {optimizer.param_groups[0]['params']}")
-.. GENERATED FROM PYTHON SOURCE LINES 55-77
+.. GENERATED FROM PYTHON SOURCE LINES 53-71
-``nn.Module.to()`` and related methods
+``nn.Module.to()`` 和相关方法
--------------------------------------
-This includes methods that change the device of the module (such as ``nn.Module.cpu()``),
-methods that change the ``dtype`` of the module (such as ``nn.Module.float()``)
-as well as methods that allow the module to be materialized
-(such as ``nn.Module.to_empty()``).
+这包括改变模块设备的方法(如 ``nn.Module.cpu()``)、
+改变模块 ``dtype`` 的方法(如 ``nn.Module.float()``)、
+以及允许模块实例化的方法(如 ``nn.Module.to_empty()``)。
-At first glance, it might be non-intuitive that these methods are able to
-modify the parameters of the module in-place. The existing approach has been
-to use a nasty hack dating back from the first days of PyTorch.
+乍一看,这些方法能够就地修改模块的参数可能看起来不太直观。
+现有的方法是使用一种追溯到 PyTorch 最初几天的丑陋黑客手段。
-Notably, the existing approach does not work in these cases:
+值得注意的是,现有方法在以下情况下无法工作:
-* when using ``__torch_dispatch__`` subclasses
-* when ``param`` and ``new_param`` do not have the same Python ``type()``
-* For tensors with special C++ representations (such as sparse tensors and ``XLA`` tensors)
+* 使用 ``__torch_dispatch__`` 子类
+* ``param`` 和 ``new_param`` 的 Python ``type()`` 不同
+* 对于具有特殊 C++ 表示的张量(如稀疏张量和 ``XLA`` 张量)
-In the following part of this recipe, we will define a toy ``__torch_dispatch__``
-subclass ``MyQuantizedLinearWeight`` that represents quantized linear weights.
-This subclass will be used for illustration purposes throughout the rest of
-the tutorial. For brevity, we omit most of the ``__torch_dispatch__``
-implementation.
+在本教程的下一部分,我们将定义一个玩具 ``__torch_dispatch__`` 子类 ``MyQuantizedLinearWeight``
+来表示量化的线性权重。在本教程的剩余部分,我们将使用这个子类进行说明。
+为简洁起见,我们省略了大部分 ``__torch_dispatch__`` 实现。
-.. GENERATED FROM PYTHON SOURCE LINES 77-110
+.. GENERATED FROM PYTHON SOURCE LINES 71-108
.. code-block:: default
+
aten = torch.ops.aten
+
class MyQuantizedLinearWeight(torch.Tensor):
@staticmethod
def __new__(cls, elem, scale):
@@ -124,7 +120,8 @@ implementation.
layout=elem.layout,
device=elem.device,
strides=elem.stride(),
- storage_offset=elem.storage_offset())
+ storage_offset=elem.storage_offset(),
+ )
def __init__(self, elem: torch.Tensor, scale: float):
self.elem = elem
@@ -138,46 +135,43 @@ implementation.
if func in (aten.detach.default, aten._to_copy.default):
new_elem = func(args[0].elem, *args[1:], **kwargs)
return cls(new_elem, args[0].scale)
- # Implementations for certain ops would be added to ``OP_TABLE``.
- # We omit this for brevity.
+ # 某些操作的实现将添加到 ``OP_TABLE``。
+ # 为简洁起见,我们在此省略。
OP_TABLE = dict()
if func in OP_TABLE:
- return OP_TABLE[func](func, args, kwargs)
- raise NotImplementedError(f"Unsupported function {func}")
+ return OP_TABLE[func](func, args, kwargs)
+ raise NotImplementedError(f"不支持的函数 {func}")
+
-.. GENERATED FROM PYTHON SOURCE LINES 111-115
+.. GENERATED FROM PYTHON SOURCE LINES 109-112
-Let us create an ``nn.Linear`` layer of ``dtype`` ``torch.float32`` where the weight is
-a ``MyQuantizedLinearWeight`` and try to convert it to ``torch.bfloat16``.
-Observe that the weight's ``dtype`` changes as expected. However, the ``dtype``
-of the subclass' payload (``elem``) does not change.
+让我们创建一个 ``dtype`` 为 ``torch.float32`` 的 ``nn.Linear`` 层,
+其权重是 ``MyQuantizedLinearWeight``。然后尝试将其转换为 ``torch.bfloat16``。
+观察到权重的 ``dtype`` 如预期般改变了。但是子类的有效载荷(``elem``)的 ``dtype`` 没有改变。
-.. GENERATED FROM PYTHON SOURCE LINES 115-125
+.. GENERATED FROM PYTHON SOURCE LINES 112-122
.. code-block:: default
m = nn.Linear(3, 5, dtype=torch.float32)
m.weight = torch.nn.Parameter(MyQuantizedLinearWeight(m.weight, 0.5))
- print(f"Before: id(m.weight)={id(m.weight)}, id(m.bias)={id(m.bias)}")
+ print(f"之前: id(m.weight)={id(m.weight)}, id(m.bias)={id(m.bias)}")
m.bfloat16()
- print(f"After: id(m.weight)={id(m.weight)}, id(m.bias)={id(m.bias)}")
+ print(f"之后: id(m.weight)={id(m.weight)}, id(m.bias)={id(m.bias)}")
print(f"m.weight.dtype: {m.weight.dtype}")
print(f"m.weight.elem.dtype: {m.weight.elem.dtype}")
print(f"m.bias.dtype: {m.bias.dtype}")
-.. GENERATED FROM PYTHON SOURCE LINES 126-132
+.. GENERATED FROM PYTHON SOURCE LINES 123-126
-To this end, we introduce a global config
-``torch.__future__.set_swap_module_params_on_conversion`` that will use
-``swap_tensors`` to swap the parameters of the module while preserving
-references in place of ``.data`` setting. When this config is set,
-``swap_tensors`` will be used during the conversion, which ensures that
-the ``dtype`` of the payload is properly converted.
+为此,我们引入了一个全局配置 ``torch.__future__.set_swap_module_params_on_conversion``
+它将使用 ``swap_tensors`` 交换模块的参数,同时保留 ``.data`` 设置中的引用。
+设置此配置后,在转换期间将使用 ``swap_tensors``,从而确保有效载荷的 ``dtype`` 正确转换。
-.. GENERATED FROM PYTHON SOURCE LINES 132-144
+.. GENERATED FROM PYTHON SOURCE LINES 126-138
.. code-block:: default
@@ -185,61 +179,52 @@ the ``dtype`` of the payload is properly converted.
torch.__future__.set_swap_module_params_on_conversion(True)
m = nn.Linear(3, 5, dtype=torch.float32)
m.weight = torch.nn.Parameter(MyQuantizedLinearWeight(m.weight, 0.5))
- print(f"Before: id(m.weight)={id(m.weight)}, id(m.bias)={id(m.bias)}")
+ print(f"之前: id(m.weight)={id(m.weight)}, id(m.bias)={id(m.bias)}")
m.bfloat16()
- print(f"After: id(m.weight)={id(m.weight)}, id(m.bias)={id(m.bias)}")
+ print(f"之后: id(m.weight)={id(m.weight)}, id(m.bias)={id(m.bias)}")
print(f"m.weight.dtype: {m.weight.dtype}")
print(f"m.weight.elem.dtype: {m.weight.elem.dtype}")
print(f"m.bias.dtype: {m.bias.dtype}")
torch.__future__.set_swap_module_params_on_conversion(False)
-.. GENERATED FROM PYTHON SOURCE LINES 145-183
+.. GENERATED FROM PYTHON SOURCE LINES 139-167
``nn.Module.load_state_dict()``
--------------------------------
-Depending on the value of the ``assign`` keyword argument passed
-to ``load_state_dict()``, there are two ways to load the ``state_dict``:
+根据传递给 ``load_state_dict()`` 的 ``assign`` 关键字参数的值,
+有两种方式加载 ``state_dict``：
-* ``assign=False``: preserves the properties of ``module.param`` and only takes the values
- from ``state_dict['param_name']``
-* ``assign=True``: preserves the properties and values of ``state_dict['param_name']``.
+* ``assign=False``: 保留 ``module.param`` 的属性,只从 ``state_dict['param_name']`` 中获取值
+* ``assign=True``: 保留 ``state_dict['param_name']`` 的属性和值。
-Previously, these were implemented with in-place ``copy_`` and ``__setattr__`` respectively.
-With the existing implementation, each approach had its own limitations -- ``assign=False``
-imposes the constraint that the type of the parameter in the ``state_dict`` must
-be the same as the type of the parameter in the module while ``assign=True`` imposes
-the constraint that anything that holds references to the module's parameters must
-be initialized after ``nn.Module.load_state_dict()``.
+之前,这些分别是通过就地 ``copy_`` 和 ``__setattr__`` 实现的。
+在现有实现中,每种方法都有自己的限制 - ``assign=False`` 要求 ``state_dict`` 中的参数类型
+必须与模块中的参数类型相同,而 ``assign=True`` 要求在 ``nn.Module.load_state_dict()`` 之后
+初始化任何持有模块参数引用的对象。
-Now, we address both constraints by adding a ``swap_tensors`` path to ``load_state_dict()``
-and introducing a new extension point ``torch.Tensor.module_load(self, other, assign=False)``.
-When the ``swap_tensors`` path is enabled via the ``__future__`` mentioned above,
-we can use a ``__torch_function__`` handler for ``module_load`` to apply a
-custom transformation to the value in the ``state_dict``. The result of this
-transformation will be swapped with the parameter in the module.
+现在,我们通过在 ``load_state_dict()`` 中添加 ``swap_tensors`` 路径并引入新的扩展点
+``torch.Tensor.module_load(self, other, assign=False)`` 来解决这两个限制。
+当启用上述 ``__future__`` 时,我们可以使用 ``module_load`` 的 ``__torch_function__`` 处理程序
+对 ``state_dict`` 中的值应用自定义转换。转换的结果将与模块中的参数交换。
-In the following example, we will use the ``MyQuantizedLinearWeight`` subclass
-defined above to illustrate how we can use these features to apply a
-custom quantization scheme to the weights of a linear layer when
-loading the ``state_dict``.
+在下面的示例中,我们将使用上面定义的 ``MyQuantizedLinearWeight`` 子类
+来说明如何使用这些功能在加载 ``state_dict`` 时对线性层的权重应用自定义量化方案。
-Recall that the ``__torch_function__`` handler for ``module_load`` will be
-invoked if either ``self`` or ``other`` (in this case ``param`` or
-``state_dict[param_key]``) are ``MyQuantizedLinearWeight`` subclasses.
+回顾一下,如果 ``self`` 或 ``other``(在本例中是 ``param`` 或 ``state_dict[param_key]``)
+是 ``MyQuantizedLinearWeight`` 子类,则会调用 ``module_load`` 的 ``__torch_function__`` 处理程序。
-Assume that we expect the ``state_dict`` to contain plain tensors and the
-module to contain ``MyQuantizedLinearWeight`` parameters where we want the
-tensors in the ``state_dict`` to be transformed into the subclass. Then we
-can define a ``__torch_function__`` handler for ``torch.Tensor.module_load``
-as such:
+假设我们期望 ``state_dict`` 包含普通张量,而模块包含 ``MyQuantizedLinearWeight`` 参数,
+我们希望将 ``state_dict`` 中的张量转换为子类。那么我们可以为 ``torch.Tensor.module_load`` 定义
+一个 ``__torch_function__`` 处理程序,如下所示:
-.. GENERATED FROM PYTHON SOURCE LINES 183-198
+.. GENERATED FROM PYTHON SOURCE LINES 167-184
.. code-block:: default
+
@classmethod
def custom_torch_function(cls, func, types, args=(), kwargs=None):
kwargs = {} if kwargs is None else kwargs
@@ -250,70 +235,67 @@ as such:
return MyQuantizedLinearWeight(src, dest.scale)
else:
with torch._C.DisableTorchFunctionSubclass():
- return func(*args, **kwargs)
+ return func(*args, **kwargs)
+
MyQuantizedLinearWeight.__torch_function__ = custom_torch_function
-.. GENERATED FROM PYTHON SOURCE LINES 199-202
+.. GENERATED FROM PYTHON SOURCE LINES 185-187
-First, let us create a skeleton of a model on the meta device to avoid
-materializing storages. We convert all weights in the modules to
-``MyQuantizedLinearWeight`` subclasses while leaving biases intact.
+首先,让我们在 meta 设备上创建一个模型框架,以避免实例化存储。
+我们将模块中的所有权重转换为 ``MyQuantizedLinearWeight`` 子类,同时保留偏置不变。
-.. GENERATED FROM PYTHON SOURCE LINES 202-214
+.. GENERATED FROM PYTHON SOURCE LINES 187-201
.. code-block:: default
+
def fn(m):
if isinstance(m, nn.Linear):
requires_grad = m.weight.requires_grad
m.weight = torch.nn.Parameter(
- MyQuantizedLinearWeight(m.weight, 0.5), requires_grad=requires_grad
- )
+ MyQuantizedLinearWeight(m.weight, 0.5), requires_grad=requires_grad
+ )
+
with torch.device("meta"):
m = nn.Linear(3, 5)
m.apply(fn)
-.. GENERATED FROM PYTHON SOURCE LINES 215-218
+.. GENERATED FROM PYTHON SOURCE LINES 202-204
-We can then load the ``state_dict``. Observe that we use ``assign=True`` because
-for biases, we want to preserve the properties of the tensor in the ``state_dict``
-(for example, we do not want the bias to be on the ``meta`` device after loading).
+然后我们可以加载 ``state_dict``。注意我们使用 ``assign=True``，因为对于偏置,
+我们希望保留 ``state_dict`` 中张量的属性(例如,我们不希望偏置在加载后位于 ``meta`` 设备上)。
-.. GENERATED FROM PYTHON SOURCE LINES 218-228
+.. GENERATED FROM PYTHON SOURCE LINES 204-214
.. code-block:: default
torch.__future__.set_swap_module_params_on_conversion(True)
- print(f"Before: id(weight)={id(m.weight)}, id(bias)={id(m.bias)}")
- print(f"m.state_dict() before load_state_dict():\n {m.state_dict()}")
+ print(f"之前: id(weight)={id(m.weight)}, id(bias)={id(m.bias)}")
+ print(f"load_state_dict() 之前的 m.state_dict():\n {m.state_dict()}")
state_dict = nn.Linear(3, 5).state_dict()
print(f"state_dict:\n {state_dict}")
m.load_state_dict(state_dict, assign=True)
- print(f"After: id(weight)={id(m.weight)}, id(bias)={id(m.bias)}")
- print(f"m.state_dict() after load_state_dict():\n {m.state_dict()}")
+ print(f"之后: id(weight)={id(m.weight)}, id(bias)={id(m.bias)}")
+ print(f"load_state_dict() 之后的 m.state_dict():\n {m.state_dict()}")
-.. GENERATED FROM PYTHON SOURCE LINES 229-242
+.. GENERATED FROM PYTHON SOURCE LINES 215-224
-The above is a toy example of how we can use the new extension point in
-``nn.Module.load_state_dict()``. One can also imagine alternate scenarios such
-as when we have tensor subclasses in the ``state_dict`` and plain ``nn.Parameters``/
-tensors in the module or when both are tensor subclasses. Based on the use
-case, we can define the ``__torch_function__`` handler for ``module_load``
-to apply the transforms as needed.
+上面是一个如何使用 ``nn.Module.load_state_dict()`` 中的新扩展点的玩具示例。
+我们还可以想象其他场景,例如当 ``state_dict`` 中有张量子类而模块中有普通 ``nn.Parameters``/张量时,
+或者两者都是张量子类时。根据使用场景,我们可以定义 ``module_load`` 的 ``__torch_function__`` 处理程序
+来应用所需的转换。
-Conclusion
+结论
----------
-In this recipe, we learned about ``swap_tensors``, the importance
-of preserving references for parameters in ``nn.Module`` as well as how to
-use the two new extension points that are gated by
-``torch.__future__.set_swap_module_params_on_conversion``.
+在本教程中,我们学习了 ``swap_tensors``、在 ``nn.Module`` 中保留参数引用的重要性,
+以及如何使用由 ``torch.__future__.set_swap_module_params_on_conversion`` 控制的两个新扩展点。
.. rst-class:: sphx-glr-timing
diff --git a/docs/_sources/recipes/recipes/tensorboard_with_pytorch.rst.txt b/docs/_sources/recipes/recipes/tensorboard_with_pytorch.rst.txt
index 441e887..71fd2a2 100644
--- a/docs/_sources/recipes/recipes/tensorboard_with_pytorch.rst.txt
+++ b/docs/_sources/recipes/recipes/tensorboard_with_pytorch.rst.txt
@@ -18,71 +18,70 @@
.. _sphx_glr_recipes_recipes_tensorboard_with_pytorch.py:
-How to use TensorBoard with PyTorch
+如何在PyTorch中使用TensorBoard
===================================
-TensorBoard is a visualization toolkit for machine learning experimentation.
-TensorBoard allows tracking and visualizing metrics such as loss and accuracy,
-visualizing the model graph, viewing histograms, displaying images and much more.
-In this tutorial we are going to cover TensorBoard installation,
-basic usage with PyTorch, and how to visualize data you logged in TensorBoard UI.
+TensorBoard是一个用于机器学习实验的可视化工具包。
+TensorBoard允许跟踪和可视化指标,如损失和准确率,
+可视化模型图,查看直方图,显示图像等。
+在本教程中,我们将介绍TensorBoard的安装、
+在PyTorch中的基本用法,以及如何在TensorBoard UI中可视化您记录的数据。
-Installation
+安装
----------------------
-PyTorch should be installed to log models and metrics into TensorBoard log
-directory. The following command will install PyTorch 1.4+ via
-Anaconda (recommended):
+应安装PyTorch以将模型和指标记录到TensorBoard日志
+目录。以下命令将通过Anaconda(推荐)安装PyTorch 1.4+:
.. code-block:: sh
- $ conda install pytorch torchvision -c pytorch
+ $ conda install pytorch torchvision -c pytorch
-or pip
+或者使用pip:
.. code-block:: sh
$ pip install torch torchvision
-.. GENERATED FROM PYTHON SOURCE LINES 30-36
+.. GENERATED FROM PYTHON SOURCE LINES 29-35
-Using TensorBoard in PyTorch
+在PyTorch中使用TensorBoard
-----------------------------
-Let’s now try using TensorBoard with PyTorch! Before logging anything,
-we need to create a ``SummaryWriter`` instance.
+现在让我们尝试在PyTorch中使用TensorBoard!在记录任何内容之前,
+我们需要创建一个 ``SummaryWriter`` 实例。
-.. GENERATED FROM PYTHON SOURCE LINES 36-41
+.. GENERATED FROM PYTHON SOURCE LINES 35-41
.. code-block:: default
import torch
from torch.utils.tensorboard import SummaryWriter
+
writer = SummaryWriter()
.. GENERATED FROM PYTHON SOURCE LINES 42-44
-Writer will output to ``./runs/`` directory by default.
+写入器默认将输出到 ``./runs/`` 目录。
-.. GENERATED FROM PYTHON SOURCE LINES 47-59
+.. GENERATED FROM PYTHON SOURCE LINES 47-58
-Log scalars
+记录标量
-----------
-In machine learning, it’s important to understand key metrics such as
-loss and how they change during training. Scalar helps to save
-the loss value of each training step, or the accuracy after each epoch.
+在机器学习中,了解关键指标(如损失)及其在训练期间的变化非常重要。
+标量可用于保存每个训练步骤的损失值或每个epoch的准确率。
-To log a scalar value, use
-``add_scalar(tag, scalar_value, global_step=None, walltime=None)``.
-For example, lets create a simple linear regression training, and
-log loss value using ``add_scalar``
+要记录标量值,请使用
+``add_scalar(tag, scalar_value, global_step=None, walltime=None)``。
+例如,让我们创建一个简单的线性回归训练,并
+使用 ``add_scalar`` 记录损失值
-.. GENERATED FROM PYTHON SOURCE LINES 59-80
+.. GENERATED FROM PYTHON SOURCE LINES 58-81
.. code-block:: default
@@ -92,7 +91,8 @@ log loss value using ``add_scalar``
model = torch.nn.Linear(1, 1)
criterion = torch.nn.MSELoss()
- optimizer = torch.optim.SGD(model.parameters(), lr = 0.1)
+ optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
+
def train_model(iter):
for epoch in range(iter):
@@ -102,24 +102,25 @@ log loss value using ``add_scalar``
optimizer.zero_grad()
loss.backward()
optimizer.step()
-
+
+
train_model(10)
writer.flush()
-.. GENERATED FROM PYTHON SOURCE LINES 81-89
+.. GENERATED FROM PYTHON SOURCE LINES 82-90
-Call ``flush()`` method to make sure that all pending events
-have been written to disk.
+调用 ``flush()`` 方法以确保所有待处理事件
+已写入磁盘。
-See `torch.utils.tensorboard tutorials `_
-to find more TensorBoard visualization types you can log.
+请参阅 `torch.utils.tensorboard 教程 `_
+以了解您可以记录的更多TensorBoard可视化类型。
-If you do not need the summary writer anymore, call ``close()`` method.
+如果您不再需要摘要写入器,请调用 ``close()`` 方法。
-.. GENERATED FROM PYTHON SOURCE LINES 89-92
+.. GENERATED FROM PYTHON SOURCE LINES 90-93
.. code-block:: default
@@ -127,45 +128,43 @@ If you do not need the summary writer anymore, call ``close()`` method.
writer.close()
-.. GENERATED FROM PYTHON SOURCE LINES 93-122
+.. GENERATED FROM PYTHON SOURCE LINES 94-121
-Run TensorBoard
+运行TensorBoard
----------------
-Install TensorBoard through the command line to visualize data you logged
+通过命令行安装TensorBoard以可视化您记录的数据
.. code-block:: sh
pip install tensorboard
-Now, start TensorBoard, specifying the root log directory you used above.
-Argument ``logdir`` points to directory where TensorBoard will look to find
-event files that it can display. TensorBoard will recursively walk
-the directory structure rooted at ``logdir``, looking for ``.*tfevents.*`` files.
+现在,启动TensorBoard,指定您之前使用的根日志目录。
+参数 ``logdir`` 指向TensorBoard将查找可显示的事件文件的目录。
+TensorBoard将递归遍历 ``logdir`` 根目录下的目录结构,寻找 ``.*tfevents.*`` 文件。
.. code-block:: sh
tensorboard --logdir=runs
-Go to the URL it provides OR to `http://localhost:6006/ `_ docs
-- `Visualizing models, data, and training with TensorBoard `_ tutorial
+- `torch.utils.tensorboard `_ 文档
+- `使用TensorBoard可视化模型、数据和训练 `_ 教程
diff --git a/docs/_sources/recipes/recipes_index.rst.txt b/docs/_sources/recipes/recipes_index.rst.txt
index b19ac42..0e56f12 100644
--- a/docs/_sources/recipes/recipes_index.rst.txt
+++ b/docs/_sources/recipes/recipes_index.rst.txt
@@ -103,7 +103,7 @@ Recipes are bite-sized, actionable examples of how to use specific PyTorch featu
.. customcarditem::
:header: PyTorch Benchmark
- :card_description: Learn how to use PyTorch's benchmark module to measure and compare the performance of your code
+ :card_description: 学习如何使用 PyTorch Benchmark 模块来测量和比较代码性能
:image: ../_static/img/thumbnails/cropped/profiler.png
:link: ../recipes/recipes/benchmark.html
:tags: Basics
diff --git a/docs/_sources/recipes/torch_compile_backend_ipex.rst.txt b/docs/_sources/recipes/torch_compile_backend_ipex.rst.txt
index 8d38a68..0d8613d 100644
--- a/docs/_sources/recipes/torch_compile_backend_ipex.rst.txt
+++ b/docs/_sources/recipes/torch_compile_backend_ipex.rst.txt
@@ -1,18 +1,17 @@
-Intel® Extension for PyTorch* Backend
+Intel® PyTorch* 扩展后端
=====================================
-To work better with `torch.compile`, Intel® Extension for PyTorch* implements a backend ``ipex``.
-It targets to improve hardware resource usage efficiency on Intel platforms for better performance.
-The `ipex` backend is implemented with further customizations designed in Intel® Extension for
-PyTorch* for the model compilation.
+为了更好地与 `torch.compile` 协作，Intel® PyTorch* 扩展实现了一个名为 `ipex` 的后端。
+它旨在提高 Intel 平台上的硬件资源使用效率,从而获得更好的性能。
+`ipex` 后端是通过 Intel® PyTorch* 扩展中进一步的定制设计来实现模型编译的。
-Usage Example
+使用示例
~~~~~~~~~~~~~
-Train FP32
+FP32 训练
----------
-Check the example below to learn how to utilize the `ipex` backend with `torch.compile` for model training with FP32 data type.
+查看下面的示例,了解如何将 `ipex` 后端与 `torch.compile` 一起使用,进行 FP32 数据类型的模型训练。
.. code:: python
@@ -44,10 +43,10 @@ Check the example below to learn how to utilize the `ipex` backend with `torch.c
optimizer = torch.optim.SGD(model.parameters(), lr = LR, momentum=0.9)
model.train()
- #################### code changes ####################
+ #################### 代码修改 ####################
import intel_extension_for_pytorch as ipex
- # Invoke the following API optionally, to apply frontend optimizations
+ # 可选择调用以下 API,应用前端优化
model, optimizer = ipex.optimize(model, optimizer=optimizer)
compile_model = torch.compile(model, backend="ipex")
@@ -61,10 +60,10 @@ Check the example below to learn how to utilize the `ipex` backend with `torch.c
optimizer.step()
-Train BF16
+BF16 训练
----------
-Check the example below to learn how to utilize the `ipex` backend with `torch.compile` for model training with BFloat16 data type.
+查看下面的示例,了解如何将 `ipex` 后端与 `torch.compile` 一起使用,进行 BFloat16 数据类型的模型训练。
.. code:: python
@@ -96,10 +95,10 @@ Check the example below to learn how to utilize the `ipex` backend with `torch.c
optimizer = torch.optim.SGD(model.parameters(), lr = LR, momentum=0.9)
model.train()
- #################### code changes ####################
+ #################### 代码修改 ####################
import intel_extension_for_pytorch as ipex
- # Invoke the following API optionally, to apply frontend optimizations
+ # 可选择调用以下 API,应用前端优化
model, optimizer = ipex.optimize(model, dtype=torch.bfloat16, optimizer=optimizer)
compile_model = torch.compile(model, backend="ipex")
@@ -114,10 +113,10 @@ Check the example below to learn how to utilize the `ipex` backend with `torch.c
optimizer.step()
-Inference FP32
+FP32 推理
--------------
-Check the example below to learn how to utilize the `ipex` backend with `torch.compile` for model inference with FP32 data type.
+查看下面的示例,了解如何将 `ipex` 后端与 `torch.compile` 一起使用,进行 FP32 数据类型的模型推理。
.. code:: python
@@ -128,10 +127,10 @@ Check the example below to learn how to utilize the `ipex` backend with `torch.c
model.eval()
data = torch.rand(1, 3, 224, 224)
- #################### code changes ####################
+ #################### 代码修改 ####################
import intel_extension_for_pytorch as ipex
- # Invoke the following API optionally, to apply frontend optimizations
+ # 可选择调用以下 API,应用前端优化
model = ipex.optimize(model, weights_prepack=False)
compile_model = torch.compile(model, backend="ipex")
@@ -141,10 +140,10 @@ Check the example below to learn how to utilize the `ipex` backend with `torch.c
compile_model(data)
-Inference BF16
+BF16 推理
--------------
-Check the example below to learn how to utilize the `ipex` backend with `torch.compile` for model inference with BFloat16 data type.
+查看下面的示例,了解如何将 `ipex` 后端与 `torch.compile` 一起使用,进行 BFloat16 数据类型的模型推理。
.. code:: python
@@ -155,10 +154,10 @@ Check the example below to learn how to utilize the `ipex` backend with `torch.c
model.eval()
data = torch.rand(1, 3, 224, 224)
- #################### code changes ####################
+ #################### 代码修改 ####################
import intel_extension_for_pytorch as ipex
- # Invoke the following API optionally, to apply frontend optimizations
+ # 可选择调用以下 API,应用前端优化
model = ipex.optimize(model, dtype=torch.bfloat16, weights_prepack=False)
compile_model = torch.compile(model, backend="ipex")
diff --git a/docs/_sources/recipes/torch_logs.rst.txt b/docs/_sources/recipes/torch_logs.rst.txt
index c182145..a568748 100644
--- a/docs/_sources/recipes/torch_logs.rst.txt
+++ b/docs/_sources/recipes/torch_logs.rst.txt
@@ -18,9 +18,9 @@
.. _sphx_glr_recipes_torch_logs.py:
-(beta) Using TORCH_LOGS python API with torch.compile
+(Beta) 使用 TORCH_LOGS python API 与 torch.compile
==========================================================================================
-**Author:** `Michael Lazos `_
+**作者:** `Michael Lazos `_
.. GENERATED FROM PYTHON SOURCE LINES 6-9
@@ -30,101 +30,91 @@
import logging
-.. GENERATED FROM PYTHON SOURCE LINES 10-18
+.. GENERATED FROM PYTHON SOURCE LINES 10-17
-This tutorial introduces the ``TORCH_LOGS`` environment variable, as well as the Python API, and
-demonstrates how to apply it to observe the phases of ``torch.compile``.
+本教程介绍了 ``TORCH_LOGS`` 环境变量以及 Python API,并演示了如何将其应用于观察 ``torch.compile`` 的各个阶段。
.. note::
- This tutorial requires PyTorch 2.2.0 or later.
+ 本教程需要 PyTorch 2.2.0 或更高版本。
-.. GENERATED FROM PYTHON SOURCE LINES 22-32
+.. GENERATED FROM PYTHON SOURCE LINES 21-28
-Setup
+设置
~~~~~~~~~~~~~~~~~~~~~
-In this example, we'll set up a simple Python function which performs an elementwise
-add and observe the compilation process with ``TORCH_LOGS`` Python API.
+在这个例子中,我们将设置一个简单的 Python 函数,执行元素级加法,并使用 ``TORCH_LOGS`` Python API 观察编译过程。
.. note::
- There is also an environment variable ``TORCH_LOGS``, which can be used to
- change logging settings at the command line. The equivalent environment
- variable setting is shown for each example.
+ 还有一个环境变量 ``TORCH_LOGS``,可用于在命令行中更改日志设置。每个示例都显示了等效的环境变量设置。
-.. GENERATED FROM PYTHON SOURCE LINES 32-81
+.. GENERATED FROM PYTHON SOURCE LINES 28-74
.. code-block:: default
import torch
- # exit cleanly if we are on a device that doesn't support torch.compile
+ # 如果设备不支持 torch.compile,则干净地退出
if torch.cuda.get_device_capability() < (7, 0):
- print("Skipping because torch.compile is not supported on this device.")
+ print("跳过,因为此设备不支持 torch.compile。")
else:
+
@torch.compile()
def fn(x, y):
z = x + y
return z + 2
-
inputs = (torch.ones(2, 2, device="cuda"), torch.zeros(2, 2, device="cuda"))
-
- # print separator and reset dynamo
- # between each example
+ # 在每个示例之间打印分隔符并重置 dynamo
def separator(name):
print(f"==================={name}=========================")
torch._dynamo.reset()
-
- separator("Dynamo Tracing")
- # View dynamo tracing
- # TORCH_LOGS="+dynamo"
+ separator("Dynamo 跟踪")
+ # 查看 dynamo 跟踪
+ # TORCH_LOGS="+dynamo"
torch._logging.set_logs(dynamo=logging.DEBUG)
fn(*inputs)
- separator("Traced Graph")
- # View traced graph
- # TORCH_LOGS="graph"
+ separator("跟踪的图形")
+ # 查看跟踪的图形
+ # TORCH_LOGS="graph"
torch._logging.set_logs(graph=True)
fn(*inputs)
- separator("Fusion Decisions")
- # View fusion decisions
- # TORCH_LOGS="fusion"
+ separator("融合决策")
+ # 查看融合决策
+ # TORCH_LOGS="fusion"
torch._logging.set_logs(fusion=True)
fn(*inputs)
- separator("Output Code")
- # View output code generated by inductor
- # TORCH_LOGS="output_code"
+ separator("输出代码")
+ # 查看 inductor 生成的输出代码
+ # TORCH_LOGS="output_code"
torch._logging.set_logs(output_code=True)
fn(*inputs)
separator("")
-.. GENERATED FROM PYTHON SOURCE LINES 82-97
+.. GENERATED FROM PYTHON SOURCE LINES 75-87
-Conclusion
+结论
~~~~~~~~~~
-In this tutorial we introduced the TORCH_LOGS environment variable and python API
-by experimenting with a small number of the available logging options.
-To view descriptions of all available options, run any python script
-which imports torch and set TORCH_LOGS to "help".
+在本教程中,我们介绍了 TORCH_LOGS 环境变量和 python API,并通过实验了一小部分可用的日志选项。
+要查看所有可用选项的描述,请运行任何导入 torch 的 python 脚本,并将 TORCH_LOGS 设置为 "help"。
-Alternatively, you can view the `torch._logging documentation`_ to see
-descriptions of all available logging options.
+或者,您可以查看 `torch._logging 文档`_ 以查看所有可用日志选项的描述。
-For more information on torch.compile, see the `torch.compile tutorial`_.
+有关 torch.compile 的更多信息,请参阅 `torch.compile 教程`_。
-.. _torch._logging documentation: https://pytorch.org/docs/main/logging.html
-.. _torch.compile tutorial: https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html
+.. _torch._logging 文档: https://pytorch.org/docs/main/logging.html
+.. _torch.compile 教程: https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html
.. rst-class:: sphx-glr-timing
diff --git a/docs/_sources/recipes/torchscript_inference.rst.txt b/docs/_sources/recipes/torchscript_inference.rst.txt
index 2f904e4..50e18e3 100644
--- a/docs/_sources/recipes/torchscript_inference.rst.txt
+++ b/docs/_sources/recipes/torchscript_inference.rst.txt
@@ -1,13 +1,16 @@
-TorchScript for Deployment
+TorchScript 部署
==========================
-In this recipe, you will learn:
+在本教程中,您将学习:
- What TorchScript is
- How to export your trained model in TorchScript format
- How to load your TorchScript model in C++ and do inference
+- TorchScript 是什么
+- 如何将训练好的模型导出为 TorchScript 格式
+- 如何在 C++ 中加载 TorchScript 模型并进行推理
-Requirements
+环境要求
------------
- PyTorch 1.5
@@ -15,31 +18,25 @@ Requirements
- libtorch 1.5
- C++ compiler
-The instructions for installing the three PyTorch components are
-available at `pytorch.org`_. The C++ compiler will depend on your
-platform.
+安装这三个 PyTorch 组件的说明可在 `pytorch.org_` 上找到。C++ 编译器则取决于您的平台。
-What is TorchScript?
+
+
+什么是 TorchScript?
--------------------
-**TorchScript** is an intermediate representation of a PyTorch model
-(subclass of ``nn.Module``) that can then be run in a high-performance
-environment like C++. It’s a high-performance subset of Python that is
-meant to be consumed by the **PyTorch JIT Compiler,** which performs
-run-time optimization on your model’s computation. TorchScript is the
-recommended model format for doing scaled inference with PyTorch models.
-For more information, see the PyTorch `Introduction to TorchScript
-tutorial`_, the `Loading A TorchScript Model in C++ tutorial`_, and the
-`full TorchScript documentation`_, all of which are available on
-`pytorch.org`_.
-
-How to Export Your Model
+**TorchScript** 是 PyTorch 模型( ``nn.Module`` 的子类)的中间表示,可以在高性能环境(如 C++)中运行。
+它是 Python 的一个高性能子集,旨在被 **PyTorch JIT 编译器** 使用,后者会对模型的计算进行运行时优化。
+TorchScript 是使用 PyTorch 模型进行大规模推理的推荐模型格式。更多信息,
+请参阅 `pytorch.org_` 上的 `PyTorch TorchScript 入门教程`、 `在 C++ 中加载 TorchScript 模型教程`
+和 `完整的 TorchScript 文档_` 。
+
+如何导出模型
------------------------
-As an example, let’s take a pretrained vision model. All of the
-pretrained models in TorchVision are compatible with TorchScript.
+作为示例,让我们使用一个预训练的视觉模型。TorchVision 中的所有预训练模型都与 TorchScript 兼容。
-Run the following Python 3 code, either in a script or from the REPL:
+运行以下 Python 3 代码,可以在脚本中或从 REPL 中运行:
.. code:: python3
@@ -47,9 +44,9 @@ Run the following Python 3 code, either in a script or from the REPL:
import torch.nn.functional as F
import torchvision.models as models
- r18 = models.resnet18(pretrained=True) # We now have an instance of the pretrained model
- r18_scripted = torch.jit.script(r18) # *** This is the TorchScript export
- dummy_input = torch.rand(1, 3, 224, 224) # We should run a quick test
+ r18 = models.resnet18(pretrained=True) # 现在我们有一个预训练模型的实例
+ r18_scripted = torch.jit.script(r18) # *** 这是 TorchScript 导出
+ dummy_input = torch.rand(1, 3, 224, 224) # 快速测试一下
Let’s do a sanity check on the equivalence of the two models:
diff --git a/docs/objects.inv b/docs/objects.inv
index d7a2820..3f43671 100644
Binary files a/docs/objects.inv and b/docs/objects.inv differ
diff --git a/docs/recipes/compiling_optimizer.html b/docs/recipes/compiling_optimizer.html
index 7829c9a..b50721b 100644
--- a/docs/recipes/compiling_optimizer.html
+++ b/docs/recipes/compiling_optimizer.html
@@ -42,7 +42,7 @@
-
+