[Fix]fix cleandoc with a first blank line (#55052)

* [Fix]fix cleandoc with a first blank line

* [Fix]fix metrics.py code-block

* [Fix]fix metrics.py code-block indent

python/paddle/metric/metrics.py

@@ -82,31 +82,33 @@ class Metric(metaclass=abc.ABCMeta):
         prediction of each sample like follows, while the correct prediction
         matrix shape is [N, 5].
 
-          .. code-block:: text
+        .. code-block:: python
+            :name: code-compute-example
 
-              def compute(pred, label):
-                  # sort prediction and slice the top-5 scores
-                  pred = paddle.argsort(pred, descending=True)[:, :5]
-                  # calculate whether the predictions are correct
-                  correct = pred == label
-                  return paddle.cast(correct, dtype='float32')
+            def compute(pred, label):
+                # sort prediction and slice the top-5 scores
+                pred = paddle.argsort(pred, descending=True)[:, :5]
+                # calculate whether the predictions are correct
+                correct = pred == label
+                return paddle.cast(correct, dtype='float32')
 
         With the :code:`compute`, we split some calculations to OPs (which
         may run on GPU devices, will be faster), and only fetch 1 tensor with
         shape as [N, 5] instead of 2 tensors with shapes as [N, 10] and [N, 1].
         :code:`update` can be define as follows:
 
-          .. code-block:: text
-
-              def update(self, correct):
-                  accs = []
-                  for i, k in enumerate(self.topk):
-                      num_corrects = correct[:, :k].sum()
-                      num_samples = len(correct)
-                      accs.append(float(num_corrects) / num_samples)
-                      self.total[i] += num_corrects
-                      self.count[i] += num_samples
-                  return accs
+        .. code-block:: python
+            :name: code-update-example
+
+            def update(self, correct):
+                accs = []
+                for i, k in enumerate(self.topk):
+                    num_corrects = correct[:, :k].sum()
+                    num_samples = len(correct)
+                    accs.append(float(num_corrects) / num_samples)
+                    self.total[i] += num_corrects
+                    self.count[i] += num_samples
+                return accs
     """
 
     def __init__(self):
@@ -195,50 +197,48 @@ class Accuracy(Metric):
         name (str, optional): String name of the metric instance. Default
             is `acc`.
 
-    Example by standalone:
-
+    Examples:
         .. code-block:: python
+            :name: code-standalone-example
 
-          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
+            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]]))
 
-    Example with Model API:
+            m = paddle.metric.Accuracy()
+            correct = m.compute(x, y)
+            m.update(correct)
+            res = m.accumulate()
+            print(res) # 0.75
 
         .. code-block:: python
+            :name: code-model-api-example
 
-          import paddle
-          from paddle.static import InputSpec
-          import paddle.vision.transforms as T
-          from paddle.vision.datasets import MNIST
+            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)
+            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 = 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)
 
     """
 
@@ -349,57 +349,55 @@ class Precision(Metric):
         name (str, optional): String name of the metric instance.
             Default is `precision`.
 
-    Example by standalone:
-
+    Examples:
         .. code-block:: python
+            :name: code-standalone-example
 
-          import numpy as np
-          import paddle
-
-          x = np.array([0.1, 0.5, 0.6, 0.7])
-          y = np.array([0, 1, 1, 1])
-
-          m = paddle.metric.Precision()
-          m.update(x, y)
-          res = m.accumulate()
-          print(res) # 1.0
+            import numpy as np
+            import paddle
 
+            x = np.array([0.1, 0.5, 0.6, 0.7])
+            y = np.array([0, 1, 1, 1])
 
-    Example with Model API:
+            m = paddle.metric.Precision()
+            m.update(x, y)
+            res = m.accumulate()
+            print(res) # 1.0
 
         .. code-block:: python
+            :name: code-model-api-example
+
+            import numpy as np
 
-          import numpy as np
-
-          import paddle
-          import paddle.nn as nn
-
-          class Data(paddle.io.Dataset):
-              def __init__(self):
-                  super().__init__()
-                  self.n = 1024
-                  self.x = np.random.randn(self.n, 10).astype('float32')
-                  self.y = np.random.randint(2, size=(self.n, 1)).astype('float32')
-
-              def __getitem__(self, idx):
-                  return self.x[idx], self.y[idx]
-
-              def __len__(self):
-                  return self.n
-
-          model = paddle.Model(nn.Sequential(
-              nn.Linear(10, 1),
-              nn.Sigmoid()
-          ))
-          optim = paddle.optimizer.Adam(
-              learning_rate=0.001, parameters=model.parameters())
-          model.prepare(
-              optim,
-              loss=nn.BCELoss(),
-              metrics=paddle.metric.Precision())
-
-          data = Data()
-          model.fit(data, batch_size=16)
+            import paddle
+            import paddle.nn as nn
+
+            class Data(paddle.io.Dataset):
+                def __init__(self):
+                    super().__init__()
+                    self.n = 1024
+                    self.x = np.random.randn(self.n, 10).astype('float32')
+                    self.y = np.random.randint(2, size=(self.n, 1)).astype('float32')
+
+                def __getitem__(self, idx):
+                    return self.x[idx], self.y[idx]
+
+                def __len__(self):
+                    return self.n
+
+            model = paddle.Model(nn.Sequential(
+                nn.Linear(10, 1),
+                nn.Sigmoid()
+            ))
+            optim = paddle.optimizer.Adam(
+                learning_rate=0.001, parameters=model.parameters())
+            model.prepare(
+                optim,
+                loss=nn.BCELoss(),
+                metrics=paddle.metric.Precision())
+
+            data = Data()
+            model.fit(data, batch_size=16)
     """
 
     def __init__(self, name='precision', *args, **kwargs):
@@ -482,57 +480,55 @@ class Recall(Metric):
         name (str, optional): String name of the metric instance.
             Default is `recall`.
 
-    Example by standalone:
-
+    Examples:
         .. code-block:: python
+            :name: code-standalone-example
 
-          import numpy as np
-          import paddle
-
-          x = np.array([0.1, 0.5, 0.6, 0.7])
-          y = np.array([1, 0, 1, 1])
-
-          m = paddle.metric.Recall()
-          m.update(x, y)
-          res = m.accumulate()
-          print(res) # 2.0 / 3.0
+            import numpy as np
+            import paddle
 
+            x = np.array([0.1, 0.5, 0.6, 0.7])
+            y = np.array([1, 0, 1, 1])
 
-    Example with Model API:
+            m = paddle.metric.Recall()
+            m.update(x, y)
+            res = m.accumulate()
+            print(res) # 2.0 / 3.0
 
         .. code-block:: python
+            :name: code-model-api-example
+
+            import numpy as np
 
-          import numpy as np
-
-          import paddle
-          import paddle.nn as nn
-
-          class Data(paddle.io.Dataset):
-              def __init__(self):
-                  super().__init__()
-                  self.n = 1024
-                  self.x = np.random.randn(self.n, 10).astype('float32')
-                  self.y = np.random.randint(2, size=(self.n, 1)).astype('float32')
-
-              def __getitem__(self, idx):
-                  return self.x[idx], self.y[idx]
-
-              def __len__(self):
-                  return self.n
-
-          model = paddle.Model(nn.Sequential(
-              nn.Linear(10, 1),
-              nn.Sigmoid()
-          ))
-          optim = paddle.optimizer.Adam(
-              learning_rate=0.001, parameters=model.parameters())
-          model.prepare(
-              optim,
-              loss=nn.BCELoss(),
-              metrics=[paddle.metric.Precision(), paddle.metric.Recall()])
-
-          data = Data()
-          model.fit(data, batch_size=16)
+            import paddle
+            import paddle.nn as nn
+
+            class Data(paddle.io.Dataset):
+                def __init__(self):
+                    super().__init__()
+                    self.n = 1024
+                    self.x = np.random.randn(self.n, 10).astype('float32')
+                    self.y = np.random.randint(2, size=(self.n, 1)).astype('float32')
+
+                def __getitem__(self, idx):
+                    return self.x[idx], self.y[idx]
+
+                def __len__(self):
+                    return self.n
+
+            model = paddle.Model(nn.Sequential(
+                nn.Linear(10, 1),
+                nn.Sigmoid()
+            ))
+            optim = paddle.optimizer.Adam(
+                learning_rate=0.001, parameters=model.parameters())
+            model.prepare(
+                optim,
+                loss=nn.BCELoss(),
+                metrics=[paddle.metric.Precision(), paddle.metric.Recall()])
+
+            data = Data()
+            model.fit(data, batch_size=16)
     """
 
     def __init__(self, name='recall', *args, **kwargs):
@@ -624,61 +620,60 @@ class Auc(Metric):
 
     "NOTE: only implement the ROC curve type via Python now."
 
-    Example by standalone:
+    Examples:
         .. code-block:: python
+            :name: code-standalone-example
 
-          import numpy as np
-          import paddle
+            import numpy as np
+            import paddle
 
-          m = paddle.metric.Auc()
+            m = paddle.metric.Auc()
 
-          n = 8
-          class0_preds = np.random.random(size = (n, 1))
-          class1_preds = 1 - class0_preds
+            n = 8
+            class0_preds = np.random.random(size = (n, 1))
+            class1_preds = 1 - class0_preds
 
-          preds = np.concatenate((class0_preds, class1_preds), axis=1)
-          labels = np.random.randint(2, size = (n, 1))
+            preds = np.concatenate((class0_preds, class1_preds), axis=1)
+            labels = np.random.randint(2, size = (n, 1))
 
-          m.update(preds=preds, labels=labels)
-          res = m.accumulate()
+            m.update(preds=preds, labels=labels)
+            res = m.accumulate()
 
+        .. code-block:: python
+            :name: code-model-api-example
 
-    Example with Model API:
+            import numpy as np
+            import paddle
+            import paddle.nn as nn
 
-        .. code-block:: python
+            class Data(paddle.io.Dataset):
+                def __init__(self):
+                    super().__init__()
+                    self.n = 1024
+                    self.x = np.random.randn(self.n, 10).astype('float32')
+                    self.y = np.random.randint(2, size=(self.n, 1)).astype('int64')
 
-          import numpy as np
-          import paddle
-          import paddle.nn as nn
-
-          class Data(paddle.io.Dataset):
-              def __init__(self):
-                  super().__init__()
-                  self.n = 1024
-                  self.x = np.random.randn(self.n, 10).astype('float32')
-                  self.y = np.random.randint(2, size=(self.n, 1)).astype('int64')
-
-              def __getitem__(self, idx):
-                  return self.x[idx], self.y[idx]
-
-              def __len__(self):
-                  return self.n
-
-          model = paddle.Model(nn.Sequential(
-              nn.Linear(10, 2), nn.Softmax())
-          )
-          optim = paddle.optimizer.Adam(
-              learning_rate=0.001, parameters=model.parameters())
-
-          def loss(x, y):
-              return nn.functional.nll_loss(paddle.log(x), y)
-
-          model.prepare(
-              optim,
-              loss=loss,
-              metrics=paddle.metric.Auc())
-          data = Data()
-          model.fit(data, batch_size=16)
+                def __getitem__(self, idx):
+                    return self.x[idx], self.y[idx]
+
+                def __len__(self):
+                    return self.n
+
+            model = paddle.Model(nn.Sequential(
+                nn.Linear(10, 2), nn.Softmax())
+            )
+            optim = paddle.optimizer.Adam(
+                learning_rate=0.001, parameters=model.parameters())
+
+            def loss(x, y):
+                return nn.functional.nll_loss(paddle.log(x), y)
+
+            model.prepare(
+                optim,
+                loss=loss,
+                metrics=paddle.metric.Auc())
+            data = Data()
+            model.fit(data, batch_size=16)
     """
 
     def __init__(

tools/sampcd_processor.py

@@ -151,7 +151,7 @@ def extract_code_blocks_from_docstr(docstr):
         # nonlocal code_blocks, cb_cur, cb_cur_name, cb_cur_seq_id, cb_required
         code_blocks.append(
             {
-                'codes': inspect.cleandoc("\n".join(cb_info['cb_cur'])),
+                'codes': inspect.cleandoc("\n" + "\n".join(cb_info['cb_cur'])),
                 'name': cb_info['cb_cur_name'],
                 'id': cb_info['cb_cur_seq_id'],
                 'required': cb_info['cb_required'],