From 23cc7d94294f9b26a3ecd9171f9960bc9c069bb1 Mon Sep 17 00:00:00 2001
From: iLeGend <824040212@qq.com>
Date: Wed, 4 Feb 2026 08:42:54 -0800
Subject: [PATCH 01/13] add  param for MaxPool*D/max_pool*d

---
 docs/api/paddle/nn/MaxPool1D_cn.rst             | 1 +
 docs/api/paddle/nn/MaxPool2D_cn.rst             | 1 +
 docs/api/paddle/nn/MaxPool3D_cn.rst             | 3 ++-
 docs/api/paddle/nn/functional/max_pool1d_cn.rst | 1 +
 docs/api/paddle/nn/functional/max_pool2d_cn.rst | 1 +
 docs/api/paddle/nn/functional/max_pool3d_cn.rst | 1 +
 6 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/docs/api/paddle/nn/MaxPool1D_cn.rst b/docs/api/paddle/nn/MaxPool1D_cn.rst
index f1d498e66bf..64d60111ff8 100755
--- a/docs/api/paddle/nn/MaxPool1D_cn.rst
+++ b/docs/api/paddle/nn/MaxPool1D_cn.rst
@@ -18,6 +18,7 @@ MaxPool1D
     - **kernel_size** (int|list|tuple) - 池化核的尺寸大小。如果 kernel_size 为 list 或 tuple 类型，其必须包含一个整数，最终池化核的大小为该数值。
     - **stride** (int|list|tuple，可选) - 池化操作步长。如果 stride 为 list 或 tuple 类型，其必须包含一个整数，最终池化操作的步长为该数值。默认值为 None，这时会使用 kernel_size 作为 stride。
     - **padding** (str|int|list|tuple，可选) - 池化补零的方式。如果 padding 是一个字符串，则必须为 `SAME` 或者 `VALID`。如果是 tuple 或者 list 类型，若其长度为 1，则会在输入的两端都填充上长度为 padding[0] 的 0，若其长度为 2，则应是 `[pad_before, pad_after]` 形式。如果 padding 是一个非 0 整数，那么表示会在输入的两端都填充上同样长度的 0。如果 padding 是长度为 2 的序列组成的 list 或 tuple，则其中的每个元素表示在相应维度上的填充长度。注意：在 batch_size 维度和通道维度应该设置为 [0, 0] 或 (0, 0)。默认值为 0。
+    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含一个整数。默认值为 1。
     - **return_mask** (bool，可选) - 是否返回最大值的索引，默认为 False。
     - **ceil_mode** (bool，可选) - 是否用 ceil 函数计算输出的 height 和 width，如果设置为 False，则使用 floor 函数来计算，默认为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
diff --git a/docs/api/paddle/nn/MaxPool2D_cn.rst b/docs/api/paddle/nn/MaxPool2D_cn.rst
index 61d57d8b87f..02e3186cd31 100644
--- a/docs/api/paddle/nn/MaxPool2D_cn.rst
+++ b/docs/api/paddle/nn/MaxPool2D_cn.rst
@@ -27,6 +27,7 @@ MaxPool2D
     - **kernel_size** (int|list|tuple) - 池化核大小。如果它是一个元组或列表，它必须包含两个整数值，(pool_size_Height, pool_size_Width)。若为一个整数，则它的平方值将作为池化核大小，比如若 pool_size=2，则池化核大小为 2x2。
     - **stride** (int|list|tuple，可选) - 池化层的步长。如果它是一个元组或列表，它将包含两个整数，(pool_stride_Height, pool_stride_Width)。若为一个整数，则表示 H 和 W 维度上 stride 均为该值。默认值为 None，这时会使用 kernel_size 作为 stride。
     - **padding** (str|int|list|tuple，可选) - 池化填充。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 2 个整数值：[pad_height, pad_width]；(2)包含 4 个整数值：[pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；(3)包含 4 个二元组：当 data_format 为"NCHW"时为 [[0,0], [0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当 data_format 为"NHWC"时为[[0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]。若为一个整数，则表示 H 和 W 维度上均为该值。默认值：0。
+    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含两个整数：[dilation_height, dilation_width]。若为一个整数，则表示 H 和 W 维度上均为该值。默认值：1。
     - **ceil_mode** (bool，可选) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。
     - **return_mask** (bool，可选) - 是否返回最大索引和输出。默认为 False。
     - **data_format** (str，可选) - 输入和输出的数据格式，可以是"NCHW"和"NHWC"。N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。默认值："NCHW"。
diff --git a/docs/api/paddle/nn/MaxPool3D_cn.rst b/docs/api/paddle/nn/MaxPool3D_cn.rst
index 822d2858ead..4ac67e8f67f 100644
--- a/docs/api/paddle/nn/MaxPool3D_cn.rst
+++ b/docs/api/paddle/nn/MaxPool3D_cn.rst
@@ -24,7 +24,8 @@ MaxPool3D
 :::::::::
     - **kernel_size** (int|list|tuple) - 池化核大小。如果它是一个元组或列表，它必须包含三个整数值，(pool_size_Depth，pool_size_Height, pool_size_Width)。若为一个整数，则表示 D，H 和 W 维度上均为该值，比如若 pool_size=2，则池化核大小为[2,2,2]。
     - **stride** (int|list|tuple，可选) - 池化层的步长。如果它是一个元组或列表，它将包含三个整数，(pool_stride_Depth，pool_stride_Height, pool_stride_Width)。若为一个整数，则表示 D, H 和 W 维度上 stride 均为该值。默认值为 None，这时会使用 kernel_size 作为 stride。
-    - **padding** (str|int|list|tuple，可选) - 池化填充。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 3 个整数值：[pad_depth, pad_height, pad_width]；(2)包含 6 个整数值：[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；(3)包含 5 个二元组：当 data_format 为"NCDHW"时为[[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当 data_format 为"NDHWC"时为[[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：0
+    - **padding** (str|int|list|tuple，可选) - 池化填充。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 3 个整数值：[pad_depth, pad_height, pad_width]；(2)包含 6 个整数值：[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；(3)包含 5 个二元组：当 data_format 为"NCDHW"时为[[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当 data_format 为"NDHWC"时为[[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：0。
+    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含 3 个整数：[dilation_depth, dilation_height, dilation_width]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：1。
     - **ceil_mode** (bool，可选) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 False。
     - **return_mask** (bool，可选) - 是否返回最大索引和输出。默认为 False。
     - **data_format** (str，可选) - 输入和输出的数据格式，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值："NDCHW"。
diff --git a/docs/api/paddle/nn/functional/max_pool1d_cn.rst b/docs/api/paddle/nn/functional/max_pool1d_cn.rst
index 24cee7e1e19..3be6919c10a 100755
--- a/docs/api/paddle/nn/functional/max_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool1d_cn.rst
@@ -18,6 +18,7 @@ max_pool1d
     - **kernel_size** (int|list|tuple) - 池化核的尺寸大小。如果 kernel_size 为 list 或 tuple 类型，其必须包含一个整数。
     - **stride** (int|list|tuple) - 池化操作步长。如果 stride 为 list 或 tuple 类型，其必须包含一个整数。
     - **padding** (string|int|list|tuple) - 池化补零的方式。如果 padding 是一个字符串，则必须为 `SAME` 或者 `VALID`。如果是 turple 或者 list 类型，则应是 `[pad_left, pad_right]` 形式。如果 padding 是一个非 0 值，那么表示会在输入的两端都 padding 上同样长度的 0。
+    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含一个整数。默认值为 1。
     - **return_mask** (bool) - 是否返回最大值的索引，默认为 False。
     - **ceil_mode** (bool) - 是否用 ceil 函数计算输出的 height 和 width，如果设置为 False，则使用 floor 函数来计算，默认为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
diff --git a/docs/api/paddle/nn/functional/max_pool2d_cn.rst b/docs/api/paddle/nn/functional/max_pool2d_cn.rst
index cbaf6d13e17..40b77c2f469 100644
--- a/docs/api/paddle/nn/functional/max_pool2d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool2d_cn.rst
@@ -28,6 +28,7 @@ max_pool2d
     - **kernel_size** (int|list|tuple) - 池化核大小。如果它是一个元组或列表，它必须包含两个整数值，(pool_size_Height, pool_size_Width)。若为一个整数，则它的平方值将作为池化核大小，比如若 pool_size=2，则池化核大小为 2x2。
     - **stride** (int|list|tuple) - 池化层的步长。如果它是一个元组或列表，它将包含两个整数，(pool_stride_Height, pool_stride_Width)。若为一个整数，则表示 H 和 W 维度上 stride 均为该值。默认值为 kernel_size。
     - **padding** (string|int|list|tuple) - 池化填充。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 2 个整数值：[pad_height, pad_width]；(2)包含 4 个整数值：[pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；(3)包含 4 个二元组：当 data_format 为"NCHW"时为 [[0,0], [0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当 data_format 为"NHWC"时为[[0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]。若为一个整数，则表示 H 和 W 维度上均为该值。默认值：0。
+    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含两个整数：[dilation_height, dilation_width]。若为一个整数，则表示 H 和 W 维度上均为该值。默认值：1。
     - **ceil_mode** (bool) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 None。
     - **return_mask** (bool) - 是否返回最大索引和输出。默认为 False。
     - **data_format** (str) - 输入和输出的数据格式，可以是"NCHW"和"NHWC"。N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。默认值："NCHW"。
diff --git a/docs/api/paddle/nn/functional/max_pool3d_cn.rst b/docs/api/paddle/nn/functional/max_pool3d_cn.rst
index 207e0226c06..dcfd0e85f1e 100644
--- a/docs/api/paddle/nn/functional/max_pool3d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool3d_cn.rst
@@ -28,6 +28,7 @@ max_pool3d
     - **kernel_size** (int|list|tuple) - 池化核大小。如果它是一个元组或列表，它必须包含三个整数值，(pool_size_Depth，pool_size_Height, pool_size_Width)。若为一个整数，则表示 D，H 和 W 维度上均为该值，比如若 pool_size=2，则池化核大小为[2,2,2]。
     - **stride** (int|list|tuple) - 池化层的步长。如果它是一个元组或列表，它将包含三个整数，(pool_stride_Depth，pool_stride_Height, pool_stride_Width)。若为一个整数，则表示 D, H 和 W 维度上 stride 均为该值。默认值为 kernel_size。
     - **padding** (string|int|list|tuple) - 池化填充。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 3 个整数值：[pad_depth, pad_height, pad_width]；(2)包含 6 个整数值：[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；(3)包含 5 个二元组：当 data_format 为"NCDHW"时为[[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当 data_format 为"NDHWC"时为[[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：0。
+    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含 3 个整数：[dilation_depth, dilation_height, dilation_width]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：1。
     - **ceil_mode** (bool) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 False。
     - **return_mask** (bool) - 是否返回最大索引和输出。默认为 False。
     - **data_format** (str) - 输入和输出的数据格式，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值："NDCHW"。

From 1e5e06310f902e9b095824f1ade923ffc930d4b5 Mon Sep 17 00:00:00 2001
From: iLeGend <824040212@qq.com>
Date: Wed, 4 Feb 2026 19:11:09 -0800
Subject: [PATCH 02/13] fix typo turple -> tuple

---
 docs/api/paddle/nn/AdaptiveAvgPool2D_cn.rst              | 2 +-
 docs/api/paddle/nn/AdaptiveAvgPool3D_cn.rst              | 2 +-
 docs/api/paddle/nn/functional/adaptive_avg_pool2d_cn.rst | 2 +-
 docs/api/paddle/nn/functional/adaptive_avg_pool3d_cn.rst | 2 +-
 docs/api/paddle/nn/functional/avg_pool1d_cn.rst          | 2 +-
 docs/api/paddle/nn/functional/lp_pool1d_cn.rst           | 2 +-
 docs/api/paddle/nn/functional/max_pool1d_cn.rst          | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/docs/api/paddle/nn/AdaptiveAvgPool2D_cn.rst b/docs/api/paddle/nn/AdaptiveAvgPool2D_cn.rst
index 2725c5715ec..02fbb93122e 100755
--- a/docs/api/paddle/nn/AdaptiveAvgPool2D_cn.rst
+++ b/docs/api/paddle/nn/AdaptiveAvgPool2D_cn.rst
@@ -25,7 +25,7 @@ AdaptiveAvgPool2D
 
 参数
 :::::::::
-    - **output_size** (int|list|tuple)：算子输出特征图的尺寸，如果其是 list 或 turple 类型的数值，必须包含两个元素，H 和 W。H 和 W 既可以是 int 类型值也可以是 None，None 表示与输入特征尺寸相同。
+    - **output_size** (int|list|tuple)：算子输出特征图的尺寸，如果其是 list 或 tuple 类型的数值，必须包含两个元素，H 和 W。H 和 W 既可以是 int 类型值也可以是 None，None 表示与输入特征尺寸相同。
     - **data_format** (str，可选)：输入和输出的数据格式，可以是"NCHW"和"NHWC"。N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。默认值："NCHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/nn/AdaptiveAvgPool3D_cn.rst b/docs/api/paddle/nn/AdaptiveAvgPool3D_cn.rst
index 4f91c6ac08c..b837ec63170 100755
--- a/docs/api/paddle/nn/AdaptiveAvgPool3D_cn.rst
+++ b/docs/api/paddle/nn/AdaptiveAvgPool3D_cn.rst
@@ -28,7 +28,7 @@ AdaptiveAvgPool3D
 
 参数
 :::::::::
-    - **output_size** (int|list|tuple)：算子输出特征图的尺寸，如果其是 list 或 turple 类型的数值，必须包含三个元素，D，H 和 W。D，H 和 W 既可以是 int 类型值也可以是 None，None 表示与输入特征尺寸相同。
+    - **output_size** (int|list|tuple)：算子输出特征图的尺寸，如果其是 list 或 tuple 类型的数值，必须包含三个元素，D，H 和 W。D，H 和 W 既可以是 int 类型值也可以是 None，None 表示与输入特征尺寸相同。
     - **data_format** (str，可选)：输入和输出的数据格式，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征长度，H 是特征高度，W 是特征宽度。默认值："NCDHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/nn/functional/adaptive_avg_pool2d_cn.rst b/docs/api/paddle/nn/functional/adaptive_avg_pool2d_cn.rst
index 1298c143ce3..ecb0319f3e6 100755
--- a/docs/api/paddle/nn/functional/adaptive_avg_pool2d_cn.rst
+++ b/docs/api/paddle/nn/functional/adaptive_avg_pool2d_cn.rst
@@ -26,7 +26,7 @@ adaptive_avg_pool2d
 参数
 :::::::::
     - **x** (Tensor)：默认形状为（批大小，通道数，高度，宽度），即 NCHW 格式的 4-D Tensor。其数据类型为 float16, float32, float64, int32 或 int64。
-    - **output_size** (int|list|turple)：算子输出特征图的尺寸，如果其是 list 或 turple 类型的数值，必须包含两个元素，H 和 W。H 和 W 既可以是 int 类型值也可以是 None，None 表示与输入特征尺寸相同。
+    - **output_size** (int|list|tuple)：算子输出特征图的尺寸，如果其是 list 或 tuple 类型的数值，必须包含两个元素，H 和 W。H 和 W 既可以是 int 类型值也可以是 None，None 表示与输入特征尺寸相同。
     - **data_format** (str)：输入和输出的数据格式，可以是"NCHW"和"NHWC"。N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。默认值："NCHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/nn/functional/adaptive_avg_pool3d_cn.rst b/docs/api/paddle/nn/functional/adaptive_avg_pool3d_cn.rst
index 65e324be848..1f271b12ce9 100755
--- a/docs/api/paddle/nn/functional/adaptive_avg_pool3d_cn.rst
+++ b/docs/api/paddle/nn/functional/adaptive_avg_pool3d_cn.rst
@@ -31,7 +31,7 @@ adaptive_avg_pool3d
 参数
 :::::::::
     - **x** (Tensor)：默认形状为（批大小，通道数，长度，高度，宽度），即 NCDHW 格式的 5-D Tensor。其数据类型为 float16, float32, float64, int32 或 int64。
-    - **output_size** (int|list|turple)：算子输出特征图的尺寸，如果其是 list 或 turple 类型的数值，必须包含三个元素，D，H 和 W。D，H 和 W 既可以是 int 类型值也可以是 None，None 表示与输入特征尺寸相同。
+    - **output_size** (int|list|tuple)：算子输出特征图的尺寸，如果其是 list 或 tuple 类型的数值，必须包含三个元素，D，H 和 W。D，H 和 W 既可以是 int 类型值也可以是 None，None 表示与输入特征尺寸相同。
     - **data_format** (str)：输入和输出的数据格式，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征长度，H 是特征高度，W 是特征宽度。默认值："NCDHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/nn/functional/avg_pool1d_cn.rst b/docs/api/paddle/nn/functional/avg_pool1d_cn.rst
index 804b49a6114..0fa4048333a 100755
--- a/docs/api/paddle/nn/functional/avg_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/avg_pool1d_cn.rst
@@ -17,7 +17,7 @@ avg_pool1d
     - **x** (Tensor)：当前算子的输入，其是一个形状为 `[N, C, L]` 的 3-D Tensor。其中 `N` 是 batch size, `C` 是通道数，`L` 是输入特征的长度。其数据类型为 float16、float32 和 float64。
     - **kernel_size** (int|list|tuple)：池化核的尺寸大小。如果 kernel_size 为 list 或 tuple 类型，其必须包含一个整数。
     - **stride** (int|list|tuple)：池化操作步长。如果 stride 为 list 或 tuple 类型，其必须包含一个整数。
-    - **padding** (string|int|list|tuple)：池化补零的方式。如果 padding 是一个字符串，则必须为 `SAME` 或者 `VALID`。如果是 turple 或者 list 类型，则应是 `[pad_left, pad_right]` 形式。如果 padding 是一个非 0 值，那么表示会在输入的两端都 padding 上同样长度的 0。
+    - **padding** (string|int|list|tuple)：池化补零的方式。如果 padding 是一个字符串，则必须为 `SAME` 或者 `VALID`。如果是 tuple 或者 list 类型，则应是 `[pad_left, pad_right]` 形式。如果 padding 是一个非 0 值，那么表示会在输入的两端都 padding 上同样长度的 0。
     - **exclusive** (bool)：是否用额外 padding 的值计算平均池化结果，默认为 True。
     - **ceil_mode** (bool)：是否用 ceil 函数计算输出的 height 和 width，如果设置为 False，则使用 floor 函数来计算，默认为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
diff --git a/docs/api/paddle/nn/functional/lp_pool1d_cn.rst b/docs/api/paddle/nn/functional/lp_pool1d_cn.rst
index 0ef48a89fff..cafe117f167 100644
--- a/docs/api/paddle/nn/functional/lp_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/lp_pool1d_cn.rst
@@ -18,7 +18,7 @@ lp_pool1d
     - **norm_type** (int|float)：幂平均池化的指数，不可以为 0。
     - **kernel_size** (int|list|tuple)：池化核的尺寸大小。如果 kernel_size 为 list 或 tuple 类型，其必须包含一个整数。
     - **stride** (int|list|tuple)：池化操作步长。如果 stride 为 list 或 tuple 类型，其必须包含一个整数。
-    - **padding** (string|int|list|tuple)：池化补零的方式。如果 padding 是一个字符串，则必须为 `SAME` 或者 `VALID`。如果是 turple 或者 list 类型，则应是 `[pad_left, pad_right]` 形式。如果 padding 是一个非 0 值，那么表示会在输入的两端都 padding 上同样长度的 0。
+    - **padding** (string|int|list|tuple)：池化补零的方式。如果 padding 是一个字符串，则必须为 `SAME` 或者 `VALID`。如果是 tuple 或者 list 类型，则应是 `[pad_left, pad_right]` 形式。如果 padding 是一个非 0 值，那么表示会在输入的两端都 padding 上同样长度的 0。
     - **ceil_mode** (bool)：是否用 ceil 函数计算输出的 height 和 width，如果设置为 False，则使用 floor 函数来计算，默认为 False。
     - **data_format** (str)：输入和输出的数据格式，可以是"NCL"和"NLC"。N 是批尺寸，C 是通道数，L 是特征长度。默认值："NCL"
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
diff --git a/docs/api/paddle/nn/functional/max_pool1d_cn.rst b/docs/api/paddle/nn/functional/max_pool1d_cn.rst
index 3be6919c10a..75e1998ab52 100755
--- a/docs/api/paddle/nn/functional/max_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool1d_cn.rst
@@ -17,7 +17,7 @@ max_pool1d
     - **x** (Tensor) - 当前算子的输入，其是一个形状为 `[N, C, L]` 的 3-D Tensor。其中 `N` 是 batch size, `C` 是通道数，`L` 是输入特征的长度。其数据类型为 float32 或者 float64。
     - **kernel_size** (int|list|tuple) - 池化核的尺寸大小。如果 kernel_size 为 list 或 tuple 类型，其必须包含一个整数。
     - **stride** (int|list|tuple) - 池化操作步长。如果 stride 为 list 或 tuple 类型，其必须包含一个整数。
-    - **padding** (string|int|list|tuple) - 池化补零的方式。如果 padding 是一个字符串，则必须为 `SAME` 或者 `VALID`。如果是 turple 或者 list 类型，则应是 `[pad_left, pad_right]` 形式。如果 padding 是一个非 0 值，那么表示会在输入的两端都 padding 上同样长度的 0。
+    - **padding** (string|int|list|tuple) - 池化补零的方式。如果 padding 是一个字符串，则必须为 `SAME` 或者 `VALID`。如果是 tuple 或者 list 类型，则应是 `[pad_left, pad_right]` 形式。如果 padding 是一个非 0 值，那么表示会在输入的两端都 padding 上同样长度的 0。
     - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含一个整数。默认值为 1。
     - **return_mask** (bool) - 是否返回最大值的索引，默认为 False。
     - **ceil_mode** (bool) - 是否用 ceil 函数计算输出的 height 和 width，如果设置为 False，则使用 floor 函数来计算，默认为 False。

From 0be61ef681d441b53515f664215ecc6a2719c533 Mon Sep 17 00:00:00 2001
From: iLeGend <824040212@qq.com>
Date: Wed, 4 Feb 2026 23:08:27 -0800
Subject: [PATCH 03/13] add params alias for (fractional)maxpool*

---
 docs/api/paddle/nn/FractionalMaxPool2D_cn.rst              | 4 ++++
 docs/api/paddle/nn/FractionalMaxPool3D_cn.rst              | 4 ++++
 docs/api/paddle/nn/MaxPool1D_cn.rst                        | 5 +++++
 docs/api/paddle/nn/MaxPool2D_cn.rst                        | 5 +++++
 docs/api/paddle/nn/MaxPool3D_cn.rst                        | 6 ++++++
 docs/api/paddle/nn/functional/fractional_max_pool2d_cn.rst | 5 +++++
 docs/api/paddle/nn/functional/fractional_max_pool3d_cn.rst | 5 +++++
 docs/api/paddle/nn/functional/max_pool1d_cn.rst            | 4 ++++
 docs/api/paddle/nn/functional/max_pool2d_cn.rst            | 4 ++++
 docs/api/paddle/nn/functional/max_pool3d_cn.rst            | 4 ++++
 10 files changed, 46 insertions(+)

diff --git a/docs/api/paddle/nn/FractionalMaxPool2D_cn.rst b/docs/api/paddle/nn/FractionalMaxPool2D_cn.rst
index 4496976faf0..95a4f5a9c55 100644
--- a/docs/api/paddle/nn/FractionalMaxPool2D_cn.rst
+++ b/docs/api/paddle/nn/FractionalMaxPool2D_cn.rst
@@ -33,6 +33,8 @@ FractionalMaxPool2D
 进而得到论文中的随机序列为 `index_end - index_start = [1, 2, 1, 2, 1]` 。
 由于池化操作的步长与核尺寸相同，同为此随机序列，最终得到池化输出为 `[2, 4, 1, 5, 3]` 。
 
+..  note::
+    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
 
 参数
 :::::::::
@@ -41,12 +43,14 @@ FractionalMaxPool2D
     - **kernel_size** (int|list|tuple, 可选) - 池化核大小。如果它是一个元组或列表，它必须包含两个整数值，(pool_size_Height, pool_size_Width)。若为一个整数，则表示 H 和 W 维度上均为该值，比如若 pool_size=2，则池化核大小为 [2,2]。默认为 `None`，表示使用 `disjoint` (`non-overlapping`) 模式。
     - **random_u** (float)：分数阶池化操作的浮点随机数，取值范围为 `(0, 1)` 。默认为 `None` ，由框架随机生成，可以使用 `paddle.seed` 设置随机种子。
     - **return_mask** (bool，可选)：如果设置为 `True` ，则会与输出一起返回最大值的索引，默认为 `False`。
+      ``别名：return_indices``
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 `None`。
 
 形状
 :::::::::
 
     - **x** (Tensor)：默认形状为（批大小，通道数，输出特征长度，宽度），即 NCHW 格式的 4-D Tensor。其数据类型为 float16, bfloat16, float32, float64。
+      ``别名：input``
     - **output** (Tensor)：默认形状为（批大小，通道数，输出特征长度，宽度），即 NCHW 格式的 4-D Tensor。其数据类型与输入 x 相同。
 
 返回
diff --git a/docs/api/paddle/nn/FractionalMaxPool3D_cn.rst b/docs/api/paddle/nn/FractionalMaxPool3D_cn.rst
index 4e7d9e32b5a..e1a2da4166d 100644
--- a/docs/api/paddle/nn/FractionalMaxPool3D_cn.rst
+++ b/docs/api/paddle/nn/FractionalMaxPool3D_cn.rst
@@ -33,6 +33,8 @@ FractionalMaxPool3D
 进而得到论文中的随机序列为 `index_end - index_start = [1, 2, 1, 2, 1]` 。
 由于池化操作的步长与核尺寸相同，同为此随机序列，最终得到池化输出为 `[2, 4, 1, 5, 3]` 。
 
+..  note::
+    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
 
 参数
 :::::::::
@@ -41,11 +43,13 @@ FractionalMaxPool3D
     - **kernel_size** (int|list|tuple，可选) - 池化核大小。如果它是一个元组或列表，它必须包含三个整数值，(pool_size_Depth，pool_size_Height, pool_size_Width)。若为一个整数，则表示 D，H 和 W 维度上均为该值，比如若 pool_size=2，则池化核大小为[2,2,2]。默认为 `None`，表示使用 `disjoint` (`non-overlapping`) 模式。
     - **random_u** (float)：分数阶池化操作的浮点随机数，取值范围为 `(0, 1)` 。默认为 `None` ，由框架随机生成，可以使用 `paddle.seed` 设置随机种子。
     - **return_mask** (bool，可选)：如果设置为 `True` ，则会与输出一起返回最大值的索引，默认为 `False`。
+      ``别名：return_indices``
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 `None`。
 
 形状
 :::::::::
     - **x** (Tensor)：默认形状为（批大小，通道数，输出特征深度，高度，宽度），即 NCDHW 格式的 5-D Tensor。其数据类型为 float16, bfloat16, float32, float64。
+      ``别名：input``
     - **output** (Tensor)：默认形状为（批大小，通道数，输出特征深度，高度，宽度），即 NCDHW 格式的 5-D Tensor。其数据类型与输入 x 相同。
 
 返回
diff --git a/docs/api/paddle/nn/MaxPool1D_cn.rst b/docs/api/paddle/nn/MaxPool1D_cn.rst
index 64d60111ff8..48d1443dc99 100755
--- a/docs/api/paddle/nn/MaxPool1D_cn.rst
+++ b/docs/api/paddle/nn/MaxPool1D_cn.rst
@@ -13,6 +13,9 @@ MaxPool1D
 
     Output(N_i, C_i, l) =  max(Input[N_i, C_i, stride \times l:stride \times l+k])
 
+..  note::
+    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
+
 参数
 :::::::::
     - **kernel_size** (int|list|tuple) - 池化核的尺寸大小。如果 kernel_size 为 list 或 tuple 类型，其必须包含一个整数，最终池化核的大小为该数值。
@@ -20,6 +23,7 @@ MaxPool1D
     - **padding** (str|int|list|tuple，可选) - 池化补零的方式。如果 padding 是一个字符串，则必须为 `SAME` 或者 `VALID`。如果是 tuple 或者 list 类型，若其长度为 1，则会在输入的两端都填充上长度为 padding[0] 的 0，若其长度为 2，则应是 `[pad_before, pad_after]` 形式。如果 padding 是一个非 0 整数，那么表示会在输入的两端都填充上同样长度的 0。如果 padding 是长度为 2 的序列组成的 list 或 tuple，则其中的每个元素表示在相应维度上的填充长度。注意：在 batch_size 维度和通道维度应该设置为 [0, 0] 或 (0, 0)。默认值为 0。
     - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含一个整数。默认值为 1。
     - **return_mask** (bool，可选) - 是否返回最大值的索引，默认为 False。
+      ``别名：return_indices``
     - **ceil_mode** (bool，可选) - 是否用 ceil 函数计算输出的 height 和 width，如果设置为 False，则使用 floor 函数来计算，默认为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
@@ -27,6 +31,7 @@ MaxPool1D
 形状
 :::::::::
     - **x** (Tensor) ：默认形状为（批大小，通道数，长度），即 NCL 格式的 3-D Tensor。其数据类型为 float32 或 float64。
+      ``别名：input``
     - **output** (Tensor) ：默认形状为（批大小，通道数，输出特征长度），即 NCL 格式的 3-D Tensor。其数据类型与输入 x 相同。
 
 返回
diff --git a/docs/api/paddle/nn/MaxPool2D_cn.rst b/docs/api/paddle/nn/MaxPool2D_cn.rst
index 02e3186cd31..7c749775e65 100644
--- a/docs/api/paddle/nn/MaxPool2D_cn.rst
+++ b/docs/api/paddle/nn/MaxPool2D_cn.rst
@@ -22,6 +22,9 @@ MaxPool2D
                                                    \text{stride[1]} \times w + n)
 
 
+..  note::
+    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
+
 参数
 :::::::::
     - **kernel_size** (int|list|tuple) - 池化核大小。如果它是一个元组或列表，它必须包含两个整数值，(pool_size_Height, pool_size_Width)。若为一个整数，则它的平方值将作为池化核大小，比如若 pool_size=2，则池化核大小为 2x2。
@@ -30,6 +33,7 @@ MaxPool2D
     - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含两个整数：[dilation_height, dilation_width]。若为一个整数，则表示 H 和 W 维度上均为该值。默认值：1。
     - **ceil_mode** (bool，可选) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。
     - **return_mask** (bool，可选) - 是否返回最大索引和输出。默认为 False。
+      ``别名：return_indices``
     - **data_format** (str，可选) - 输入和输出的数据格式，可以是"NCHW"和"NHWC"。N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。默认值："NCHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
@@ -38,6 +42,7 @@ MaxPool2D
 形状
 :::::::::
     - **x** (Tensor) ：默认形状为（批大小，通道数，高度，宽度），即 NCHW 格式的 4-D Tensor。其数据类型为 float16, float32, float64, int32 或 int64。
+      ``别名：input``
     - **output** (Tensor) ：默认形状为（批大小，通道数，输出特征高度，输出特征宽度），即 NCHW 格式的 4-D Tensor。其数据类型与输入相同。
 
 
diff --git a/docs/api/paddle/nn/MaxPool3D_cn.rst b/docs/api/paddle/nn/MaxPool3D_cn.rst
index 4ac67e8f67f..b5759c57b00 100644
--- a/docs/api/paddle/nn/MaxPool3D_cn.rst
+++ b/docs/api/paddle/nn/MaxPool3D_cn.rst
@@ -20,6 +20,10 @@ MaxPool3D
           \text{out}(N_i, C_j, d, h, w) ={} & \max_{k=0, \ldots, kD-1} \max_{m=0, \ldots, kH-1} \max_{n=0, \ldots, kW-1} \\
                                               & \text{input}(N_i, C_j, \text{stride[0]} \times d + k,
                                                              \text{stride[1]} \times h + m, \text{stride[2]} \times w + n)
+
+..  note::
+    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
+
 参数
 :::::::::
     - **kernel_size** (int|list|tuple) - 池化核大小。如果它是一个元组或列表，它必须包含三个整数值，(pool_size_Depth，pool_size_Height, pool_size_Width)。若为一个整数，则表示 D，H 和 W 维度上均为该值，比如若 pool_size=2，则池化核大小为[2,2,2]。
@@ -28,6 +32,7 @@ MaxPool3D
     - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含 3 个整数：[dilation_depth, dilation_height, dilation_width]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：1。
     - **ceil_mode** (bool，可选) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 False。
     - **return_mask** (bool，可选) - 是否返回最大索引和输出。默认为 False。
+      ``别名：return_indices``
     - **data_format** (str，可选) - 输入和输出的数据格式，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值："NDCHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
@@ -35,6 +40,7 @@ MaxPool3D
 形状
 :::::::::
     - **x** (Tensor) ：默认形状为（批大小，通道数，长度，高度，宽度），即 NCDHW 格式的 5-D Tensor。其数据类型为 float16, float32, float64, int32 或 int64。
+      ``别名：input``
     - **output** (Tensor) ：默认形状为（批大小，通道数，输出特征长度，输出特征高度，输出特征宽度），即 NCDHW 格式的 5-D Tensor。其数据类型与输入相同。
 
 
diff --git a/docs/api/paddle/nn/functional/fractional_max_pool2d_cn.rst b/docs/api/paddle/nn/functional/fractional_max_pool2d_cn.rst
index 414663303b3..a66a7aab6fd 100644
--- a/docs/api/paddle/nn/functional/fractional_max_pool2d_cn.rst
+++ b/docs/api/paddle/nn/functional/fractional_max_pool2d_cn.rst
@@ -32,13 +32,18 @@ fractional_max_pool2d
 进而得到论文中的随机序列为 `index_end - index_start = [1, 2, 1, 2, 1]` 。
 由于池化操作的步长与核尺寸相同，同为此随机序列，最终得到池化输出为 `[2, 4, 1, 5, 3]` 。
 
+..  note::
+    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
+
 参数
 :::::::::
     - **x** (Tensor)：当前算子的输入，其是一个形状为 `[N, C, H, W]` 的 4-D Tensor。其中 `N` 是 batch size, `C` 是通道数， `H` 是输入特征的高度， `W` 是输入特征的宽度。其数据类型为 `float16`, `bfloat16`, `float32`, `float64` 。
+      ``别名：input``
     - **output_size** (int|list|tuple)：算子输出图的尺寸，其数据类型为 int 或 list，tuple。如果输出为 tuple 或者 list，则必须包含两个元素， `(H, W)` 。 `H` 和 `W` 可以是 `int` ，也可以是 `None` ，表示与输入保持一致。
     - **kernel_size** (int|list|tuple, 可选) - 池化核大小。如果它是一个元组或列表，它必须包含两个整数值，(pool_size_Height, pool_size_Width)。若为一个整数，则表示 H 和 W 维度上均为该值，比如若 pool_size=2，则池化核大小为 [2,2]。默认为 `None`，表示使用 `disjoint` (`non-overlapping`) 模式。
     - **random_u** (float)：分数阶池化操作的浮点随机数，取值范围为 `(0, 1)` 。默认为 `None` ，由框架随机生成，可以使用 `paddle.seed` 设置随机种子。
     - **return_mask** (bool，可选)：如果设置为 `True` ，则会与输出一起返回最大值的索引，默认为 `False`。
+      ``别名：return_indices``
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 `None`。
 
 返回
diff --git a/docs/api/paddle/nn/functional/fractional_max_pool3d_cn.rst b/docs/api/paddle/nn/functional/fractional_max_pool3d_cn.rst
index 6044f06a40b..b6fd634f4db 100644
--- a/docs/api/paddle/nn/functional/fractional_max_pool3d_cn.rst
+++ b/docs/api/paddle/nn/functional/fractional_max_pool3d_cn.rst
@@ -32,13 +32,18 @@ fractional_max_pool3d
 进而得到论文中的随机序列为 `index_end - index_start = [1, 2, 1, 2, 1]` 。
 由于池化操作的步长与核尺寸相同，同为此随机序列，最终得到池化输出为 `[2, 4, 1, 5, 3]` 。
 
+..  note::
+    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
+
 参数
 :::::::::
     - **x** (Tensor)：当前算子的输入，其是一个形状为 `[N, C, D, H, W]` 的 5-D Tensor。其中 `N` 是 batch size, `C` 是通道数， `D` 是输入特征的深度， `H` 是输入特征的高度， `W` 是输入特征的宽度。其数据类型为 `float16`, `bfloat16`, `float32`, `float64` 。
+      ``别名：input``
     - **output_size** (int|list|tuple)：算子输出图的尺寸，其数据类型为 int 或 list，tuple。如果输出为 tuple 或者 list，则必须包含三个元素， `(D, H, W)` 。 `D`, `H` 和 `W` 可以是 `int` ，也可以是 `None` ，表示与输入保持一致。
     - **kernel_size** (int|list|tuple，可选) - 池化核大小。如果它是一个元组或列表，它必须包含三个整数值，(pool_size_Depth，pool_size_Height, pool_size_Width)。若为一个整数，则表示 D，H 和 W 维度上均为该值，比如若 pool_size=2，则池化核大小为[2,2,2]。默认为 `None`，表示使用 `disjoint` (`non-overlapping`) 模式。
     - **random_u** (float)：分数阶池化操作的浮点随机数，取值范围为 `(0, 1)` 。默认为 `None` ，由框架随机生成，可以使用 `paddle.seed` 设置随机种子。
     - **return_mask** (bool，可选)：如果设置为 `True` ，则会与输出一起返回最大值的索引，默认为 `False`。
+      ``别名：return_indices``
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 `None`。
 
 返回
diff --git a/docs/api/paddle/nn/functional/max_pool1d_cn.rst b/docs/api/paddle/nn/functional/max_pool1d_cn.rst
index 75e1998ab52..b8754505112 100755
--- a/docs/api/paddle/nn/functional/max_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool1d_cn.rst
@@ -11,15 +11,19 @@ max_pool1d
 .. note::
    详细请参考对应的 `Class` 请参考：:ref:`cn_api_paddle_nn_MaxPool1D` 。
 
+..  note::
+    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
 
 参数
 :::::::::
     - **x** (Tensor) - 当前算子的输入，其是一个形状为 `[N, C, L]` 的 3-D Tensor。其中 `N` 是 batch size, `C` 是通道数，`L` 是输入特征的长度。其数据类型为 float32 或者 float64。
+      ``别名：input``
     - **kernel_size** (int|list|tuple) - 池化核的尺寸大小。如果 kernel_size 为 list 或 tuple 类型，其必须包含一个整数。
     - **stride** (int|list|tuple) - 池化操作步长。如果 stride 为 list 或 tuple 类型，其必须包含一个整数。
     - **padding** (string|int|list|tuple) - 池化补零的方式。如果 padding 是一个字符串，则必须为 `SAME` 或者 `VALID`。如果是 tuple 或者 list 类型，则应是 `[pad_left, pad_right]` 形式。如果 padding 是一个非 0 值，那么表示会在输入的两端都 padding 上同样长度的 0。
     - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含一个整数。默认值为 1。
     - **return_mask** (bool) - 是否返回最大值的索引，默认为 False。
+      ``别名：return_indices``
     - **ceil_mode** (bool) - 是否用 ceil 函数计算输出的 height 和 width，如果设置为 False，则使用 floor 函数来计算，默认为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/nn/functional/max_pool2d_cn.rst b/docs/api/paddle/nn/functional/max_pool2d_cn.rst
index 40b77c2f469..c6d770c3aab 100644
--- a/docs/api/paddle/nn/functional/max_pool2d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool2d_cn.rst
@@ -21,16 +21,20 @@ max_pool2d
                                     & \text{input}(N_i, C_j, \text{stride[0]} \times h + m,
                                                    \text{stride[1]} \times w + n)
 
+..  note::
+    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
 
 参数
 :::::::::
     - **x** (Tensor) - 形状为 `[N,C,H,W]` 或 `[N,H,W,C]` 的 4-D Tensor，N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度，数据类型为 float32 或 float64。
+      ``别名：input``
     - **kernel_size** (int|list|tuple) - 池化核大小。如果它是一个元组或列表，它必须包含两个整数值，(pool_size_Height, pool_size_Width)。若为一个整数，则它的平方值将作为池化核大小，比如若 pool_size=2，则池化核大小为 2x2。
     - **stride** (int|list|tuple) - 池化层的步长。如果它是一个元组或列表，它将包含两个整数，(pool_stride_Height, pool_stride_Width)。若为一个整数，则表示 H 和 W 维度上 stride 均为该值。默认值为 kernel_size。
     - **padding** (string|int|list|tuple) - 池化填充。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 2 个整数值：[pad_height, pad_width]；(2)包含 4 个整数值：[pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；(3)包含 4 个二元组：当 data_format 为"NCHW"时为 [[0,0], [0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当 data_format 为"NHWC"时为[[0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]。若为一个整数，则表示 H 和 W 维度上均为该值。默认值：0。
     - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含两个整数：[dilation_height, dilation_width]。若为一个整数，则表示 H 和 W 维度上均为该值。默认值：1。
     - **ceil_mode** (bool) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 None。
     - **return_mask** (bool) - 是否返回最大索引和输出。默认为 False。
+      ``别名：return_indices``
     - **data_format** (str) - 输入和输出的数据格式，可以是"NCHW"和"NHWC"。N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。默认值："NCHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/nn/functional/max_pool3d_cn.rst b/docs/api/paddle/nn/functional/max_pool3d_cn.rst
index dcfd0e85f1e..4d86a3271bf 100644
--- a/docs/api/paddle/nn/functional/max_pool3d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool3d_cn.rst
@@ -21,16 +21,20 @@ max_pool3d
                                               & \text{input}(N_i, C_j, \text{stride[0]} \times d + k,
                                                              \text{stride[1]} \times h + m, \text{stride[2]} \times w + n)
 
+..  note::
+    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
 
 参数
 :::::::::
     - **x** (Tensor) - 形状为 [N,C,D,H,W] 或 [N,D,H,W,C] 的 5-D Tensor，N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度，数据类型为 float32 或 float64。
+      ``别名：input``
     - **kernel_size** (int|list|tuple) - 池化核大小。如果它是一个元组或列表，它必须包含三个整数值，(pool_size_Depth，pool_size_Height, pool_size_Width)。若为一个整数，则表示 D，H 和 W 维度上均为该值，比如若 pool_size=2，则池化核大小为[2,2,2]。
     - **stride** (int|list|tuple) - 池化层的步长。如果它是一个元组或列表，它将包含三个整数，(pool_stride_Depth，pool_stride_Height, pool_stride_Width)。若为一个整数，则表示 D, H 和 W 维度上 stride 均为该值。默认值为 kernel_size。
     - **padding** (string|int|list|tuple) - 池化填充。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 3 个整数值：[pad_depth, pad_height, pad_width]；(2)包含 6 个整数值：[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；(3)包含 5 个二元组：当 data_format 为"NCDHW"时为[[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当 data_format 为"NDHWC"时为[[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：0。
     - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含 3 个整数：[dilation_depth, dilation_height, dilation_width]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：1。
     - **ceil_mode** (bool) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 False。
     - **return_mask** (bool) - 是否返回最大索引和输出。默认为 False。
+      ``别名：return_indices``
     - **data_format** (str) - 输入和输出的数据格式，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值："NDCHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 

From bdfacfbb3dae6c41bf05fcd3f4332b692f35f11a Mon Sep 17 00:00:00 2001
From: iLeGend <824040212@qq.com>
Date: Thu, 5 Feb 2026 00:44:02 -0800
Subject: [PATCH 04/13] add adpative_max_pool*d and fix some fmt

---
 docs/api/paddle/nn/AdaptiveMaxPool1D_cn.rst              | 5 +++++
 docs/api/paddle/nn/AdaptiveMaxPool2D_cn.rst              | 6 ++++++
 docs/api/paddle/nn/AdaptiveMaxPool3D_cn.rst              | 6 ++++++
 docs/api/paddle/nn/FractionalMaxPool2D_cn.rst            | 1 +
 docs/api/paddle/nn/FractionalMaxPool3D_cn.rst            | 1 +
 docs/api/paddle/nn/MaxPool1D_cn.rst                      | 1 +
 docs/api/paddle/nn/MaxPool3D_cn.rst                      | 1 +
 docs/api/paddle/nn/functional/adaptive_max_pool1d_cn.rst | 9 +++++++--
 docs/api/paddle/nn/functional/adaptive_max_pool2d_cn.rst | 9 +++++++--
 docs/api/paddle/nn/functional/adaptive_max_pool3d_cn.rst | 9 +++++++--
 docs/api/paddle/nn/functional/max_pool2d_cn.rst          | 1 +
 docs/api/paddle/nn/functional/max_pool3d_cn.rst          | 2 +-
 12 files changed, 44 insertions(+), 7 deletions(-)

diff --git a/docs/api/paddle/nn/AdaptiveMaxPool1D_cn.rst b/docs/api/paddle/nn/AdaptiveMaxPool1D_cn.rst
index 60a02836c31..64c0a07ed54 100755
--- a/docs/api/paddle/nn/AdaptiveMaxPool1D_cn.rst
+++ b/docs/api/paddle/nn/AdaptiveMaxPool1D_cn.rst
@@ -19,15 +19,20 @@ AdaptiveMaxPool1D
     Output(i) &= max(Input[lstart:lend])
 
 
+..  note::
+    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
+
 参数
 :::::::::
     - **output_size** (int|list|tuple)：算子输出特征图的长度，其数据类型为 int,list 或 tuple。
     - **return_mask** (bool，可选)：如果设置为 True，则会与输出一起返回最大值的索引，默认为 False。
+      ``别名：return_indices``
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
 :::::::::
     - **x** (Tensor)：默认形状为（批大小，通道数，输出特征长度），即 NCL 格式的 3-D Tensor。其数据类型为 float32 或者 float64。
+      ``别名：input``
     - **output** (Tensor)：默认形状为（批大小，通道数，输出特征长度），即 NCL 格式的 3-D Tensor。其数据类型与输入 x 相同。
 
 返回
diff --git a/docs/api/paddle/nn/AdaptiveMaxPool2D_cn.rst b/docs/api/paddle/nn/AdaptiveMaxPool2D_cn.rst
index 4668461628f..884d8f233a2 100644
--- a/docs/api/paddle/nn/AdaptiveMaxPool2D_cn.rst
+++ b/docs/api/paddle/nn/AdaptiveMaxPool2D_cn.rst
@@ -27,17 +27,23 @@ AdaptiveMaxPool2D
 
     Output(i ,j) &= max(Input[hstart:hend, wstart:wend])
 
+
+..  note::
+    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
+
 参数
 :::::::::
 
     - **output_size** (int|list|tuple)：算子输出特征图的高和宽大小，其数据类型为 int,list 或 tuple。
     - **return_mask** (bool，可选)：如果设置为 True，则会与输出一起返回最大值的索引，默认为 False。
+      ``别名：return_indices``
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
 :::::::::
 
     - **x** (Tensor)：默认形状为（批大小，通道数，输出特征长度，宽度），即 NCHW 格式的 4-D Tensor。其数据类型为 float32 或者 float64。
+      ``别名：input``
     - **output** (Tensor)：默认形状为（批大小，通道数，输出特征长度，宽度），即 NCHW 格式的 4-D Tensor。其数据类型与输入 x 相同。
 
 返回
diff --git a/docs/api/paddle/nn/AdaptiveMaxPool3D_cn.rst b/docs/api/paddle/nn/AdaptiveMaxPool3D_cn.rst
index 25df013b17a..65a70e13ce1 100644
--- a/docs/api/paddle/nn/AdaptiveMaxPool3D_cn.rst
+++ b/docs/api/paddle/nn/AdaptiveMaxPool3D_cn.rst
@@ -25,15 +25,21 @@ AdaptiveMaxPool3D
 
     Output(i ,j, k) &= max(Input[dstart:dend, hstart:hend, wstart:wend])
 
+
+..  note::
+    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
+
 参数
 :::::::::
     - **output_size** (int|list|tuple)：算子输出特征图的高宽长大小，其数据类型为 int,list 或 tuple。
     - **return_mask** (bool，可选)：如果设置为 True，则会与输出一起返回最大值的索引，默认为 False。
+      ``别名：return_indices``
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
 :::::::::
     - **x** (Tensor)：默认形状为（批大小，通道数，输出特征深度，高度，宽度），即 NCDHW 格式的 5-D Tensor。其数据类型为 float32 或者 float64。
+      ``别名：input``
     - **output** (Tensor)：默认形状为（批大小，通道数，输出特征深度，高度，宽度），即 NCDHW 格式的 5-D Tensor。其数据类型与输入 x 相同。
 
 返回
diff --git a/docs/api/paddle/nn/FractionalMaxPool2D_cn.rst b/docs/api/paddle/nn/FractionalMaxPool2D_cn.rst
index 95a4f5a9c55..e9c756e7a74 100644
--- a/docs/api/paddle/nn/FractionalMaxPool2D_cn.rst
+++ b/docs/api/paddle/nn/FractionalMaxPool2D_cn.rst
@@ -33,6 +33,7 @@ FractionalMaxPool2D
 进而得到论文中的随机序列为 `index_end - index_start = [1, 2, 1, 2, 1]` 。
 由于池化操作的步长与核尺寸相同，同为此随机序列，最终得到池化输出为 `[2, 4, 1, 5, 3]` 。
 
+
 ..  note::
     别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
 
diff --git a/docs/api/paddle/nn/FractionalMaxPool3D_cn.rst b/docs/api/paddle/nn/FractionalMaxPool3D_cn.rst
index e1a2da4166d..4f7be34d725 100644
--- a/docs/api/paddle/nn/FractionalMaxPool3D_cn.rst
+++ b/docs/api/paddle/nn/FractionalMaxPool3D_cn.rst
@@ -33,6 +33,7 @@ FractionalMaxPool3D
 进而得到论文中的随机序列为 `index_end - index_start = [1, 2, 1, 2, 1]` 。
 由于池化操作的步长与核尺寸相同，同为此随机序列，最终得到池化输出为 `[2, 4, 1, 5, 3]` 。
 
+
 ..  note::
     别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
 
diff --git a/docs/api/paddle/nn/MaxPool1D_cn.rst b/docs/api/paddle/nn/MaxPool1D_cn.rst
index 48d1443dc99..428e3ddcbb4 100755
--- a/docs/api/paddle/nn/MaxPool1D_cn.rst
+++ b/docs/api/paddle/nn/MaxPool1D_cn.rst
@@ -13,6 +13,7 @@ MaxPool1D
 
     Output(N_i, C_i, l) =  max(Input[N_i, C_i, stride \times l:stride \times l+k])
 
+
 ..  note::
     别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
 
diff --git a/docs/api/paddle/nn/MaxPool3D_cn.rst b/docs/api/paddle/nn/MaxPool3D_cn.rst
index b5759c57b00..56b00d18476 100644
--- a/docs/api/paddle/nn/MaxPool3D_cn.rst
+++ b/docs/api/paddle/nn/MaxPool3D_cn.rst
@@ -21,6 +21,7 @@ MaxPool3D
                                               & \text{input}(N_i, C_j, \text{stride[0]} \times d + k,
                                                              \text{stride[1]} \times h + m, \text{stride[2]} \times w + n)
 
+
 ..  note::
     别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
 
diff --git a/docs/api/paddle/nn/functional/adaptive_max_pool1d_cn.rst b/docs/api/paddle/nn/functional/adaptive_max_pool1d_cn.rst
index c394f52bce9..0e76efb8924 100755
--- a/docs/api/paddle/nn/functional/adaptive_max_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/adaptive_max_pool1d_cn.rst
@@ -8,15 +8,20 @@ adaptive_max_pool1d
 根据输入 `x` , `output_size` 等参数对一个输入 Tensor 计算 1D 的自适应最大值池化。输入和输出都是 3-D Tensor，
 默认是以 `NCL` 格式表示的，其中 `N` 是 batch size, `C` 是通道数，`L` 是输入特征的长度。
 
-.. note::
-   详细请参考对应的 `Class` 请参考：:ref:`cn_api_paddle_nn_AdaptiveMaxPool1D` 。
+
+..  note::
+    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
+ 
+    详细请参考对应的 `Class` 请参考：:ref:`cn_api_paddle_nn_AdaptiveMaxPool1D` 。
 
 
 参数
 :::::::::
     - **x** (Tensor)：当前算子的输入，其是一个形状为 `[N, C, L]` 的 3-D Tensor。其中 `N` 是 batch size, `C` 是通道数，`L` 是输入特征的长度。其数据类型为 float32 或者 float64。
+      ``别名：input``
     - **output_size** (int|list|tuple)：算子输出特征图的长度，其数据类型为 int 或 list，tuple。
     - **return_mask** (bool)：如果设置为 True，则会与输出一起返回最大值的索引，默认为 False。
+      ``别名：return_indices``
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/nn/functional/adaptive_max_pool2d_cn.rst b/docs/api/paddle/nn/functional/adaptive_max_pool2d_cn.rst
index 9580a0441fd..cf1582665c4 100644
--- a/docs/api/paddle/nn/functional/adaptive_max_pool2d_cn.rst
+++ b/docs/api/paddle/nn/functional/adaptive_max_pool2d_cn.rst
@@ -7,15 +7,20 @@ adaptive_max_pool2d
 根据输入 `x` , `output_size` 等参数对一个输入 Tensor 计算 2D 的自适应最大值池化。输入和输出都是 4-D Tensor，
 默认是以 `NCHW` 格式表示的，其中 `N` 是 batch size, `C` 是通道数，`H` 是输入特征的高度，`W` 是输入特征的宽度。
 
-.. note::
-   详细请参考对应的 `Class` 请参考：:ref:`cn_api_paddle_nn_AdaptiveMaxPool2D` 。
+
+..  note::
+    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
+
+    详细请参考对应的 `Class` 请参考：:ref:`cn_api_paddle_nn_AdaptiveMaxPool2D` 。
 
 
 参数
 :::::::::
     - **x** (Tensor)：当前算子的输入，其是一个形状为 `[N, C, H, W]` 的 4-D Tensor。其中 `N` 是 batch size, `C` 是通道数，`H` 是输入特征的高度，`W` 是输入特征的宽度。其数据类型为 float32 或者 float64。
+      ``别名：input``
     - **output_size** (int|list|tuple)：算子输出特征图的长度，其数据类型为 int 或 list，tuple。
     - **return_mask** (bool，可选)：如果设置为 True，则会与输出一起返回最大值的索引，默认为 False。
+      ``别名：return_indices``
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/nn/functional/adaptive_max_pool3d_cn.rst b/docs/api/paddle/nn/functional/adaptive_max_pool3d_cn.rst
index 2f6e30cfd79..6253812ac10 100644
--- a/docs/api/paddle/nn/functional/adaptive_max_pool3d_cn.rst
+++ b/docs/api/paddle/nn/functional/adaptive_max_pool3d_cn.rst
@@ -7,15 +7,20 @@ adaptive_max_pool3d
 根据输入 `x` , `output_size` 等参数对一个输入 Tensor 计算 3D 的自适应最大值池化。输入和输出都是 5-D Tensor，
 默认是以 `NCDHW` 格式表示的，其中 `N` 是 batch size, `C` 是通道数，`D` , `H` , `W` 是输入特征的深度，高度，宽度。
 
-.. note::
-   详细请参考对应的 `Class` 请参考：:ref:`cn_api_paddle_nn_AdaptiveMaxPool3D` 。
+
+..  note::
+    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
+
+    详细请参考对应的 `Class` 请参考：:ref:`cn_api_paddle_nn_AdaptiveMaxPool3D` 。
 
 
 参数
 :::::::::
     - **x** (Tensor)：当前算子的输入，其是一个形状为 `[N, C, D, H, W]` 的 5-D Tensor。其中 `N` 是 batch size, `C` 是通道数，`D` , `H` , `W` 是输入特征的深度，高度，宽度。其数据类型为 float32 或者 float64。
+      ``别名：input``
     - **output_size** (int|list|tuple)：算子输出特征图的长度，其数据类型为 int 或 list，tuple。
     - **return_mask** (bool，可选)：如果设置为 True，则会与输出一起返回最大值的索引，默认为 False。
+      ``别名：return_indices``
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/nn/functional/max_pool2d_cn.rst b/docs/api/paddle/nn/functional/max_pool2d_cn.rst
index c6d770c3aab..530e345a65b 100644
--- a/docs/api/paddle/nn/functional/max_pool2d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool2d_cn.rst
@@ -21,6 +21,7 @@ max_pool2d
                                     & \text{input}(N_i, C_j, \text{stride[0]} \times h + m,
                                                    \text{stride[1]} \times w + n)
 
+
 ..  note::
     别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
 
diff --git a/docs/api/paddle/nn/functional/max_pool3d_cn.rst b/docs/api/paddle/nn/functional/max_pool3d_cn.rst
index 4d86a3271bf..eeef0459f01 100644
--- a/docs/api/paddle/nn/functional/max_pool3d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool3d_cn.rst
@@ -3,7 +3,7 @@
 max_pool3d
 -------------------------------
 
-.. py:function:: paddle.nn.functional.max_pool3d(x, kernel_size, stride=None, padding=0, ceil_mode=False, return_mask=False, data_format="NCDHW", name=None))
+.. py:function:: paddle.nn.functional.max_pool3d(x, kernel_size, stride=None, padding=0, ceil_mode=False, return_mask=False, data_format="NCDHW", name=None)
 该函数是一个三维最大池化函数，根据输入参数 `kernel_size`, `stride`,
 `padding` 等参数对输入 `x` 做最大池化操作。
 

From 4ff9a5bbcf92c7084be9d50158a6d36b03591ed7 Mon Sep 17 00:00:00 2001
From: iLeGend <824040212@qq.com>
Date: Thu, 5 Feb 2026 00:48:36 -0800
Subject: [PATCH 05/13] fix fmt

---
 docs/api/paddle/nn/functional/adaptive_max_pool1d_cn.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/api/paddle/nn/functional/adaptive_max_pool1d_cn.rst b/docs/api/paddle/nn/functional/adaptive_max_pool1d_cn.rst
index 0e76efb8924..113a4aa88bb 100755
--- a/docs/api/paddle/nn/functional/adaptive_max_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/adaptive_max_pool1d_cn.rst
@@ -11,7 +11,7 @@ adaptive_max_pool1d
 
 ..  note::
     别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``return_indices`` 可替代 ``return_mask``。
- 
+
     详细请参考对应的 `Class` 请参考：:ref:`cn_api_paddle_nn_AdaptiveMaxPool1D` 。
 
 

From 65a9b46edac5de1b98386a37f15864811b44a71b Mon Sep 17 00:00:00 2001
From: iLeGend <824040212@qq.com>
Date: Sun, 8 Feb 2026 07:49:33 -0800
Subject: [PATCH 06/13] fix F.max_pool3d param list seq

---
 docs/api/paddle/nn/functional/max_pool3d_cn.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/api/paddle/nn/functional/max_pool3d_cn.rst b/docs/api/paddle/nn/functional/max_pool3d_cn.rst
index eeef0459f01..6479bb3d9b8 100644
--- a/docs/api/paddle/nn/functional/max_pool3d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool3d_cn.rst
@@ -3,7 +3,7 @@
 max_pool3d
 -------------------------------
 
-.. py:function:: paddle.nn.functional.max_pool3d(x, kernel_size, stride=None, padding=0, ceil_mode=False, return_mask=False, data_format="NCDHW", name=None)
+.. py:function:: paddle.nn.functional.max_pool3d(x, kernel_size, stride=None, padding=0, return_mask=False, ceil_mode=False, data_format="NCDHW", name=None)
 该函数是一个三维最大池化函数，根据输入参数 `kernel_size`, `stride`,
 `padding` 等参数对输入 `x` 做最大池化操作。
 
@@ -32,9 +32,9 @@ max_pool3d
     - **stride** (int|list|tuple) - 池化层的步长。如果它是一个元组或列表，它将包含三个整数，(pool_stride_Depth，pool_stride_Height, pool_stride_Width)。若为一个整数，则表示 D, H 和 W 维度上 stride 均为该值。默认值为 kernel_size。
     - **padding** (string|int|list|tuple) - 池化填充。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 3 个整数值：[pad_depth, pad_height, pad_width]；(2)包含 6 个整数值：[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；(3)包含 5 个二元组：当 data_format 为"NCDHW"时为[[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当 data_format 为"NDHWC"时为[[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：0。
     - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含 3 个整数：[dilation_depth, dilation_height, dilation_width]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：1。
-    - **ceil_mode** (bool) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 False。
     - **return_mask** (bool) - 是否返回最大索引和输出。默认为 False。
       ``别名：return_indices``
+    - **ceil_mode** (bool) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 False。
     - **data_format** (str) - 输入和输出的数据格式，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值："NDCHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 

From 92f9dec6b3979b314ee53c89acca002e014bb976 Mon Sep 17 00:00:00 2001
From: iLeGend <824040212@qq.com>
Date: Thu, 12 Feb 2026 17:37:18 +0800
Subject: [PATCH 07/13] update

---
 docs/api/paddle/nn/MaxPool1D_cn.rst             | 4 ++--
 docs/api/paddle/nn/MaxPool2D_cn.rst             | 6 +++---
 docs/api/paddle/nn/MaxPool3D_cn.rst             | 6 +++---
 docs/api/paddle/nn/functional/max_pool1d_cn.rst | 4 ++--
 docs/api/paddle/nn/functional/max_pool2d_cn.rst | 6 +++---
 docs/api/paddle/nn/functional/max_pool3d_cn.rst | 4 ++--
 6 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/docs/api/paddle/nn/MaxPool1D_cn.rst b/docs/api/paddle/nn/MaxPool1D_cn.rst
index 428e3ddcbb4..dfcc6d686ab 100755
--- a/docs/api/paddle/nn/MaxPool1D_cn.rst
+++ b/docs/api/paddle/nn/MaxPool1D_cn.rst
@@ -3,7 +3,7 @@
 MaxPool1D
 -------------------------------
 
-.. py:class:: paddle.nn.MaxPool1D(kernel_size, stride=None, padding=0, return_mask=False, ceil_mode=False, name=None)
+.. py:class:: paddle.nn.MaxPool1D(kernel_size, stride=None, padding=0, return_mask=False, ceil_mode=False, dilation=1, name=None)
 
 根据输入 `x` ， `kernel_size` 等参数对一个输入 Tensor 计算 1D 的最大值池化。输入和输出都是 3-D Tensor，默认是以 `NCL` 格式表示的，其中 `N` 是 batch size，`C` 是通道数，`L` 是输入特征的长度。
 
@@ -22,10 +22,10 @@ MaxPool1D
     - **kernel_size** (int|list|tuple) - 池化核的尺寸大小。如果 kernel_size 为 list 或 tuple 类型，其必须包含一个整数，最终池化核的大小为该数值。
     - **stride** (int|list|tuple，可选) - 池化操作步长。如果 stride 为 list 或 tuple 类型，其必须包含一个整数，最终池化操作的步长为该数值。默认值为 None，这时会使用 kernel_size 作为 stride。
     - **padding** (str|int|list|tuple，可选) - 池化补零的方式。如果 padding 是一个字符串，则必须为 `SAME` 或者 `VALID`。如果是 tuple 或者 list 类型，若其长度为 1，则会在输入的两端都填充上长度为 padding[0] 的 0，若其长度为 2，则应是 `[pad_before, pad_after]` 形式。如果 padding 是一个非 0 整数，那么表示会在输入的两端都填充上同样长度的 0。如果 padding 是长度为 2 的序列组成的 list 或 tuple，则其中的每个元素表示在相应维度上的填充长度。注意：在 batch_size 维度和通道维度应该设置为 [0, 0] 或 (0, 0)。默认值为 0。
-    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含一个整数。默认值为 1。
     - **return_mask** (bool，可选) - 是否返回最大值的索引，默认为 False。
       ``别名：return_indices``
     - **ceil_mode** (bool，可选) - 是否用 ceil 函数计算输出的 height 和 width，如果设置为 False，则使用 floor 函数来计算，默认为 False。
+    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含一个整数。默认值为 1。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
diff --git a/docs/api/paddle/nn/MaxPool2D_cn.rst b/docs/api/paddle/nn/MaxPool2D_cn.rst
index 7c749775e65..e44797f91a8 100644
--- a/docs/api/paddle/nn/MaxPool2D_cn.rst
+++ b/docs/api/paddle/nn/MaxPool2D_cn.rst
@@ -3,7 +3,7 @@
 MaxPool2D
 -------------------------------
 
-.. py:class:: paddle.nn.MaxPool2D(kernel_size, stride=None, padding=0, ceil_mode=False, return_mask=False, data_format="NCHW", name=None)
+.. py:class:: paddle.nn.MaxPool2D(kernel_size, stride=None, padding=0, return_mask=False, ceil_mode=False, dilation=1, data_format="NCHW", name=None)
 构建 `MaxPool2D` 类的一个可调用对象，其将构建一个二维最大池化层，根据输入参数 `kernel_size`, `stride`,
 `padding` 等参数对输入做最大池化操作。
 
@@ -30,10 +30,10 @@ MaxPool2D
     - **kernel_size** (int|list|tuple) - 池化核大小。如果它是一个元组或列表，它必须包含两个整数值，(pool_size_Height, pool_size_Width)。若为一个整数，则它的平方值将作为池化核大小，比如若 pool_size=2，则池化核大小为 2x2。
     - **stride** (int|list|tuple，可选) - 池化层的步长。如果它是一个元组或列表，它将包含两个整数，(pool_stride_Height, pool_stride_Width)。若为一个整数，则表示 H 和 W 维度上 stride 均为该值。默认值为 None，这时会使用 kernel_size 作为 stride。
     - **padding** (str|int|list|tuple，可选) - 池化填充。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 2 个整数值：[pad_height, pad_width]；(2)包含 4 个整数值：[pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；(3)包含 4 个二元组：当 data_format 为"NCHW"时为 [[0,0], [0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当 data_format 为"NHWC"时为[[0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]。若为一个整数，则表示 H 和 W 维度上均为该值。默认值：0。
-    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含两个整数：[dilation_height, dilation_width]。若为一个整数，则表示 H 和 W 维度上均为该值。默认值：1。
-    - **ceil_mode** (bool，可选) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。
     - **return_mask** (bool，可选) - 是否返回最大索引和输出。默认为 False。
       ``别名：return_indices``
+    - **ceil_mode** (bool，可选) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。
+    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含两个整数：[dilation_height, dilation_width]。若为一个整数，则表示 H 和 W 维度上均为该值。默认值：1。
     - **data_format** (str，可选) - 输入和输出的数据格式，可以是"NCHW"和"NHWC"。N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。默认值："NCHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/nn/MaxPool3D_cn.rst b/docs/api/paddle/nn/MaxPool3D_cn.rst
index 56b00d18476..dbc2e089c94 100644
--- a/docs/api/paddle/nn/MaxPool3D_cn.rst
+++ b/docs/api/paddle/nn/MaxPool3D_cn.rst
@@ -3,7 +3,7 @@
 MaxPool3D
 -------------------------------
 
-.. py:class:: paddle.nn.MaxPool3D(kernel_size, stride=None, padding=0, ceil_mode=False, return_mask=False, data_format="NCDHW", name=None)
+.. py:class:: paddle.nn.MaxPool3D(kernel_size, stride=None, padding=0, return_mask=False, ceil_mode=False, dilation=1, data_format="NCDHW", name=None)
 构建 `MaxPool3D` 类的一个可调用对象，其将构建一个二维最大池化层，根据输入参数 `kernel_size`, `stride`,
 `padding` 等参数对输入做最大池化操作。
 
@@ -30,10 +30,10 @@ MaxPool3D
     - **kernel_size** (int|list|tuple) - 池化核大小。如果它是一个元组或列表，它必须包含三个整数值，(pool_size_Depth，pool_size_Height, pool_size_Width)。若为一个整数，则表示 D，H 和 W 维度上均为该值，比如若 pool_size=2，则池化核大小为[2,2,2]。
     - **stride** (int|list|tuple，可选) - 池化层的步长。如果它是一个元组或列表，它将包含三个整数，(pool_stride_Depth，pool_stride_Height, pool_stride_Width)。若为一个整数，则表示 D, H 和 W 维度上 stride 均为该值。默认值为 None，这时会使用 kernel_size 作为 stride。
     - **padding** (str|int|list|tuple，可选) - 池化填充。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 3 个整数值：[pad_depth, pad_height, pad_width]；(2)包含 6 个整数值：[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；(3)包含 5 个二元组：当 data_format 为"NCDHW"时为[[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当 data_format 为"NDHWC"时为[[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：0。
-    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含 3 个整数：[dilation_depth, dilation_height, dilation_width]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：1。
-    - **ceil_mode** (bool，可选) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 False。
     - **return_mask** (bool，可选) - 是否返回最大索引和输出。默认为 False。
       ``别名：return_indices``
+    - **ceil_mode** (bool，可选) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 False。
+    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含 3 个整数：[dilation_depth, dilation_height, dilation_width]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：1。
     - **data_format** (str，可选) - 输入和输出的数据格式，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值："NDCHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/nn/functional/max_pool1d_cn.rst b/docs/api/paddle/nn/functional/max_pool1d_cn.rst
index b8754505112..7447b619b8e 100755
--- a/docs/api/paddle/nn/functional/max_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool1d_cn.rst
@@ -3,7 +3,7 @@
 max_pool1d
 -------------------------------
 
-.. py:function:: paddle.nn.functional.max_pool1d(x, kernel_size, stride=None, padding=0, return_mask=False, ceil_mode=False, name=None)
+.. py:function:: paddle.nn.functional.max_pool1d(x, kernel_size, stride=None, padding=0, return_mask=False, ceil_mode=False, dilation=1, name=None)
 
 根据输入 `x` , `kernel_size` 等参数对一个输入 Tensor 计算 1D 的最大值池化。输入和输出都是 3-D Tensor，
 默认是以 `NCL` 格式表示的，其中 `N` 是 batch size, `C` 是通道数，`L` 是输入特征的长度。
@@ -21,10 +21,10 @@ max_pool1d
     - **kernel_size** (int|list|tuple) - 池化核的尺寸大小。如果 kernel_size 为 list 或 tuple 类型，其必须包含一个整数。
     - **stride** (int|list|tuple) - 池化操作步长。如果 stride 为 list 或 tuple 类型，其必须包含一个整数。
     - **padding** (string|int|list|tuple) - 池化补零的方式。如果 padding 是一个字符串，则必须为 `SAME` 或者 `VALID`。如果是 tuple 或者 list 类型，则应是 `[pad_left, pad_right]` 形式。如果 padding 是一个非 0 值，那么表示会在输入的两端都 padding 上同样长度的 0。
-    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含一个整数。默认值为 1。
     - **return_mask** (bool) - 是否返回最大值的索引，默认为 False。
       ``别名：return_indices``
     - **ceil_mode** (bool) - 是否用 ceil 函数计算输出的 height 和 width，如果设置为 False，则使用 floor 函数来计算，默认为 False。
+      **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含一个整数。默认值为 1。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
diff --git a/docs/api/paddle/nn/functional/max_pool2d_cn.rst b/docs/api/paddle/nn/functional/max_pool2d_cn.rst
index 530e345a65b..f24660c036a 100644
--- a/docs/api/paddle/nn/functional/max_pool2d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool2d_cn.rst
@@ -3,7 +3,7 @@
 max_pool2d
 -------------------------------
 
-.. py:function:: paddle.nn.functional.max_pool2d(x, kernel_size, stride=None, padding=0, ceil_mode=False, return_mask=False, data_format="NCHW", name=None)
+.. py:function:: paddle.nn.functional.max_pool2d(x, kernel_size, stride=None, padding=0, return_mask=False, ceil_mode=False, dilation=1, data_format="NCHW", name=None)
 构建 `max_pool2d` 类的一个可调用对象，其将构建一个二维平均池化层，根据输入参数 `kernel_size`, `stride`,
 `padding` 等参数对输入做最大池化操作。
 
@@ -32,10 +32,10 @@ max_pool2d
     - **kernel_size** (int|list|tuple) - 池化核大小。如果它是一个元组或列表，它必须包含两个整数值，(pool_size_Height, pool_size_Width)。若为一个整数，则它的平方值将作为池化核大小，比如若 pool_size=2，则池化核大小为 2x2。
     - **stride** (int|list|tuple) - 池化层的步长。如果它是一个元组或列表，它将包含两个整数，(pool_stride_Height, pool_stride_Width)。若为一个整数，则表示 H 和 W 维度上 stride 均为该值。默认值为 kernel_size。
     - **padding** (string|int|list|tuple) - 池化填充。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 2 个整数值：[pad_height, pad_width]；(2)包含 4 个整数值：[pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；(3)包含 4 个二元组：当 data_format 为"NCHW"时为 [[0,0], [0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当 data_format 为"NHWC"时为[[0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]。若为一个整数，则表示 H 和 W 维度上均为该值。默认值：0。
-    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含两个整数：[dilation_height, dilation_width]。若为一个整数，则表示 H 和 W 维度上均为该值。默认值：1。
-    - **ceil_mode** (bool) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 None。
     - **return_mask** (bool) - 是否返回最大索引和输出。默认为 False。
       ``别名：return_indices``
+    - **ceil_mode** (bool) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 None。
+    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含两个整数：[dilation_height, dilation_width]。若为一个整数，则表示 H 和 W 维度上均为该值。默认值：1。
     - **data_format** (str) - 输入和输出的数据格式，可以是"NCHW"和"NHWC"。N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。默认值："NCHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/nn/functional/max_pool3d_cn.rst b/docs/api/paddle/nn/functional/max_pool3d_cn.rst
index 6479bb3d9b8..111be26c002 100644
--- a/docs/api/paddle/nn/functional/max_pool3d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool3d_cn.rst
@@ -3,7 +3,7 @@
 max_pool3d
 -------------------------------
 
-.. py:function:: paddle.nn.functional.max_pool3d(x, kernel_size, stride=None, padding=0, return_mask=False, ceil_mode=False, data_format="NCDHW", name=None)
+.. py:function:: paddle.nn.functional.max_pool3d(x, kernel_size, stride=None, padding=0, return_mask=False, ceil_mode=False, dilation=1, data_format="NCDHW", name=None)
 该函数是一个三维最大池化函数，根据输入参数 `kernel_size`, `stride`,
 `padding` 等参数对输入 `x` 做最大池化操作。
 
@@ -31,10 +31,10 @@ max_pool3d
     - **kernel_size** (int|list|tuple) - 池化核大小。如果它是一个元组或列表，它必须包含三个整数值，(pool_size_Depth，pool_size_Height, pool_size_Width)。若为一个整数，则表示 D，H 和 W 维度上均为该值，比如若 pool_size=2，则池化核大小为[2,2,2]。
     - **stride** (int|list|tuple) - 池化层的步长。如果它是一个元组或列表，它将包含三个整数，(pool_stride_Depth，pool_stride_Height, pool_stride_Width)。若为一个整数，则表示 D, H 和 W 维度上 stride 均为该值。默认值为 kernel_size。
     - **padding** (string|int|list|tuple) - 池化填充。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 3 个整数值：[pad_depth, pad_height, pad_width]；(2)包含 6 个整数值：[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；(3)包含 5 个二元组：当 data_format 为"NCDHW"时为[[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当 data_format 为"NDHWC"时为[[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：0。
-    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含 3 个整数：[dilation_depth, dilation_height, dilation_width]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：1。
     - **return_mask** (bool) - 是否返回最大索引和输出。默认为 False。
       ``别名：return_indices``
     - **ceil_mode** (bool) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 False。
+    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含 3 个整数：[dilation_depth, dilation_height, dilation_width]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：1。
     - **data_format** (str) - 输入和输出的数据格式，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值："NDCHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 

From 502278f8b859d60cdf14fe02fb6b207d83ef3fa2 Mon Sep 17 00:00:00 2001
From: iLeGend <824040212@qq.com>
Date: Thu, 12 Feb 2026 17:58:10 +0800
Subject: [PATCH 08/13] Update docs/api/paddle/nn/functional/max_pool2d_cn.rst

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 docs/api/paddle/nn/functional/max_pool2d_cn.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/api/paddle/nn/functional/max_pool2d_cn.rst b/docs/api/paddle/nn/functional/max_pool2d_cn.rst
index f24660c036a..64280be0809 100644
--- a/docs/api/paddle/nn/functional/max_pool2d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool2d_cn.rst
@@ -34,7 +34,7 @@ max_pool2d
     - **padding** (string|int|list|tuple) - 池化填充。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 2 个整数值：[pad_height, pad_width]；(2)包含 4 个整数值：[pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；(3)包含 4 个二元组：当 data_format 为"NCHW"时为 [[0,0], [0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当 data_format 为"NHWC"时为[[0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]。若为一个整数，则表示 H 和 W 维度上均为该值。默认值：0。
     - **return_mask** (bool) - 是否返回最大索引和输出。默认为 False。
       ``别名：return_indices``
-    - **ceil_mode** (bool) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 None。
+    - **ceil_mode** (bool) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 False。
     - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含两个整数：[dilation_height, dilation_width]。若为一个整数，则表示 H 和 W 维度上均为该值。默认值：1。
     - **data_format** (str) - 输入和输出的数据格式，可以是"NCHW"和"NHWC"。N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。默认值："NCHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。

From d40718bf273f1f0c7e030150e6beaa771ca2eb66 Mon Sep 17 00:00:00 2001
From: iLeGend <824040212@qq.com>
Date: Thu, 12 Feb 2026 17:59:06 +0800
Subject: [PATCH 09/13] Update docs/api/paddle/nn/functional/max_pool1d_cn.rst

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 docs/api/paddle/nn/functional/max_pool1d_cn.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/api/paddle/nn/functional/max_pool1d_cn.rst b/docs/api/paddle/nn/functional/max_pool1d_cn.rst
index 7447b619b8e..c2b727cde6a 100755
--- a/docs/api/paddle/nn/functional/max_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool1d_cn.rst
@@ -24,7 +24,7 @@ max_pool1d
     - **return_mask** (bool) - 是否返回最大值的索引，默认为 False。
       ``别名：return_indices``
     - **ceil_mode** (bool) - 是否用 ceil 函数计算输出的 height 和 width，如果设置为 False，则使用 floor 函数来计算，默认为 False。
-      **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含一个整数。默认值为 1。
+    - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含一个整数。默认值为 1。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 

From df654139f31c22f80a77ce9e07f877d4aa4c6082 Mon Sep 17 00:00:00 2001
From: iLeGend <824040212@qq.com>
Date: Thu, 12 Feb 2026 17:59:22 +0800
Subject: [PATCH 10/13] Update docs/api/paddle/nn/MaxPool3D_cn.rst

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 docs/api/paddle/nn/MaxPool3D_cn.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/api/paddle/nn/MaxPool3D_cn.rst b/docs/api/paddle/nn/MaxPool3D_cn.rst
index dbc2e089c94..e1ff94bbbec 100644
--- a/docs/api/paddle/nn/MaxPool3D_cn.rst
+++ b/docs/api/paddle/nn/MaxPool3D_cn.rst
@@ -4,7 +4,7 @@ MaxPool3D
 -------------------------------
 
 .. py:class:: paddle.nn.MaxPool3D(kernel_size, stride=None, padding=0, return_mask=False, ceil_mode=False, dilation=1, data_format="NCDHW", name=None)
-构建 `MaxPool3D` 类的一个可调用对象，其将构建一个二维最大池化层，根据输入参数 `kernel_size`, `stride`,
+构建 `MaxPool3D` 类的一个可调用对象，其将构建一个三维最大池化层，根据输入参数 `kernel_size`, `stride`,
 `padding` 等参数对输入做最大池化操作。
 
 例如：

From 5bffb363eac79f51d39b9271215a8437cce8fa5f Mon Sep 17 00:00:00 2001
From: iLeGend <824040212@qq.com>
Date: Thu, 12 Feb 2026 17:59:48 +0800
Subject: [PATCH 11/13] Update docs/api/paddle/nn/functional/max_pool2d_cn.rst

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 docs/api/paddle/nn/functional/max_pool2d_cn.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/api/paddle/nn/functional/max_pool2d_cn.rst b/docs/api/paddle/nn/functional/max_pool2d_cn.rst
index 64280be0809..11ab9ab35dd 100644
--- a/docs/api/paddle/nn/functional/max_pool2d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool2d_cn.rst
@@ -4,7 +4,7 @@ max_pool2d
 -------------------------------
 
 .. py:function:: paddle.nn.functional.max_pool2d(x, kernel_size, stride=None, padding=0, return_mask=False, ceil_mode=False, dilation=1, data_format="NCHW", name=None)
-构建 `max_pool2d` 类的一个可调用对象，其将构建一个二维平均池化层，根据输入参数 `kernel_size`, `stride`,
+构建 `max_pool2d` 类的一个可调用对象，其将构建一个二维最大池化层，根据输入参数 `kernel_size`, `stride`,
 `padding` 等参数对输入做最大池化操作。
 
 例如：

From ea2357db91fadff3ca82851a3efacb683944343d Mon Sep 17 00:00:00 2001
From: iLeGend <824040212@qq.com>
Date: Thu, 12 Feb 2026 17:59:59 +0800
Subject: [PATCH 12/13] Update docs/api/paddle/nn/functional/max_pool3d_cn.rst

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 docs/api/paddle/nn/functional/max_pool3d_cn.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/api/paddle/nn/functional/max_pool3d_cn.rst b/docs/api/paddle/nn/functional/max_pool3d_cn.rst
index 111be26c002..b246336eed5 100644
--- a/docs/api/paddle/nn/functional/max_pool3d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool3d_cn.rst
@@ -35,7 +35,7 @@ max_pool3d
       ``别名：return_indices``
     - **ceil_mode** (bool) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 False。
     - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含 3 个整数：[dilation_depth, dilation_height, dilation_width]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：1。
-    - **data_format** (str) - 输入和输出的数据格式，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值："NDCHW"。
+    - **data_format** (str) - 输入和输出的数据格式，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值："NCDHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 

From 1f1a8396c7cfccf7d4daf81043e1cd1179fb0c46 Mon Sep 17 00:00:00 2001
From: iLeGend <824040212@qq.com>
Date: Thu, 12 Feb 2026 18:00:29 +0800
Subject: [PATCH 13/13] Update docs/api/paddle/nn/MaxPool3D_cn.rst

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 docs/api/paddle/nn/MaxPool3D_cn.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/api/paddle/nn/MaxPool3D_cn.rst b/docs/api/paddle/nn/MaxPool3D_cn.rst
index e1ff94bbbec..e6bbd8ca6f4 100644
--- a/docs/api/paddle/nn/MaxPool3D_cn.rst
+++ b/docs/api/paddle/nn/MaxPool3D_cn.rst
@@ -34,7 +34,7 @@ MaxPool3D
       ``别名：return_indices``
     - **ceil_mode** (bool，可选) - 是否用 ceil 函数计算输出高度和宽度。如果是 True，则使用 `ceil` 计算输出形状的大小。默认为 False。
     - **dilation** (int|list|tuple，可选) - 空洞池化步长，如果 dilation 为 list 或 tuple 类型，其必须包含 3 个整数：[dilation_depth, dilation_height, dilation_width]。若为一个整数，则表示 D、H 和 W 维度上均为该值。默认值：1。
-    - **data_format** (str，可选) - 输入和输出的数据格式，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值："NDCHW"。
+    - **data_format** (str，可选) - 输入和输出的数据格式，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值："NCDHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。