[Typing] update pybind11 stub

python/paddle/base/framework.py

@@ -1969,7 +1969,7 @@ def backward(self, retain_graph=False):
                 >>> import paddle
                 >>> paddle.disable_static()
 
-                >>> x = np.ones([2, 2], np.float32) # type: ignore[var-annotated]
+                >>> x = np.ones([2, 2], np.float32)
                 >>> inputs = []
                 >>> for _ in range(10):
                 ...     tmp = paddle.to_tensor(x)
@@ -2013,7 +2013,7 @@ def gradient(self):
                 >>> import numpy as np
 
                 >>> # example1: return ndarray
-                >>> x = np.ones([2, 2], np.float32) # type: ignore[var-annotated]
+                >>> x = np.ones([2, 2], np.float32)
                 >>> with base.dygraph.guard():
                 ...     inputs2 = []
                 ...     for _ in range(10):
@@ -2062,7 +2062,7 @@ def clear_gradient(self):
                 >>> import paddle.base as base
                 >>> import numpy as np
 
-                >>> x = np.ones([2, 2], np.float32) # type: ignore[var-annotated]
+                >>> x = np.ones([2, 2], np.float32)
                 >>> inputs2 = []
                 >>> for _ in range(10):
                 >>>     tmp = paddle.to_tensor(x)

python/paddle/base/layers/math_op_patch.py

@@ -358,7 +358,7 @@ def astype(self, dtype):
                 >>> import paddle
                 >>> import numpy as np
 
-                >>> x = np.ones([2, 2], np.float32) # type: ignore[var-annotated]
+                >>> x = np.ones([2, 2], np.float32)
                 >>> with base.dygraph.guard():
                 ...     original_variable = paddle.to_tensor(x)
                 ...     print("original var's dtype is: {}, numpy dtype is {}".format(original_variable.dtype, original_variable.numpy().dtype))

python/paddle/distributed/parallel.py

@@ -348,7 +348,7 @@ class DataParallel(Layer):
             ...     model = paddle.DataParallel(model)
             ...     opt = paddle.optimizer.SGD(learning_rate=0.01, parameters=model.parameters())
             ...     for step in range(10):
-            ...         x_data = numpy.random.randn(2, 2).astype(numpy.float32) # type: ignore[var-annotated]
+            ...         x_data = numpy.random.randn(2, 2).astype(numpy.float32)
             ...         x = paddle.to_tensor(x_data)
             ...         x.stop_gradient = False
             ...         # step 1 : skip gradient synchronization by 'no_sync'

python/paddle/incubate/optimizer/lbfgs.py

@@ -93,10 +93,10 @@ class LBFGS(Optimizer):
 
             >>> paddle.disable_static()
             >>> np.random.seed(0)
-            >>> np_w = np.random.rand(1).astype(np.float32) # type: ignore[var-annotated]
-            >>> np_x = np.random.rand(1).astype(np.float32) # type: ignore[var-annotated]
+            >>> np_w = np.random.rand(1).astype(np.float32)
+            >>> np_x = np.random.rand(1).astype(np.float32)
 
-            >>> inputs = [np.random.rand(1).astype(np.float32) for i in range(10)] # type: ignore[var-annotated]
+            >>> inputs = [np.random.rand(1).astype(np.float32) for i in range(10)]
             >>> # y = 2x
             >>> targets = [2 * x for x in inputs]
 

python/paddle/optimizer/lbfgs.py

@@ -396,10 +396,10 @@ class LBFGS(Optimizer):
 
             >>> paddle.disable_static()
             >>> np.random.seed(0)
-            >>> np_w = np.random.rand(1).astype(np.float32)  # type: ignore[var-annotated]
-            >>> np_x = np.random.rand(1).astype(np.float32)  # type: ignore[var-annotated]
+            >>> np_w = np.random.rand(1).astype(np.float32)
+            >>> np_x = np.random.rand(1).astype(np.float32)
 
-            >>> inputs = [np.random.rand(1).astype(np.float32) for i in range(10)]  # type: ignore[var-annotated]
+            >>> inputs = [np.random.rand(1).astype(np.float32) for i in range(10)]
             >>> # y = 2x
             >>> targets = [2 * x for x in inputs]
 

python/paddle/static/input.py

@@ -110,7 +110,7 @@ def data(
 
             # In this example, we will feed x and y with np-ndarray "1"
             # and fetch z, like implementing "1 + 1 = 2" in PaddlePaddle
-            >>> feed_data = np.ones(shape=[3, 2, 1], dtype=np.float32) # type: ignore[var-annotated]
+            >>> feed_data = np.ones(shape=[3, 2, 1], dtype=np.float32)
 
             >>> exe = paddle.static.Executor(paddle.framework.CPUPlace())
             >>> out = exe.run(paddle.static.default_main_program(),
@@ -308,7 +308,7 @@ def from_numpy(
                 >>> import numpy as np
                 >>> from paddle.static import InputSpec
 
-                >>> x = np.ones([2, 2], np.float32) # type: ignore[var-annotated]
+                >>> x = np.ones([2, 2], np.float32)
                 >>> x_spec = InputSpec.from_numpy(x, name='x')
                 >>> print(x_spec)
                 InputSpec(shape=(2, 2), dtype=paddle.float32, name=x, stop_gradient=False)

python/paddle/static/io.py

@@ -900,7 +900,7 @@ def load_inference_model(
 
             >>> [inference_program, feed_target_names, fetch_targets] = (
             ...     paddle.static.load_inference_model(path_prefix, exe))
-            >>> tensor_img = np.array(np.random.random((64, 784)), dtype=np.float32) # type: ignore[var-annotated]
+            >>> tensor_img = np.array(np.random.random((64, 784)), dtype=np.float32)
             >>> results = exe.run(inference_program,
             ...               feed={feed_target_names[0]: tensor_img},
             ...               fetch_list=fetch_targets)

python/paddle/static/nn/common.py

@@ -3578,7 +3578,7 @@ def embedding(
             >>> exe = paddle.static.Executor(place)
             >>> exe.run(paddle.static.default_startup_program())
 
-            >>> x = np.array([[7, 2, 4, 5],[4, 3, 2, 9]], dtype=np.int64) # type: ignore[var-annotated]
+            >>> x = np.array([[7, 2, 4, 5],[4, 3, 2, 9]], dtype=np.int64)
             >>> out, = exe.run(paddle.static.default_main_program(), feed={'x':x}, fetch_list=[output])
             >>> print(out)
             [[[1. 1. 1.]

python/paddle/static/nn/static_pylayer.py

@@ -312,46 +312,42 @@ def static_pylayer(forward_fn, inputs, backward_fn=None, name=None):
     Examples:
         .. code-block:: python
 
-                >>> import paddle
-                >>> import numpy as np
-
-                >>> paddle.enable_static()
-
-                >>> def forward_fn(x):
-                ...     return paddle.exp(x)
-
-                >>> def backward_fn(dy):
-                ...     return 2 * paddle.exp(dy)
-
-                >>> main_program = paddle.static.Program()
-                >>> start_program = paddle.static.Program()
-
-                >>> place = paddle.CPUPlace()
-                >>> exe = paddle.static.Executor(place)
-                >>> with paddle.static.program_guard(main_program, start_program):
-                ...     data = paddle.static.data(name="X", shape=[None, 5], dtype="float32")
-                ...     data.stop_gradient = False
-                ...     ret = paddle.static.nn.static_pylayer(forward_fn, [data], backward_fn)
-                ...     data_grad = paddle.static.gradients([ret], data)[0]
-
-                >>> exe.run(start_program)
-                >>> x = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32) # type: ignore[var-annotated]
-                >>> x, x_grad, y = exe.run(
-                ...     main_program,
-                ...     feed={"X": x},
-                ...     fetch_list=[
-                ...         data.name,
-                ...         data_grad.name,
-                ...         ret.name
-                ...     ],
-                ... )
-
-                >>> print(x)
-                [[1. 2. 3. 4. 5.]]
-                >>> print(x_grad)
-                [[5.4365635 5.4365635 5.4365635 5.4365635 5.4365635]]
-                >>> print(y)
-                [[  2.7182817   7.389056   20.085537   54.59815   148.41316  ]]
+            >>> import paddle
+            >>> import numpy as np
+
+            >>> paddle.enable_static()
+
+            >>> def forward_fn(x):
+            ...     return paddle.exp(x)
+
+            >>> def backward_fn(dy):
+            ...     return 2 * paddle.exp(dy)
+
+            >>> main_program = paddle.static.Program()
+            >>> start_program = paddle.static.Program()
+
+            >>> place = paddle.CPUPlace()
+            >>> exe = paddle.static.Executor(place)
+            >>> with paddle.static.program_guard(main_program, start_program):
+            ...     data = paddle.static.data(name="X", shape=[None, 5], dtype="float32")
+            ...     data.stop_gradient = False
+            ...     ret = paddle.static.nn.static_pylayer(forward_fn, [data], backward_fn)
+            ...     data_grad = paddle.static.gradients([ret], data)[0]
+
+            >>> exe.run(start_program)
+            >>> x = np.array([[1.0, 2.0, 3.0, 4.0, 5.0]], dtype=np.float32)
+            >>> x, x_grad, y = exe.run(
+            ...     main_program,
+            ...     feed={"X": x},
+            ...     fetch_list=[data, data_grad, ret],
+            ... )
+
+            >>> print(x)
+            [[1. 2. 3. 4. 5.]]
+            >>> print(x_grad)
+            [[5.4365635 5.4365635 5.4365635 5.4365635 5.4365635]]
+            >>> print(y)
+            [[  2.7182817   7.389056   20.085537   54.59815   148.41316  ]]
     """
     assert (
         in_dygraph_mode() is False

python/paddle/static/pir_io.py

@@ -840,7 +840,7 @@ def load_inference_model_pir(path_prefix, executor, **kwargs):
 
             >>> [inference_program, feed_target_names, fetch_targets] = (
             ...     paddle.static.load_inference_model(path_prefix, exe))
-            >>> tensor_img = np.array(np.random.random((64, 784)), dtype=np.float32) # type: ignore[var-annotated]
+            >>> tensor_img = np.array(np.random.random((64, 784)), dtype=np.float32)
             >>> results = exe.run(inference_program,
             ...               feed={feed_target_names[0]: tensor_img},
             ...               fetch_list=fetch_targets)

python/paddle/tensor/attribute.py

@@ -83,11 +83,11 @@ def shape(input: Tensor) -> Tensor:
                 input.shape = [3, 2]
 
     Args:
-        input (Variable): The input can be N-D Tensor or SelectedRows with data type bool, bfloat16, float16, float32, float64, int32, int64.
+        input (Tensor): The input can be N-D Tensor or SelectedRows with data type bool, bfloat16, float16, float32, float64, int32, int64.
                           If input variable is type of SelectedRows, returns the shape of it's inner tensor.
 
     Returns:
-        Variable (Tensor): The shape of the input variable.
+        Tensor: The shape of the input variable.
 
     Examples:
         .. code-block:: python
@@ -102,11 +102,11 @@ def shape(input: Tensor) -> Tensor:
             >>> exe = paddle.static.Executor(paddle.CPUPlace())
             >>> exe.run(paddle.static.default_startup_program())
 
-            >>> img = np.ones((3, 100, 100)).astype(np.float32) # type: ignore[var-annotated]
+            >>> img = np.ones((3, 100, 100)).astype(np.float32)
 
-            >>> res = exe.run(paddle.static.default_main_program(), feed={'x':img}, fetch_list=[output])
+            >>> res = exe.run(paddle.static.default_main_program(), feed={'x': img}, fetch_list=[output])
             >>> print(res)
-            [array([  3, 100, 100], dtype=int32)]
+            [array([  3, 100, 100], dtype=int64)]
     """
     if in_dynamic_or_pir_mode():
         out = _C_ops.shape64(input)  # type: ignore

python/paddle/tensor/creation.py

@@ -2645,7 +2645,7 @@ def assign(x: TensorLike, output: paddle.Tensor | None = None) -> paddle.Tensor:
              [2.5 2.5]]
             >>> array = np.array([[1, 1], [3, 4], [1, 3]]).astype(
             ...     np.int64
-            ... )  # type: ignore[var-annotated]
+            ... )
             >>> result1 = paddle.zeros(shape=[3, 3], dtype='float32')
             >>> paddle.assign(array, result1)
             >>> print(result1.numpy())

python/paddle/vision/transforms/functional.py

@@ -437,18 +437,13 @@ def adjust_brightness(
             >>> fake_img = Image.fromarray(fake_img)
             >>> print(fake_img.size)
             (300, 256)
-            >>> print(fake_img.load()[1,1]) # type: ignore[index]
+            >>> print(fake_img.load()[1, 1]) # type: ignore[index]
             (61, 155, 171)
             >>> converted_img = F.adjust_brightness(fake_img, 0.5)
             >>> print(converted_img.size)
             (300, 256)
-            >>> print(converted_img.load()[1,1]) # type: ignore[index]
+            >>> print(converted_img.load()[1, 1])
             (30, 77, 85)
-
-
-
-
-
     """
     if not (
         _is_pil_image(img) or _is_numpy_image(img) or _is_tensor_image(img)

python/paddle/vision/transforms/transforms.py

@@ -387,7 +387,7 @@ class ToTensor(BaseTransform[_InputT, "Tensor"]):
             >>> img_arr = ((paddle.rand((4, 5, 3)) * 255.).astype('uint8')).numpy()
             >>> fake_img = Image.fromarray(img_arr)
             >>> transform = T.ToTensor()
-            >>> tensor = transform(fake_img)  # type: ignore[call-overload]
+            >>> tensor = transform(fake_img)
             >>> print(tensor.shape)
             [3, 4, 5]
             >>> print(tensor.dtype)
@@ -457,11 +457,11 @@ class Resize(BaseTransform[_InputT, _RetT]):
 
             >>> fake_img = Image.fromarray((np.random.rand(256, 300, 3) * 255.).astype(np.uint8))
             >>> transform = Resize(size=224)
-            >>> converted_img = transform(fake_img) # type: ignore[call-overload]
+            >>> converted_img = transform(fake_img)
             >>> print(converted_img.size)
             (262, 224)
             >>> transform = Resize(size=(200,150))
-            >>> converted_img = transform(fake_img) # type: ignore[call-overload]
+            >>> converted_img = transform(fake_img)
             >>> print(converted_img.size)
             (150, 200)
     """
@@ -530,7 +530,7 @@ class RandomResizedCrop(BaseTransform[_InputT, _RetT]):
 
             >>> transform = RandomResizedCrop(224)
             >>> fake_img = Image.fromarray((np.random.rand(300, 320, 3) * 255.).astype(np.uint8))
-            >>> fake_img = transform(fake_img)  # type: ignore[call-overload]
+            >>> fake_img = transform(fake_img)
             >>> print(fake_img.size)
             (224, 224)
 
@@ -736,7 +736,7 @@ class CenterCrop(BaseTransform[_InputT, _RetT]):
 
             >>> transform = CenterCrop(224)
             >>> fake_img = Image.fromarray((np.random.rand(300, 320, 3) * 255.).astype(np.uint8))
-            >>> fake_img = transform(fake_img)  # type: ignore[call-overload]
+            >>> fake_img = transform(fake_img)
             >>> print(fake_img.size)
             (224, 224)
 
@@ -918,7 +918,7 @@ class Normalize(BaseTransform[_InputT, _RetT]):
             ...                         data_format='HWC')
             ...
             >>> fake_img = paddle.rand([300,320,3]).numpy() * 255.
-            >>> fake_img = normalize(fake_img)  # type: ignore[call-overload]
+            >>> fake_img = normalize(fake_img)
             >>> print(fake_img.shape)
             (300, 320, 3)
             >>> print(fake_img.max(), fake_img.min())
@@ -985,7 +985,7 @@ class Transpose(BaseTransform[_InputT, _RetT]):
 
             >>> transform = Transpose()
             >>> fake_img = Image.fromarray((np.random.rand(300, 320, 3) * 255.).astype(np.uint8))
-            >>> fake_img = transform(fake_img)  # type: ignore[call-overload]
+            >>> fake_img = transform(fake_img)
             >>> print(fake_img.shape)
             (3, 300, 320)
 
@@ -1042,7 +1042,7 @@ class BrightnessTransform(BaseTransform[_InputT, _RetT]):
             >>> print(fake_img.load()[1,1]) # type: ignore[index]
             (60, 169, 34)
             >>> # doctest: +SKIP('random sample in Brightness function')
-            >>> fake_img = transform(fake_img) # type: ignore[call-overload]
+            >>> fake_img = transform(fake_img)
             >>> print(fake_img.load()[1,1])
             (68, 192, 38)
 
@@ -1089,7 +1089,7 @@ class ContrastTransform(BaseTransform[_InputT, _RetT]):
 
             >>> transform = ContrastTransform(0.4)
             >>> fake_img = Image.fromarray((np.random.rand(224, 224, 3) * 255.).astype(np.uint8))
-            >>> fake_img = transform(fake_img)  # type: ignore[call-overload]
+            >>> fake_img = transform(fake_img)
             >>> print(fake_img.size)
             (224, 224)
 
@@ -1138,7 +1138,7 @@ class SaturationTransform(BaseTransform[_InputT, _RetT]):
 
             >>> transform = SaturationTransform(0.4)
             >>> fake_img = Image.fromarray((np.random.rand(224, 224, 3) * 255.).astype(np.uint8))
-            >>> fake_img = transform(fake_img)  # type: ignore[call-overload]
+            >>> fake_img = transform(fake_img)
             >>> print(fake_img.size)
             (224, 224)
     """
@@ -1184,7 +1184,7 @@ class HueTransform(BaseTransform[_InputT, _RetT]):
 
             >>> transform = HueTransform(0.4)
             >>> fake_img = Image.fromarray((np.random.rand(224, 224, 3) * 255.).astype(np.uint8))
-            >>> fake_img = transform(fake_img)  # type: ignore[call-overload]
+            >>> fake_img = transform(fake_img)
             >>> print(fake_img.size)
             (224, 224)
 
@@ -1239,7 +1239,7 @@ class ColorJitter(BaseTransform[_InputT, _RetT]):
 
             >>> transform = ColorJitter(0.4, 0.4, 0.4, 0.4)
             >>> fake_img = Image.fromarray((np.random.rand(224, 224, 3) * 255.).astype(np.uint8))
-            >>> fake_img = transform(fake_img)  # type: ignore[call-overload]
+            >>> fake_img = transform(fake_img)
             >>> print(fake_img.size)
             (224, 224)
 
@@ -1480,7 +1480,7 @@ class Pad(BaseTransform[_InputT, _RetT]):
 
             >>> transform = Pad(2)
             >>> fake_img = Image.fromarray((np.random.rand(224, 224, 3) * 255.).astype(np.uint8))
-            >>> fake_img = transform(fake_img)  # type: ignore[call-overload]
+            >>> fake_img = transform(fake_img)
             >>> print(fake_img.size)
             (228, 228)
     """
@@ -1778,7 +1778,7 @@ class RandomRotation(BaseTransform[_InputT, _RetT]):
 
             >>> transform = RandomRotation(90)
             >>> fake_img = Image.fromarray((np.random.rand(200, 150, 3) * 255.).astype(np.uint8))
-            >>> fake_img = transform(fake_img)  # type: ignore[call-overload]
+            >>> fake_img = transform(fake_img)
             >>> print(fake_img.size)
             (150, 200)
     """
@@ -2012,7 +2012,7 @@ class Grayscale(BaseTransform[_InputT, _RetT]):
 
             >>> transform = Grayscale()
             >>> fake_img = Image.fromarray((np.random.rand(224, 224, 3) * 255.).astype(np.uint8))
-            >>> fake_img = transform(fake_img)  # type: ignore[call-overload]
+            >>> fake_img = transform(fake_img)
             >>> print(np.array(fake_img).shape)
             (224, 224)
     """