fix 4 same name apis (#5195)

Author: SigureMo

docs/api/paddle/metric/Accuracy__upper_cn.rst

@@ -3,89 +3,90 @@
 Accuracy
 -------------------------------
 
-.. py:class:: paddle.metric.Accuracy()
+.. py:class:: paddle.metric.Accuracy(topk=(1, ), name=None, *args, **kwargs)
+
 
 计算准确率(accuracy)。
 
 参数：
 :::::::::
-    - **topk** (int|tuple(int)) - 计算准确率的top个数，默认是1。
-    - **name** (str, optional) - metric实例的名字，默认是'acc'。
+    - **topk** (list[int]|tuple[int]，可选) - 计算准确率的 top 个数，默认值为 (1,)。
+    - **name** (str，可选) - metric 实例的名字。默认值为 None，表示使用默认名字 'acc'。
 
 代码示例
 :::::::::
 
 **独立使用示例:**
-        
+
     .. code-block:: python
 
         import numpy as np
         import paddle
-
         x = paddle.to_tensor(np.array([
             [0.1, 0.2, 0.3, 0.4],
             [0.1, 0.4, 0.3, 0.2],
             [0.1, 0.2, 0.4, 0.3],
             [0.1, 0.2, 0.3, 0.4]]))
         y = paddle.to_tensor(np.array([[0], [1], [2], [3]]))
-
         m = paddle.metric.Accuracy()
         correct = m.compute(x, y)
         m.update(correct)
         res = m.accumulate()
         print(res) # 0.75
 
 
-**在Model API中的示例**
-        
+**在 Model API 中的示例**
+
     .. code-block:: python
 
         import paddle
         from paddle.static import InputSpec
         import paddle.vision.transforms as T
         from paddle.vision.datasets import MNIST
-               
+
         input = InputSpec([None, 1, 28, 28], 'float32', 'image')
         label = InputSpec([None, 1], 'int64', 'label')
         transform = T.Compose([T.Transpose(), T.Normalize([127.5], [127.5])])
         train_dataset = MNIST(mode='train', transform=transform)
-  
+
         model = paddle.Model(paddle.vision.models.LeNet(), input, label)
         optim = paddle.optimizer.Adam(
             learning_rate=0.001, parameters=model.parameters())
         model.prepare(
             optim,
             loss=paddle.nn.CrossEntropyLoss(),
             metrics=paddle.metric.Accuracy())
-  
-        model.fit(train_dataset, batch_size=64)
 
+        model.fit(train_dataset, batch_size=64)
 
 
 compute(pred, label, *args)
 :::::::::
 
-计算top-k（topk中的最大值）的索引。
+计算 top-k（topk 中的最大值）的索引。
 
 **参数**
-    
-    - **pred**  (Tensor) - 预测结果为是float64或float32类型的Tensor。shape为[batch_size, d0, ..., dN].
-    - **label**  (Tensor) - 真实的标签值是一个int64类型的Tensor，shape为[batch_size, d0, ..., 1] 或one hot表示的形状[batch_size, d0, ..., num_classes].
 
-**返回**: Tensor，shape是[batch_size, d0, ..., topk], 值为0或1，1表示预测正确.
+    - **pred** (Tensor) - 预测结果为是 float64 或 float32 类型的 Tensor。shape 为[batch_size, d0, ..., dN].
+    - **label** (Tensor) - 真实的标签值是一个 int64 类型的 Tensor，shape 为[batch_size, d0, ..., 1] 或 one hot 表示的形状[batch_size, d0, ..., num_classes].
+
+**返回**
+
+Tensor，shape 是[batch_size, d0, ..., topk], 值为 0 或 1，1 表示预测正确.
 
 
-update(pred, label, *args)
+update(correct, *args)
 :::::::::
 
-更新metric的状态（正确预测的个数和总个数），以便计算累积的准确率。返回当前step的准确率。
+更新 metric 的状态（正确预测的个数和总个数），以便计算累积的准确率。返回当前 step 的准确率。
 
-**参数:**
+**参数**
 
-    - **correct** (numpy.array | Tensor): 一个值为0或1的Tensor，shape是[batch_size, d0, ..., topk]。
+    - **correct** (numpy.array | Tensor): 一个值为 0 或 1 的 Tensor，shape 是[batch_size, d0, ..., topk]。
 
-**返回:** 当前step的准确率。
+**返回**
 
+当前 step 的准确率。
 
 reset()
 :::::::::
@@ -97,12 +98,16 @@ accumulate()
 
 累积的统计指标，计算和返回准确率。
 
-**返回:** 准确率，一般是个标量 或 多个标量，和topk的个数一致。
+**返回**
+
+准确率，一般是个标量 或 多个标量，和 topk 的个数一致。
 
 
 name()
 :::::::::
 
-返回Metric实例的名字, 参考上述name，默认是'acc'。
+返回 Metric 实例的名字, 参考上述 name，默认是'acc'。
+
+**返回**
 
-**返回:** 评估的名字，string类型。
+评估的名字，string 类型。

docs/api/paddle/metric/accuracy_cn.rst

@@ -5,33 +5,26 @@ accuracy
 
 .. py:function:: paddle.metric.accuracy(input, label, k=1, correct=None, total=None, name=None)
 
-accuracy layer。 参考 https://en.wikipedia.org/wiki/Precision_and_recall
+accuracy layer。参考 https://en.wikipedia.org/wiki/Precision_and_recall
 
-使用输入和标签计算准确率。 如果正确的标签在topk个预测值里，则计算结果加1。注意：输出正确率的类型由input类型决定，input和lable的类型可以不一样。
+使用输入和标签计算准确率。如果正确的标签在 topk 个预测值里，则计算结果加 1。注意：输出正确率的类型由 input 类型决定，input 和 lable 的类型可以不一样。
 
 参数
 :::::::::
 
-    - **input** (Tensor)-数据类型为float32,float64。输入为网络的预测值。shape为 ``[sample_number, class_dim]`` 。
-    - **label** (Tensor)-数据类型为int64，int32。输入为数据集的标签。shape为 ``[sample_number, 1]`` 。
-    - **k** (int64|int32，可选) - 取每个类别中k个预测值用于计算，默认值为1。
-    - **correct** (int64|int32, 可选)-正确预测值的个数，默认值为None。
-    - **total** (int64|int32，可选)-总共的预测值，默认值为None。
-    - **name** (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
+    - **input** (Tensor)-数据类型为 float32,float64。输入为网络的预测值。shape 为 ``[sample_number, class_dim]`` 。
+    - **label** (Tensor)-数据类型为 int64。输入为数据集的标签。shape 为 ``[sample_number, 1]`` 。
+    - **k** (int，可选) - 取每个类别中 k 个预测值用于计算，默认值为 1。
+    - **correct** (int，可选) - 正确预测值的个数，默认值为 None。
+    - **total** (int，可选) - 总共的预测值，默认值为 None。
+    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
 
-    ``Tensor``，计算出来的正确率，数据类型为float32的Tensor。
+    ``Tensor``，计算出来的正确率，数据类型为 float32 的 Tensor。
 
 代码示例
 :::::::::
 
-.. code-block:: python
-
-    import paddle
-
-    predictions = paddle.to_tensor([[0.2, 0.1, 0.4, 0.1, 0.1], [0.2, 0.3, 0.1, 0.15, 0.25]], dtype='float32')
-    label = paddle.to_tensor([[2], [0]], dtype="int64")
-    result = paddle.metric.accuracy(input=predictions, label=label, k=1)
-    # [0.5]
+COPY-FROM: paddle.metric.accuracy

docs/api/paddle/vision/transforms/Normalize__upper_cn.rst

@@ -5,50 +5,29 @@ Normalize
 
 .. py:class:: paddle.vision.transforms.Normalize(mean=0.0, std=1.0, data_format='CHW', to_rgb=False, keys=None)
 
-图像归一化处理，支持两种方式：
-1. 用统一的均值和标准差值对图像的每个通道进行归一化处理；
-2. 对每个通道指定不同的均值和标准差值进行归一化处理。
-
-计算过程：
-
-``output[channel] = (input[channel] - mean[channel]) / std[channel]``
+用均值和标准差归一化输入数据。给定 n 个通道的均值(M1,...,Mn)和方差(S1,..,Sn)，Normalize 会在每个通道归一化输入数据。output[channel] = (input[channel] - mean[channel]) / std[channel]
 
 参数
 :::::::::
 
-    - mean (int|float|list) - 用于每个通道归一化的均值。
-    - std (int|float|list) - 用于每个通道归一化的标准差值。
-    - data_format (str, optional): 数据的格式，必须为 'HWC' 或 'CHW'。 默认值: 'CHW'。
-    - to_rgb (bool, optional) - 是否转换为 ``rgb`` 的格式。默认值：False。
-    - keys (list[str]|tuple[str], optional) - 与 ``BaseTransform``. 默认值: None。
+    - **mean** (list|tuple，可选) - 用于每个通道归一化的均值。
+    - **std** (list|tuple，可选) - 用于每个通道归一化的标准差值。
+    - **data_format** (str，可选) - 数据的格式，必须为 'HWC' 或 'CHW'。 默认值为 'CHW'。
+    - **to_rgb** (bool，可选) - 是否转换为 ``rgb`` 的格式。默认值为 False。
+    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值为 None。
 
 形状
 :::::::::
 
-    - img (PIL.Image|np.ndarray|Paddle.Tensor) - 输入的图像数据，数据格式为'HWC'。
+    - img (PIL.Image|np.ndarray|paddle.Tensor) - 输入的图像数据，数据格式为'HWC'。
     - output (PIL.Image|np.ndarray|Paddle.Tensor) - 返回归一化后的图像数据。
 
 返回
 :::::::::
 
-    计算 ``Normalize`` 的可调用对象。
+计算 ``Normalize`` 的可调用对象。
 
 代码示例
 :::::::::
-    
-.. code-block:: python
-
-    import numpy as np
-    from PIL import Image
-    from paddle.vision.transforms import Normalize
-
-    normalize = Normalize(mean=[127.5, 127.5, 127.5], 
-                            std=[127.5, 127.5, 127.5],
-                            data_format='HWC')
-
-    fake_img = Image.fromarray((np.random.rand(300, 320, 3) * 255.).astype(np.uint8))
 
-    fake_img = normalize(fake_img)
-    print(fake_img.shape)
-    print(fake_img.max, fake_img.max)
-    
+COPY-FROM: paddle.vision.transforms.Normalize

docs/api/paddle/vision/transforms/Pad__upper_cn.rst

@@ -10,10 +10,16 @@ Pad
 参数
 :::::::::
 
-    - padding (int|list|tuple) -   在图像边界上进行填充的范围。如果提供的是单个int值，则该值用于填充图像所有边；如果提供的是长度为2的元组/列表，则分别为图像左/右和顶部/底部进行填充；如果提供的是长度为4的元组/列表，则按照左，上，右和下的顺序为图像填充。
-    - fill (int|list|tuple) - 用于填充的像素值。仅当padding_mode为constant时参数值有效。 默认值：0。 如果参数值是一个长度为3的元组，则会分别用于填充R，G，B通道。
-    - padding_mode (string) - 填充模式。支持: constant, edge, reflect 或 symmetric。 默认值：constant。 ``constant`` 表示使用常量值进行填充，该值由fill参数指定。``edge`` 表示使用图像边缘像素值进行填充。``reflect`` 表示使用原图像的镜像值进行填充（不使用边缘上的值）；比如：使用该模式对 ``[1, 2, 3, 4]`` 的两端分别填充2个值，结果是 ``[3, 2, 1, 2, 3, 4, 3, 2]``。``symmetric`` 表示使用原图像的镜像值进行填充（使用边缘上的值）；比如：使用该模式对 ``[1, 2, 3, 4]`` 的两端分别填充2个值，结果是 ``[2, 1, 1, 2, 3, 4, 4, 3]``。
-    - keys (list[str]|tuple[str], optional) - 与 ``BaseTransform`` 定义一致。默认值: None。
+    - **padding** (int|list|tuple) - 在图像边界上进行填充的范围。如果提供的是单个 int 值，则该值用于填充图像所有边；如果提供的是长度为 2 的元组/列表，则分别为图像左/右和顶部/底部进行填充；如果提供的是长度为 4 的元组/列表，则按照左，上，右和下的顺序为图像填充。
+    - **fill** (int|list|tuple，可选) - 用于填充的像素值。仅当 padding_mode 为 constant 时参数值有效。 默认值：0。 如果参数值是一个长度为 3 的元组，则会分别用于填充 R，G，B 通道。
+    - **padding_mode** (string，可选) - 填充模式。支持: constant, edge, reflect 或 symmetric。 默认值：constant。
+
+        - ``constant`` 表示使用常量值进行填充，该值由 fill 参数指定；
+        - ``edge`` 表示使用图像边缘像素值进行填充；
+        - ``reflect`` 表示使用原图像的镜像值进行填充（不使用边缘上的值）；比如：使用该模式对 ``[1, 2, 3, 4]`` 的两端分别填充 2 个值，结果是 ``[3, 2, 1, 2, 3, 4, 3, 2]``。
+        - ``symmetric`` 表示使用原图像的镜像值进行填充（使用边缘上的值）；比如：使用该模式对 ``[1, 2, 3, 4]`` 的两端分别填充 2 个值，结果是 ``[2, 1, 1, 2, 3, 4, 4, 3]``。
+
+    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值: None。
 
 形状
 :::::::::
@@ -24,21 +30,9 @@ Pad
 返回
 :::::::::
 
-    计算 ``Pad`` 的可调用对象。
+计算 ``Pad`` 的可调用对象。
 
 代码示例
 :::::::::
 
-.. code-block:: python
-
-    import numpy as np
-    from PIL import Image
-    from paddle.vision.transforms import Pad
-    
-    transform = Pad(2)
-    
-    fake_img = Image.fromarray((np.random.rand(224, 224, 3) * 255.).astype(np.uint8))
-    
-    fake_img = transform(fake_img)
-    print(fake_img.size)
-    
+COPY-FROM: paddle.vision.transforms.Pad

docs/api/paddle/vision/transforms/Resize__upper_cn.rst

@@ -10,9 +10,27 @@ Resize
 参数
 :::::::::
 
-    - size (int|list|tuple) - 输出图像大小。如果size是一个序列，例如（h，w），输出大小将与此匹配。如果size为int，图像的较小边缘将与此数字匹配，即如果 height > width，则图像将重新缩放为(size * height / width, size)。
-    - interpolation (int|str, optional) - 插值的方法. 默认值: 'bilinear'. 当使用 ``pil`` 作为后端时, 支持的插值方法如下: - "nearest": Image.NEAREST, - "bilinear": Image.BILINEAR, - "bicubic": Image.BICUBIC, - "box": Image.BOX, - "lanczos": Image.LANCZOS, - "hamming": Image.HAMMING；当使用 ``cv2`` 作为后端时, 支持的插值方法如下: - "nearest": cv2.INTER_NEAREST, - "bilinear": cv2.INTER_LINEAR, - "area": cv2.INTER_AREA, - "bicubic": cv2.INTER_CUBIC, - "lanczos": cv2.INTER_LANCZOS4
-    - keys (list[str]|tuple[str], optional) - 与 ``BaseTransform`` 定义一致。默认值: None。
+    - **size** (int|list|tuple) - 输出图像大小。如果 size 是一个序列，例如（h，w），输出大小将与此匹配。如果 size 为 int，图像的较小边缘将与此数字匹配，即如果 height > width，则图像将重新缩放为(size * height / width, size)。
+    - **interpolation** (int|str，可选) - 插值的方法，默认值: 'bilinear'。
+
+        - 当使用 ``pil`` 作为后端时，支持的插值方法如下
+
+            + "nearest": Image.NEAREST,
+            + "bilinear": Image.BILINEAR,
+            + "bicubic": Image.BICUBIC,
+            + "box": Image.BOX,
+            + "lanczos": Image.LANCZOS,
+            + "hamming": Image.HAMMING。
+
+        - 当使用 ``cv2`` 作为后端时，支持的插值方法如下
+
+            + "nearest": cv2.INTER_NEAREST,
+            + "bilinear": cv2.INTER_LINEAR,
+            + "area": cv2.INTER_AREA,
+            + "bicubic": cv2.INTER_CUBIC,
+            + "lanczos": cv2.INTER_LANCZOS4。
+
+    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值: None。
 
 形状
 :::::::::
@@ -23,20 +41,9 @@ Resize
 返回
 :::::::::
 
-    计算 ``Resize`` 的可调用对象。
+计算 ``Resize`` 的可调用对象。
 
 代码示例
 :::::::::
 
-.. code-block:: python
-
-    import numpy as np
-    from PIL import Image
-    from paddle.vision.transforms import Resize
-
-    transform = Resize(size=224)
-
-    fake_img = Image.fromarray((np.random.rand(100, 120, 3) * 255.).astype(np.uint8))
-
-    fake_img = transform(fake_img)
-    print(fake_img.size)
+COPY-FROM: paddle.vision.transforms.Resize

docs/api/paddle/vision/transforms/normalize_cn.rst

@@ -3,40 +3,25 @@
 normalize
 -------------------------------
 
-.. py:function:: paddle.vision.transforms.normalize(pic, data_format='CHW')
+.. py:function:: paddle.vision.transforms.normalize(img, mean, std, data_format='CHW', to_rgb=False)
 
-将 ``PIL.Image`` 或 ``numpy.ndarray`` 转换成 ``paddle.Tensor``
+用均值和标准差归一化输入数据。
 
 参数
 :::::::::
-    
-    - img (PIL.Image|np.array|paddle.Tensor) - 用于归一化的数据。
-    - mean (list|tuple) - 用于每个通道归一化的均值。
-    - std (list|tuple) - 用于每个通道归一化的标准差值。
-    - data_format (str, optional): 数据的格式，必须为 'HWC' 或 'CHW'。 默认值: 'CHW'。
-    - to_rgb (bool, optional) - 是否转换为 ``rgb`` 的格式。默认值：False。
+
+    - **img** (PIL.Image|np.array|paddle.Tensor) - 用于归一化的数据。
+    - **mean** (list|tuple) - 用于每个通道归一化的均值。
+    - **std** (list|tuple) - 用于每个通道归一化的标准差值。
+    - **data_format** (str，可选) - 数据的格式，必须为 'HWC' 或 'CHW'。默认值：'CHW'。
+    - **to_rgb** (bool，可选) - 是否转换为 ``rgb`` 的格式。默认值：False。
 
 返回
 :::::::::
 
-    ``numpy array 或 paddle.Tensor``，归一化后的图像。
+``numpy array`` 或 ``paddle.Tensor``，归一化后的图像。
 
 代码示例
 :::::::::
 
-.. code-block:: python
-
-    import numpy as np
-    from PIL import Image
-    from paddle.vision.transforms import functional as F
-
-    fake_img = (np.random.rand(256, 300, 3) * 255.).astype('uint8')
-
-    fake_img = Image.fromarray(fake_img)
-
-    mean = [127.5, 127.5, 127.5]
-    std = [127.5, 127.5, 127.5]
-
-    normalized_img = F.normalize(fake_img, mean, std, data_format='HWC')
-    print(normalized_img.max(), normalized_img.min())
-    
+COPY-FROM: paddle.vision.transforms.normalize