torch.distributed.tensor.parallel.api 的源代码

© Meta Platforms, Inc. 及其关联公司
导入 警告
来自 fnmatch 导入 fnmatch
来自 打字 导入 可选, 联合

导入 火炬
导入 torch.nn 作为 然后
来自 torch.distributed.device_mesh 导入 _网状资源, 设备网格
来自 torch.distributed.tensor.parallel._utils 导入 _validate_tp_mesh_dim
来自 torch.distributed.tensor.parallel.style 导入 并行样式


__all__ = [并行化模块]


def 并行化模块(  # type: ignore[return]
    模块: nn.模块,
    装置网状结构: 可选[设备网状结构] = 无,
    并行化计划: 可选[联盟[并行样式, 字典[字符串, 并行样式]]] = 无,
    *,
    src_data_rank: 可选[int] = 0,
) -> nn.模块:
    ""
通过根据用户指定的计划并行化模块或子模块，在 PyTorch 中应用张量并行性。

我们根据并行化计划 parallelize_plan 并行化模块或 sub_modules。
`:class:`ParallelStyle`，表示用户希望模块或子模块的样式
待并行化。

用户还可以为每个模块的完全限定名（FQN）指定不同的并行样式。

请注意，`parallelize_module` 只接受 1-D :class:`DeviceMesh`，如果您有 2-D 或 N-D :class:`DeviceMesh`，
首先将 DeviceMesh 切片成 1-D 子 DeviceMesh，然后传递给此 API（即`device_mesh["tp"]`）

参数：
模块（:class:`nn.Module`）
待并行化的模块。
device_mesh（:class:`DeviceMesh`，可选）：
描述 DTensor 设备网格拓扑的对象。
如果未指定，调用必须在 DeviceMesh 上下文中进行。
        parallelize_plan (Union[:class:`ParallelStyle`, Dict[str, :class:`ParallelStyle`]], optional):
用于并行化模块的计划。它可以是
包含我们如何准备 :class:`ParallelStyle` 对象的类
输入/输出用于张量并行或它可以是模块的字典
完全限定名及其对应的 :class:`ParallelStyle` 对象。如果没有指定，当前调用将不执行任何操作。
目前，如果没有指定，调用将不执行任何操作。
关键字参数：
src_data_rank (int, 可选): 源数据的排名，对于逻辑/全局张量，它被用于
meth:`distribute_tensor` 来分散/广播碎片/副本到其他排名。默认情况下，
我们在每个 DeviceMesh 维度上使用 ``group_rank=0`` 作为源数据以保持单设备
语义。如果显式传递 ``None``，:meth:`parallelize_module` 将简单地使用其本地数据
尝试通过散点/广播保留单设备语义。默认：0
返回：
一个并行化的 :class:`nn.Module` 对象。

示例::
        >>> # xdoctest: +SKIP("distributed")
>>> 从 torch.distributed.tensor.parallel 导入 parallelize_module, ColwiseParallel
>>> 从 torch.distributed.device_mesh 导入 init_device_mesh
...
>>> # 定义模块。
        >>> m = Model(...)
        >>> tp_mesh = init_device_mesh("cuda", (8,))
        >>> m = parallelize_module(m, tp_mesh, {"w1": ColwiseParallel(), "w2": RowwiseParallel()})
...

.. note:: 对于像 Attention、MLP 层这样的复杂模块架构，我们建议使用组合
将不同的并行样式（即 ``ColwiseParallel`` 和 ``RowwiseParallel``）一起（）
作为并行化计划，以实现所需的分片计算。
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
    火炬._C._log_api_usage_once("torch.distributed.tensor.parallel.parallelize_module")

    设备网状 = 设备网状 或 _网状资源.获取当前网状()
    _validate_tp_mesh_dim(装置网状结构)

    如果 parallelize_plan 是 无:
        warnings.警告(
            "未提供 parallelize_plan 且不支持自动并行"
            目前，所以这个 parallelize_module 调用将不会做任何事情。
        )
        返回 模块

    # 注意：如果尚未初始化，RNG 跟踪器将在 distribute_tensor()调用中初始化。
    # 未被初始化。

    如果 isinstance(parallelize_plan, 并行风格):
        并行化计划.src_data_rank
源数据排名 = src_data_rank
源数据排名
        返回 并行化计划.应用(模块, 装置网状结构)
    elif isinstance(并行化计划, 字典):
        为 模块路径, 并行化风格 在 并行化方案.项目():
            路径分割 = 模块路径.分割(“点”)
            如果 长度(路径分割) == 0:
                提升 ValueError(
                    "期望模块路径非空，但获取到空字符串！"
                )
            while 路径分割:
                原子 = 路径分割.弹出(0)
                匹配的子项 = 过滤(
                    `t[0]` 是子名称
                    lambda t: fnmatch(t[0] 原子),
                    模块.命名子项(),
                )
                将计划应用于所有匹配的子模块
                为 _, 子模块 在 匹配的子项:
                    如果 路径分割:
                        # 我们还没有到达叶子节点，应用字典风格
                        叶子路径 = “点”.加入(
                            路径分割
                        )  原路径后部分
                        并行化模块(
                            子模块,
                            装置网状结构,
                            {叶路径: 并行化风格},
                            src_data_rank=src_data_rank,
                        )
                    否则:
                        否则，直接应用此子模块的样式
                        并行化模块(
                            子模块,
                            装置网状结构,
                            并行化样式,
                            src_data_rank=src_data_rank,
                        )
        返回 模块
    否则:
        提升 类型错误(  # pyre 忽略[7]
            "期望为 Union[ParallelStyle, Dict[str, ParallelStyle]] 类型"
            f"并行化计划，"{类型(parallelize_plan)}找到了！
        )