From 5ab525db648f66cc16c8cd4fc5bd85ff0c4be986 Mon Sep 17 00:00:00 2001
From: Chunyu Zhang <saxon.zh@gmail.com>
Date: Wed, 9 Sep 2020 21:18:56 +0800
Subject: [PATCH] add define callback/metric/loss chapter (#893)

* upgrade code to 2.0-beta

* add high level api doc

* add define callback/metric/loss chapter

* add define callback/metric/loss chapter
---
 .../high_level_api/high_level_api.ipynb       | 312 ++++++++++++++++--
 .../pets_image_segmentation_U_Net_like.ipynb  | 127 ++++---
 2 files changed, 379 insertions(+), 60 deletions(-)

diff --git a/paddle2.0_docs/high_level_api/high_level_api.ipynb b/paddle2.0_docs/high_level_api/high_level_api.ipynb
index 6474cbc..9e883de 100644
--- a/paddle2.0_docs/high_level_api/high_level_api.ipynb
+++ b/paddle2.0_docs/high_level_api/high_level_api.ipynb
@@ -57,7 +57,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
@@ -66,7 +66,7 @@
       "text/plain": "'0.0.0'"
      },
      "metadata": {},
-     "execution_count": 4
+     "execution_count": 2
     }
    ],
    "source": [
@@ -91,10 +91,7 @@
     "* 如何进行模型的组网。\n",
     "* 高层API进行模型训练的相关API使用。\n",
     "* 如何在fit接口满足需求的时候进行自定义，使用基础API来完成训练。\n",
-    "* 如何使用多卡来加速训练。\n",
-    "\n",
-    "其他端到端的示例教程：\n",
-    "* TBD"
+    "* 如何使用多卡来加速训练。"
    ]
   },
   {
@@ -112,22 +109,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 5,
    "metadata": {
     "tags": []
    },
    "outputs": [
     {
-     "output_type": "execute_result",
-     "data": {
-      "text/plain": "['DatasetFolder',\n 'ImageFolder',\n 'MNIST',\n 'Flowers',\n 'Cifar10',\n 'Cifar100',\n 'VOC2012']"
-     },
-     "metadata": {},
-     "execution_count": 17
+     "output_type": "stream",
+     "name": "stdout",
+     "text": "视觉相关数据集： ['DatasetFolder', 'ImageFolder', 'MNIST', 'Flowers', 'Cifar10', 'Cifar100', 'VOC2012']\n自然语言相关数据集： ['Conll05st', 'Imdb', 'Imikolov', 'Movielens', 'MovieReviews', 'UCIHousing', 'WMT14', 'WMT16']\n"
     }
    ],
    "source": [
-    "paddle.vision.datasets.__all__"
+    "print('视觉相关数据集：', paddle.vision.datasets.__all__)\n",
+    "print('自然语言相关数据集：', paddle.text.datasets.__all__)"
    ]
   },
   {
@@ -458,9 +453,9 @@
    "source": [
     "## 5. 模型训练\n",
     "\n",
-    "使用`paddle.Model`封装成模型类后进行训练非常的简洁方便，我们可以直接通过调用`Model.fit`就可以完成训练过程。\n",
+    "网络结构通过`paddle.Model`接口封装成模型类后进行执行操作非常的简洁方便，可以直接通过调用`Model.fit`就可以完成训练过程。\n",
     "\n",
-    "在使用`Model.fit`接口启动训练前，我们先通过`Model.prepare`接口来对训练进行提前的配置准备工作，包括设置模型优化器，Loss计算方法，精度计算方法等。\n",
+    "使用`Model.fit`接口启动训练前，我们先通过`Model.prepare`接口来对训练进行提前的配置准备工作，包括设置模型优化器，Loss计算方法，精度计算方法等。\n",
     "\n"
    ]
   },
@@ -553,13 +548,269 @@
     "python -m paddle.distributed.launch train.py"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 5.3 自定义Loss\n",
+    "\n",
+    "有时我们会遇到特定任务的Loss计算方式在框架既有的Loss接口中不存在，或算法不符合自己的需求，那么期望能够自己来进行Loss的自定义，我们这里就会讲解介绍一下如何进行Loss的自定义操作，首先来看下面的代码：\n",
+    "\n",
+    "```python\n",
+    "class SelfDefineLoss(paddle.nn.Layer):\n",
+    "    \"\"\"\n",
+    "    1. 继承paddle.nn.Layer\n",
+    "    \"\"\"\n",
+    "    def __init__(self):\n",
+    "        \"\"\"\n",
+    "        2. 构造函数根据自己的实际算法需求和使用需求进行参数定义即可\n",
+    "        \"\"\"\n",
+    "        super(SelfDefineLoss, self).__init__()\n",
+    "\n",
+    "    def forward(self, input, label):\n",
+    "        \"\"\"\n",
+    "        3. 实现forward函数，forward在调用时会传递两个参数：input和label\n",
+    "            - input：单个或批次训练数据经过模型前向计算输出结果\n",
+    "            - label：单个或批次训练数据对应的标签数据\n",
+    "\n",
+    "            接口返回值是一个Tensor，根据自定义的逻辑加和或计算均值后的损失\n",
+    "        \"\"\"\n",
+    "        # 使用Paddle中相关API自定义的计算逻辑\n",
+    "        # output = xxxxx\n",
+    "        # return output\n",
+    "```\n",
+    "\n",
+    "那么了解完代码层面如果编写自定义代码后我们看一个实际的例子，下面是在图像分割示例代码中写的一个自定义Loss，当时主要是想使用自定义的softmax计算维度。\n",
+    "\n",
+    "```python\n",
+    "class SoftmaxWithCrossEntropy(paddle.nn.Layer):\n",
+    "    def __init__(self):\n",
+    "        super(SoftmaxWithCrossEntropy, self).__init__()\n",
+    "\n",
+    "    def forward(self, input, label):\n",
+    "        loss = F.softmax_with_cross_entropy(input, \n",
+    "                                            label, \n",
+    "                                            return_softmax=False,\n",
+    "                                            axis=1)\n",
+    "        return paddle.mean(loss)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 5.4 自定义Metric\n",
+    "\n",
+    "和Loss一样，如果遇到一些想要做个性化实现的操作时，我们也可以来通过框架完成自定义的评估计算方法，具体的实现方式如下：\n",
+    "\n",
+    "```python\n",
+    "class SelfDefineMetric(paddle.metric.Metric):\n",
+    "    \"\"\"\n",
+    "    1. 继承paddle.metric.Metric\n",
+    "    \"\"\"\n",
+    "    def __init__(self):\n",
+    "        \"\"\"\n",
+    "        2. 构造函数实现，自定义参数即可\n",
+    "        \"\"\"\n",
+    "        super(SelfDefineMetric, self).__init__()\n",
+    "\n",
+    "    def name(self):\n",
+    "        \"\"\"\n",
+    "        3. 实现name方法，返回定义的评估指标名字\n",
+    "        \"\"\"\n",
+    "        return '自定义评价指标的名字'\n",
+    "\n",
+    "    def compute(self, ...)\n",
+    "        \"\"\"\n",
+    "        4. 本步骤可以省略，实现compute方法，这个方法主要用于`update`的加速，可以在这个方法中调用一些paddle实现好的Tensor计算API，编译到模型网络中一起使用低层C++ OP计算。\n",
+    "        \"\"\"\n",
+    "\n",
+    "        return 自己想要返回的数据，会做为update的参数传入。\n",
+    "\n",
+    "    def update(self, ...):\n",
+    "        \"\"\"\n",
+    "        5. 实现update方法，用于单个batch训练时进行评估指标计算。\n",
+    "        - 当`compute`类函数未实现时，会将模型的计算输出和标签数据的展平作为`update`的参数传入。\n",
+    "        - 当`compute`类函数做了实现时，会将compute的返回结果作为`update`的参数传入。\n",
+    "        \"\"\"\n",
+    "        return acc value\n",
+    "    \n",
+    "    def accumulate(self):\n",
+    "        \"\"\"\n",
+    "        6. 实现accumulate方法，返回历史batch训练积累后计算得到的评价指标值。\n",
+    "        每次`update`调用时进行数据积累，`accumulate`计算时对积累的所有数据进行计算并返回。\n",
+    "        结算结果会在`fit`接口的训练日志中呈现。\n",
+    "        \"\"\"\n",
+    "        # 利用update中积累的成员变量数据进行计算后返回\n",
+    "        return accumulated acc value\n",
+    "\n",
+    "    def reset(self):\n",
+    "        \"\"\"\n",
+    "        7. 实现reset方法，每个Epoch结束后进行评估指标的重置，这样下个Epoch可以重新进行计算。\n",
+    "        \"\"\"\n",
+    "        # do reset action\n",
+    "```\n",
+    "\n",
+    "我们看一个框架中的具体例子，这个是框架中已提供的一个评估指标计算接口，这里就是按照上述说明中的实现方法进行了相关类继承和成员函数实现。\n",
+    "\n",
+    "```python\n",
+    "from paddle.metric import Metric\n",
+    "\n",
+    "\n",
+    "class Precision(Metric):\n",
+    "    \"\"\"\n",
+    "    Precision (also called positive predictive value) is the fraction of\n",
+    "    relevant instances among the retrieved instances. Refer to\n",
+    "    https://en.wikipedia.org/wiki/Evaluation_of_binary_classifiers\n",
+    "\n",
+    "    Noted that this class manages the precision score only for binary\n",
+    "    classification task.\n",
+    "    \n",
+    "    ......\n",
+    "\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(self, name='precision', *args, **kwargs):\n",
+    "        super(Precision, self).__init__(*args, **kwargs)\n",
+    "        self.tp = 0  # true positive\n",
+    "        self.fp = 0  # false positive\n",
+    "        self._name = name\n",
+    "\n",
+    "    def update(self, preds, labels):\n",
+    "        \"\"\"\n",
+    "        Update the states based on the current mini-batch prediction results.\n",
+    "\n",
+    "        Args:\n",
+    "            preds (numpy.ndarray): The prediction result, usually the output\n",
+    "                of two-class sigmoid function. It should be a vector (column\n",
+    "                vector or row vector) with data type: 'float64' or 'float32'.\n",
+    "            labels (numpy.ndarray): The ground truth (labels),\n",
+    "                the shape should keep the same as preds.\n",
+    "                The data type is 'int32' or 'int64'.\n",
+    "        \"\"\"\n",
+    "        if isinstance(preds, paddle.Tensor):\n",
+    "            preds = preds.numpy()\n",
+    "        elif not _is_numpy_(preds):\n",
+    "            raise ValueError(\"The 'preds' must be a numpy ndarray or Tensor.\")\n",
+    "\n",
+    "        if isinstance(labels, paddle.Tensor):\n",
+    "            labels = labels.numpy()\n",
+    "        elif not _is_numpy_(labels):\n",
+    "            raise ValueError(\"The 'labels' must be a numpy ndarray or Tensor.\")\n",
+    "\n",
+    "        sample_num = labels.shape[0]\n",
+    "        preds = np.floor(preds + 0.5).astype(\"int32\")\n",
+    "\n",
+    "        for i in range(sample_num):\n",
+    "            pred = preds[i]\n",
+    "            label = labels[i]\n",
+    "            if pred == 1:\n",
+    "                if pred == label:\n",
+    "                    self.tp += 1\n",
+    "                else:\n",
+    "                    self.fp += 1\n",
+    "\n",
+    "    def reset(self):\n",
+    "        \"\"\"\n",
+    "        Resets all of the metric state.\n",
+    "        \"\"\"\n",
+    "        self.tp = 0\n",
+    "        self.fp = 0\n",
+    "\n",
+    "    def accumulate(self):\n",
+    "        \"\"\"\n",
+    "        Calculate the final precision.\n",
+    "\n",
+    "        Returns:\n",
+    "            A scaler float: results of the calculated precision.\n",
+    "        \"\"\"\n",
+    "        ap = self.tp + self.fp\n",
+    "        return float(self.tp) / ap if ap != 0 else .0\n",
+    "\n",
+    "    def name(self):\n",
+    "        \"\"\"\n",
+    "        Returns metric name\n",
+    "        \"\"\"\n",
+    "        return self._name\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 5.5 自定义Callback\n",
+    "\n",
+    "`fit`接口的callback参数支持我们传一个Callback类实例，用来在每轮训练和每个batch训练前后进行调用，可以通过callback收集到训练过程中的一些数据和参数，或者实现一些自定义操作。\n",
+    "\n",
+    "```python\n",
+    "class SelfDefineCallback(paddle.callbacks.Callback):\n",
+    "    \"\"\"\n",
+    "    1. 继承paddle.callbacks.Callback\n",
+    "    2. 按照自己的需求实现以下类成员方法：\n",
+    "        def on_train_begin(self, logs=None)                 训练开始前，`Model.fit`接口中调用\n",
+    "        def on_train_end(self, logs=None)                   训练结束后，`Model.fit`接口中调用\n",
+    "        def on_eval_begin(self, logs=None)                  评估开始前，`Model.evaluate`接口调用\n",
+    "        def on_eval_end(self, logs=None)                    评估结束后，`Model.evaluate`接口调用\n",
+    "        def on_test_begin(self, logs=None)                  预测测试开始前，`Model.predict`接口中调用\n",
+    "        def on_test_end(self, logs=None)                    预测测试结束后，`Model.predict`接口中调用 \n",
+    "        def on_epoch_begin(self, epoch, logs=None)          每轮训练开始前，`Model.fit`接口中调用 \n",
+    "        def on_epoch_end(self, epoch, logs=None)            每轮训练结束后，`Model.fit`接口中调用 \n",
+    "        def on_train_batch_begin(self, step, logs=None)     单个Batch训练开始前，`Model.fit`和`Model.train_batch`接口中调用\n",
+    "        def on_train_batch_end(self, step, logs=None)       单个Batch训练结束后，`Model.fit`和`Model.train_batch`接口中调用\n",
+    "        def on_eval_batch_begin(self, step, logs=None)      单个Batch评估开始前，`Model.evalute`和`Model.eval_batch`接口中调用\n",
+    "        def on_eval_batch_end(self, step, logs=None)        单个Batch评估结束后，`Model.evalute`和`Model.eval_batch`接口中调用\n",
+    "        def on_test_batch_begin(self, step, logs=None)      单个Batch预测测试开始前，`Model.predict`和`Model.test_batch`接口中调用\n",
+    "        def on_test_batch_end(self, step, logs=None)        单个Batch预测测试结束后，`Model.predict`和`Model.test_batch`接口中调用\n",
+    "    \"\"\"\n",
+    "    def __init__(self):\n",
+    "        super(SelfDefineCallback, self).__init__()\n",
+    "\n",
+    "    按照需求定义自己的类成员方法\n",
+    "```\n",
+    "\n",
+    "我们看一个框架中的实际例子，这是一个框架自带的ModelCheckpoint回调函数，方便用户在fit训练模型时自动存储每轮训练得到的模型。\n",
+    "\n",
+    "```python\n",
+    "class ModelCheckpoint(Callback):\n",
+    "    def __init__(self, save_freq=1, save_dir=None):\n",
+    "        self.save_freq = save_freq\n",
+    "        self.save_dir = save_dir\n",
+    "\n",
+    "    def on_epoch_begin(self, epoch=None, logs=None):\n",
+    "        self.epoch = epoch\n",
+    "\n",
+    "    def _is_save(self):\n",
+    "        return self.model and self.save_dir and ParallelEnv().local_rank == 0\n",
+    "\n",
+    "    def on_epoch_end(self, epoch, logs=None):\n",
+    "        if self._is_save() and self.epoch % self.save_freq == 0:\n",
+    "            path = '{}/{}'.format(self.save_dir, epoch)\n",
+    "            print('save checkpoint at {}'.format(os.path.abspath(path)))\n",
+    "            self.model.save(path)\n",
+    "\n",
+    "    def on_train_end(self, logs=None):\n",
+    "        if self._is_save():\n",
+    "            path = '{}/final'.format(self.save_dir)\n",
+    "            print('save checkpoint at {}'.format(os.path.abspath(path)))\n",
+    "            self.model.save(path)\n",
+    "\n",
+    "```"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## 6. 模型评估\n",
     "\n",
-    "对于训练好的模型进行评估操作可以使用`evaluate`接口来实现。"
+    "对于训练好的模型进行评估操作可以使用`evaluate`接口来实现，事先定义好用于评估使用的数据集后，可以简单的调用`evaluate`接口即可完成模型评估操作，结束后根据prepare中loss和metric的定义来进行相关评估结果计算返回。\n",
+    "\n",
+    "返回格式是一个字典：\n",
+    "* 只包含loss，`{'loss': xxx}`\n",
+    "* 包含loss和一个评估指标，`{'loss': xxx, 'metric name': xxx}`\n",
+    "* 包含loss和多个评估指标，`{'loss': xxx, 'metric name': xxx, 'metric name': xxx}`"
    ]
   },
   {
@@ -577,7 +828,13 @@
    "source": [
     "## 7. 模型预测\n",
     "\n",
-    "高层API中提供`predict`接口，支持用户使用测试数据来完成模型的预测。"
+    "高层API中提供了`predict`接口来方便用户对训练好的模型进行预测验证，只需要基于训练好的模型将需要进行预测测试的数据放到接口中进行计算即可，接口会将经过模型计算得到的预测结果进行返回。\n",
+    "\n",
+    "返回格式是一个list，元素数目对应模型的输出数目：\n",
+    "* 模型是单一输出：[(numpy_ndarray_1, numpy_ndarray_2, ..., numpy_ndarray_n)]\n",
+    "* 模型是多输出：[(numpy_ndarray_1, numpy_ndarray_2, ..., numpy_ndarray_n), (numpy_ndarray_1, numpy_ndarray_2, ..., numpy_ndarray_n), ...]\n",
+    "\n",
+    "numpy_ndarray_n是对应原始数据经过模型计算后得到的预测数据，数目对应预测数据集的数目。"
    ]
   },
   {
@@ -589,6 +846,23 @@
     "pred_result = model.predict(val_dataset)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 7.1 使用多卡进行预测\n",
+    "\n",
+    "有时我们需要进行预测验证的数据较多，单卡无法满足我们的时间诉求，那么`predict`接口也为用户支持实现了使用多卡模式来运行。\n",
+    "\n",
+    "使用起来也是超级简单，无需修改代码程序，只需要使用launch来启动对应的预测脚本即可。\n",
+    "\n",
+    "```bash\n",
+    "$ python3 -m paddle.distributed.launch infer.py\n",
+    "```\n",
+    "\n",
+    "infer.py里面就是包含model.predict的代码程序。"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -597,7 +871,7 @@
     "\n",
     "### 8.1 模型存储\n",
     "\n",
-    "模型训练和验证达到我们的预期后，可以使用`save`接口来将我们的模型保存下来，用于后续模型的Fine-tuning或推理部署。"
+    "模型训练和验证达到我们的预期后，可以使用`save`接口来将我们的模型保存下来，用于后续模型的Fine-tuning（接口参数training=True）或推理部署（接口参数training=False）。"
    ]
   },
   {
diff --git a/paddle2.0_docs/image_segmentation/pets_image_segmentation_U_Net_like.ipynb b/paddle2.0_docs/image_segmentation/pets_image_segmentation_U_Net_like.ipynb
index b16235e..d439475 100644
--- a/paddle2.0_docs/image_segmentation/pets_image_segmentation_U_Net_like.ipynb
+++ b/paddle2.0_docs/image_segmentation/pets_image_segmentation_U_Net_like.ipynb
@@ -34,16 +34,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
-     "output_type": "execute_result",
      "data": {
-      "text/plain": "'0.0.0'"
+      "text/plain": [
+       "'0.0.0'"
+      ]
      },
+     "execution_count": 2,
      "metadata": {},
-     "execution_count": 1
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -140,10 +142,10 @@
     "├── test.txt\n",
     "├── trainval.txt\n",
     "├── trimaps\n",
-    "│    ├── Abyssinian_1.png\n",
-    "│    ├── Abyssinian_10.png\n",
-    "│    ├── ......\n",
-    "│    └── yorkshire_terrier_99.png\n",
+    "│    ├── Abyssinian_1.png\n",
+    "│    ├── Abyssinian_10.png\n",
+    "│    ├── ......\n",
+    "│    └── yorkshire_terrier_99.png\n",
     "└── xmls\n",
     "      ├── Abyssinian_1.xml\n",
     "      ├── Abyssinian_10.xml\n",
@@ -158,7 +160,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/",
@@ -171,9 +173,11 @@
    },
    "outputs": [
     {
-     "output_type": "stream",
      "name": "stdout",
-     "text": "用于训练的图片样本数量: 7390\n"
+     "output_type": "stream",
+     "text": [
+      "用于训练的图片样本数量: 7390\n"
+     ]
     }
    ],
    "source": [
@@ -218,7 +222,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -371,7 +375,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/",
@@ -383,15 +387,16 @@
    },
    "outputs": [
     {
-     "output_type": "display_data",
      "data": {
-      "text/plain": "<Figure size 432x288 with 2 Axes>",
-      "image/svg+xml": "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n  \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n<!-- Created with matplotlib (https://matplotlib.org/) -->\n<svg height=\"181.699943pt\" version=\"1.1\" viewBox=\"0 0 349.2 181.699943\" width=\"349.2pt\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n <defs>\n  <style type=\"text/css\">\n*{stroke-linecap:butt;stroke-linejoin:round;}\n  </style>\n </defs>\n <g id=\"figure_1\">\n  <g id=\"patch_1\">\n   <path d=\"M 0 181.699943 \nL 349.2 181.699943 \nL 349.2 0 \nL 0 0 \nz\n\" style=\"fill:none;\"/>\n  </g>\n  <g id=\"axes_1\">\n   <g clip-path=\"url(#p58ad9a7e6d)\">\n    <image height=\"153\" id=\"image6a21407320\" transform=\"scale(1 -1)translate(0 -153)\" width=\"153\" x=\"7.2\" xlink:href=\"data:image/png;base64,\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\" y=\"-21.499943\"/>\n   </g>\n   <g id=\"text_1\">\n    <!-- Train Image -->\n    <defs>\n     <path d=\"M -0.296875 72.90625 \nL 61.375 72.90625 \nL 61.375 64.59375 \nL 35.5 64.59375 \nL 35.5 0 \nL 25.59375 0 \nL 25.59375 64.59375 \nL -0.296875 64.59375 \nz\n\" id=\"DejaVuSans-84\"/>\n     <path d=\"M 41.109375 46.296875 \nQ 39.59375 47.171875 37.8125 47.578125 \nQ 36.03125 48 33.890625 48 \nQ 26.265625 48 22.1875 43.046875 \nQ 18.109375 38.09375 18.109375 28.8125 \nL 18.109375 0 \nL 9.078125 0 \nL 9.078125 54.6875 \nL 18.109375 54.6875 \nL 18.109375 46.1875 \nQ 20.953125 51.171875 25.484375 53.578125 \nQ 30.03125 56 36.53125 56 \nQ 37.453125 56 38.578125 55.875 \nQ 39.703125 55.765625 41.0625 55.515625 \nz\n\" id=\"DejaVuSans-114\"/>\n     <path d=\"M 34.28125 27.484375 \nQ 23.390625 27.484375 19.1875 25 \nQ 14.984375 22.515625 14.984375 16.5 \nQ 14.984375 11.71875 18.140625 8.90625 \nQ 21.296875 6.109375 26.703125 6.109375 \nQ 34.1875 6.109375 38.703125 11.40625 \nQ 43.21875 16.703125 43.21875 25.484375 \nL 43.21875 27.484375 \nz\nM 52.203125 31.203125 \nL 52.203125 0 \nL 43.21875 0 \nL 43.21875 8.296875 \nQ 40.140625 3.328125 35.546875 0.953125 \nQ 30.953125 -1.421875 24.3125 -1.421875 \nQ 15.921875 -1.421875 10.953125 3.296875 \nQ 6 8.015625 6 15.921875 \nQ 6 25.140625 12.171875 29.828125 \nQ 18.359375 34.515625 30.609375 34.515625 \nL 43.21875 34.515625 \nL 43.21875 35.40625 \nQ 43.21875 41.609375 39.140625 45 \nQ 35.0625 48.390625 27.6875 48.390625 \nQ 23 48.390625 18.546875 47.265625 \nQ 14.109375 46.140625 10.015625 43.890625 \nL 10.015625 52.203125 \nQ 14.9375 54.109375 19.578125 55.046875 \nQ 24.21875 56 28.609375 56 \nQ 40.484375 56 46.34375 49.84375 \nQ 52.203125 43.703125 52.203125 31.203125 \nz\n\" id=\"DejaVuSans-97\"/>\n     <path d=\"M 9.421875 54.6875 \nL 18.40625 54.6875 \nL 18.40625 0 \nL 9.421875 0 \nz\nM 9.421875 75.984375 \nL 18.40625 75.984375 \nL 18.40625 64.59375 \nL 9.421875 64.59375 \nz\n\" id=\"DejaVuSans-105\"/>\n     <path d=\"M 54.890625 33.015625 \nL 54.890625 0 \nL 45.90625 0 \nL 45.90625 32.71875 \nQ 45.90625 40.484375 42.875 44.328125 \nQ 39.84375 48.1875 33.796875 48.1875 \nQ 26.515625 48.1875 22.3125 43.546875 \nQ 18.109375 38.921875 18.109375 30.90625 \nL 18.109375 0 \nL 9.078125 0 \nL 9.078125 54.6875 \nL 18.109375 54.6875 \nL 18.109375 46.1875 \nQ 21.34375 51.125 25.703125 53.5625 \nQ 30.078125 56 35.796875 56 \nQ 45.21875 56 50.046875 50.171875 \nQ 54.890625 44.34375 54.890625 33.015625 \nz\n\" id=\"DejaVuSans-110\"/>\n     <path id=\"DejaVuSans-32\"/>\n     <path d=\"M 9.8125 72.90625 \nL 19.671875 72.90625 \nL 19.671875 0 \nL 9.8125 0 \nz\n\" id=\"DejaVuSans-73\"/>\n     <path d=\"M 52 44.1875 \nQ 55.375 50.25 60.0625 53.125 \nQ 64.75 56 71.09375 56 \nQ 79.640625 56 84.28125 50.015625 \nQ 88.921875 44.046875 88.921875 33.015625 \nL 88.921875 0 \nL 79.890625 0 \nL 79.890625 32.71875 \nQ 79.890625 40.578125 77.09375 44.375 \nQ 74.3125 48.1875 68.609375 48.1875 \nQ 61.625 48.1875 57.5625 43.546875 \nQ 53.515625 38.921875 53.515625 30.90625 \nL 53.515625 0 \nL 44.484375 0 \nL 44.484375 32.71875 \nQ 44.484375 40.625 41.703125 44.40625 \nQ 38.921875 48.1875 33.109375 48.1875 \nQ 26.21875 48.1875 22.15625 43.53125 \nQ 18.109375 38.875 18.109375 30.90625 \nL 18.109375 0 \nL 9.078125 0 \nL 9.078125 54.6875 \nL 18.109375 54.6875 \nL 18.109375 46.1875 \nQ 21.1875 51.21875 25.484375 53.609375 \nQ 29.78125 56 35.6875 56 \nQ 41.65625 56 45.828125 52.96875 \nQ 50 49.953125 52 44.1875 \nz\n\" id=\"DejaVuSans-109\"/>\n     <path d=\"M 45.40625 27.984375 \nQ 45.40625 37.75 41.375 43.109375 \nQ 37.359375 48.484375 30.078125 48.484375 \nQ 22.859375 48.484375 18.828125 43.109375 \nQ 14.796875 37.75 14.796875 27.984375 \nQ 14.796875 18.265625 18.828125 12.890625 \nQ 22.859375 7.515625 30.078125 7.515625 \nQ 37.359375 7.515625 41.375 12.890625 \nQ 45.40625 18.265625 45.40625 27.984375 \nz\nM 54.390625 6.78125 \nQ 54.390625 -7.171875 48.1875 -13.984375 \nQ 42 -20.796875 29.203125 -20.796875 \nQ 24.46875 -20.796875 20.265625 -20.09375 \nQ 16.0625 -19.390625 12.109375 -17.921875 \nL 12.109375 -9.1875 \nQ 16.0625 -11.328125 19.921875 -12.34375 \nQ 23.78125 -13.375 27.78125 -13.375 \nQ 36.625 -13.375 41.015625 -8.765625 \nQ 45.40625 -4.15625 45.40625 5.171875 \nL 45.40625 9.625 \nQ 42.625 4.78125 38.28125 2.390625 \nQ 33.9375 0 27.875 0 \nQ 17.828125 0 11.671875 7.65625 \nQ 5.515625 15.328125 5.515625 27.984375 \nQ 5.515625 40.671875 11.671875 48.328125 \nQ 17.828125 56 27.875 56 \nQ 33.9375 56 38.28125 53.609375 \nQ 42.625 51.21875 45.40625 46.390625 \nL 45.40625 54.6875 \nL 54.390625 54.6875 \nz\n\" id=\"DejaVuSans-103\"/>\n     <path d=\"M 56.203125 29.59375 \nL 56.203125 25.203125 \nL 14.890625 25.203125 \nQ 15.484375 15.921875 20.484375 11.0625 \nQ 25.484375 6.203125 34.421875 6.203125 \nQ 39.59375 6.203125 44.453125 7.46875 \nQ 49.3125 8.734375 54.109375 11.28125 \nL 54.109375 2.78125 \nQ 49.265625 0.734375 44.1875 -0.34375 \nQ 39.109375 -1.421875 33.890625 -1.421875 \nQ 20.796875 -1.421875 13.15625 6.1875 \nQ 5.515625 13.8125 5.515625 26.8125 \nQ 5.515625 40.234375 12.765625 48.109375 \nQ 20.015625 56 32.328125 56 \nQ 43.359375 56 49.78125 48.890625 \nQ 56.203125 41.796875 56.203125 29.59375 \nz\nM 47.21875 32.234375 \nQ 47.125 39.59375 43.09375 43.984375 \nQ 39.0625 48.390625 32.421875 48.390625 \nQ 24.90625 48.390625 20.390625 44.140625 \nQ 15.875 39.890625 15.1875 32.171875 \nz\n\" id=\"DejaVuSans-101\"/>\n    </defs>\n    <g transform=\"translate(48.199347 16.318125)scale(0.12 -0.12)\">\n     <use xlink:href=\"#DejaVuSans-84\"/>\n     <use x=\"46.333984\" xlink:href=\"#DejaVuSans-114\"/>\n     <use x=\"87.447266\" xlink:href=\"#DejaVuSans-97\"/>\n     <use x=\"148.726562\" xlink:href=\"#DejaVuSans-105\"/>\n     <use x=\"176.509766\" xlink:href=\"#DejaVuSans-110\"/>\n     <use x=\"239.888672\" xlink:href=\"#DejaVuSans-32\"/>\n     <use x=\"271.675781\" xlink:href=\"#DejaVuSans-73\"/>\n     <use x=\"301.167969\" xlink:href=\"#DejaVuSans-109\"/>\n     <use x=\"398.580078\" xlink:href=\"#DejaVuSans-97\"/>\n     <use x=\"459.859375\" xlink:href=\"#DejaVuSans-103\"/>\n     <use x=\"523.335938\" xlink:href=\"#DejaVuSans-101\"/>\n    </g>\n   </g>\n  </g>\n  <g id=\"axes_2\">\n   <g clip-path=\"url(#pf02e2d733d)\">\n    <image height=\"153\" id=\"imageb081ed1ee7\" transform=\"scale(1 -1)translate(0 -153)\" width=\"153\" x=\"189.818182\" xlink:href=\"data:image/png;base64,\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\" y=\"-21.499943\"/>\n   </g>\n   <g id=\"text_2\">\n    <!-- Label -->\n    <defs>\n     <path d=\"M 9.8125 72.90625 \nL 19.671875 72.90625 \nL 19.671875 8.296875 \nL 55.171875 8.296875 \nL 55.171875 0 \nL 9.8125 0 \nz\n\" id=\"DejaVuSans-76\"/>\n     <path d=\"M 48.6875 27.296875 \nQ 48.6875 37.203125 44.609375 42.84375 \nQ 40.53125 48.484375 33.40625 48.484375 \nQ 26.265625 48.484375 22.1875 42.84375 \nQ 18.109375 37.203125 18.109375 27.296875 \nQ 18.109375 17.390625 22.1875 11.75 \nQ 26.265625 6.109375 33.40625 6.109375 \nQ 40.53125 6.109375 44.609375 11.75 \nQ 48.6875 17.390625 48.6875 27.296875 \nz\nM 18.109375 46.390625 \nQ 20.953125 51.265625 25.265625 53.625 \nQ 29.59375 56 35.59375 56 \nQ 45.5625 56 51.78125 48.09375 \nQ 58.015625 40.1875 58.015625 27.296875 \nQ 58.015625 14.40625 51.78125 6.484375 \nQ 45.5625 -1.421875 35.59375 -1.421875 \nQ 29.59375 -1.421875 25.265625 0.953125 \nQ 20.953125 3.328125 18.109375 8.203125 \nL 18.109375 0 \nL 9.078125 0 \nL 9.078125 75.984375 \nL 18.109375 75.984375 \nz\n\" id=\"DejaVuSans-98\"/>\n     <path d=\"M 9.421875 75.984375 \nL 18.40625 75.984375 \nL 18.40625 0 \nL 9.421875 0 \nz\n\" id=\"DejaVuSans-108\"/>\n    </defs>\n    <g transform=\"translate(249.721278 16.318125)scale(0.12 -0.12)\">\n     <use xlink:href=\"#DejaVuSans-76\"/>\n     <use x=\"55.712891\" xlink:href=\"#DejaVuSans-97\"/>\n     <use x=\"116.992188\" xlink:href=\"#DejaVuSans-98\"/>\n     <use x=\"180.46875\" xlink:href=\"#DejaVuSans-101\"/>\n     <use x=\"241.992188\" xlink:href=\"#DejaVuSans-108\"/>\n    </g>\n   </g>\n  </g>\n </g>\n <defs>\n  <clipPath id=\"p58ad9a7e6d\">\n   <rect height=\"152.181818\" width=\"152.181818\" x=\"7.2\" y=\"22.318125\"/>\n  </clipPath>\n  <clipPath id=\"pf02e2d733d\">\n   <rect height=\"152.181818\" width=\"152.181818\" x=\"189.818182\" y=\"22.318125\"/>\n  </clipPath>\n </defs>\n</svg>\n",
-      "image/png": "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\n"
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
      },
      "metadata": {
       "needs_background": "light"
-     }
+     },
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -706,7 +711,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "metadata": {
     "colab": {
      "base_uri": "https://localhost:8080/",
@@ -719,17 +724,56 @@
    },
    "outputs": [
     {
-     "output_type": "stream",
      "name": "stdout",
-     "text": "--------------------------------------------------------------------------------\n   Layer (type)          Input Shape         Output Shape         Param #\n================================================================================\n      Conv2d-22    [-1, 3, 160, 160]     [-1, 32, 80, 80]             896\n  BatchNorm2d-9     [-1, 32, 80, 80]     [-1, 32, 80, 80]              64\n         ReLU-9     [-1, 32, 80, 80]     [-1, 32, 80, 80]               0\n        ReLU-12    [-1, 256, 20, 20]    [-1, 256, 20, 20]               0\n      Conv2d-33    [-1, 128, 20, 20]    [-1, 128, 20, 20]           1,152\n      Conv2d-34    [-1, 128, 20, 20]    [-1, 256, 20, 20]          33,024\nSeparableConv2d-11    [-1, 128, 20, 20]    [-1, 256, 20, 20]               0\n BatchNorm2d-12    [-1, 256, 20, 20]    [-1, 256, 20, 20]             512\n      Conv2d-35    [-1, 256, 20, 20]    [-1, 256, 20, 20]           2,304\n      Conv2d-36    [-1, 256, 20, 20]    [-1, 256, 20, 20]          65,792\nSeparableConv2d-12    [-1, 256, 20, 20]    [-1, 256, 20, 20]               0\n    MaxPool2d-6    [-1, 256, 20, 20]    [-1, 256, 10, 10]               0\n      Conv2d-37    [-1, 128, 20, 20]    [-1, 256, 10, 10]          33,024\n      Encoder-6    [-1, 128, 20, 20]    [-1, 256, 10, 10]               0\n        ReLU-16     [-1, 32, 80, 80]     [-1, 32, 80, 80]               0\nConvTranspose2d-15     [-1, 64, 80, 80]     [-1, 32, 80, 80]          18,464\n BatchNorm2d-16     [-1, 32, 80, 80]     [-1, 32, 80, 80]              64\nConvTranspose2d-16     [-1, 32, 80, 80]     [-1, 32, 80, 80]           9,248\n     UpSample-8     [-1, 64, 80, 80]   [-1, 64, 160, 160]               0\n      Conv2d-41   [-1, 64, 160, 160]   [-1, 32, 160, 160]           2,080\n      Decoder-8     [-1, 64, 80, 80]   [-1, 32, 160, 160]               0\n      Conv2d-42   [-1, 32, 160, 160]    [-1, 4, 160, 160]           1,156\n================================================================================\nTotal params: 167,780\nTrainable params: 167,780\nNon-trainable params: 0\n--------------------------------------------------------------------------------\nInput size (MB): 0.29\nForward/backward pass size (MB): 43.16\nParams size (MB): 0.64\nEstimated Total Size (MB): 44.10\n--------------------------------------------------------------------------------\n\n"
+     "output_type": "stream",
+     "text": [
+      "--------------------------------------------------------------------------------\n",
+      "   Layer (type)          Input Shape         Output Shape         Param #\n",
+      "================================================================================\n",
+      "       Conv2d-1    [-1, 3, 160, 160]     [-1, 32, 80, 80]             896\n",
+      "  BatchNorm2d-1     [-1, 32, 80, 80]     [-1, 32, 80, 80]              64\n",
+      "         ReLU-1     [-1, 32, 80, 80]     [-1, 32, 80, 80]               0\n",
+      "         ReLU-4    [-1, 256, 20, 20]    [-1, 256, 20, 20]               0\n",
+      "      Conv2d-12    [-1, 128, 20, 20]    [-1, 128, 20, 20]           1,152\n",
+      "      Conv2d-13    [-1, 128, 20, 20]    [-1, 256, 20, 20]          33,024\n",
+      "SeparableConv2d-5    [-1, 128, 20, 20]    [-1, 256, 20, 20]               0\n",
+      "  BatchNorm2d-4    [-1, 256, 20, 20]    [-1, 256, 20, 20]             512\n",
+      "      Conv2d-14    [-1, 256, 20, 20]    [-1, 256, 20, 20]           2,304\n",
+      "      Conv2d-15    [-1, 256, 20, 20]    [-1, 256, 20, 20]          65,792\n",
+      "SeparableConv2d-6    [-1, 256, 20, 20]    [-1, 256, 20, 20]               0\n",
+      "    MaxPool2d-3    [-1, 256, 20, 20]    [-1, 256, 10, 10]               0\n",
+      "      Conv2d-16    [-1, 128, 20, 20]    [-1, 256, 10, 10]          33,024\n",
+      "      Encoder-3    [-1, 128, 20, 20]    [-1, 256, 10, 10]               0\n",
+      "         ReLU-8     [-1, 32, 80, 80]     [-1, 32, 80, 80]               0\n",
+      "ConvTranspose2d-7     [-1, 64, 80, 80]     [-1, 32, 80, 80]          18,464\n",
+      "  BatchNorm2d-8     [-1, 32, 80, 80]     [-1, 32, 80, 80]              64\n",
+      "ConvTranspose2d-8     [-1, 32, 80, 80]     [-1, 32, 80, 80]           9,248\n",
+      "     UpSample-4     [-1, 64, 80, 80]   [-1, 64, 160, 160]               0\n",
+      "      Conv2d-20   [-1, 64, 160, 160]   [-1, 32, 160, 160]           2,080\n",
+      "      Decoder-4     [-1, 64, 80, 80]   [-1, 32, 160, 160]               0\n",
+      "      Conv2d-21   [-1, 32, 160, 160]    [-1, 4, 160, 160]           1,156\n",
+      "================================================================================\n",
+      "Total params: 167,780\n",
+      "Trainable params: 167,780\n",
+      "Non-trainable params: 0\n",
+      "--------------------------------------------------------------------------------\n",
+      "Input size (MB): 0.29\n",
+      "Forward/backward pass size (MB): 43.16\n",
+      "Params size (MB): 0.64\n",
+      "Estimated Total Size (MB): 44.10\n",
+      "--------------------------------------------------------------------------------\n",
+      "\n"
+     ]
     },
     {
-     "output_type": "execute_result",
      "data": {
-      "text/plain": "{'total_params': 167780, 'trainable_params': 167780}"
+      "text/plain": [
+       "{'total_params': 167780, 'trainable_params': 167780}"
+      ]
      },
+     "execution_count": 10,
      "metadata": {},
-     "execution_count": 11
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -765,7 +809,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -793,7 +837,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 11,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -846,15 +890,12 @@
     "                                 epsilon=1e-07, \n",
     "                                 centered=False,\n",
     "                                 parameters=model.parameters())\n",
-    "model = paddle.Model(PetModel(num_classes, model_tools))\n",
-    "model.prepare(optim, \n",
-    "              SoftmaxWithCrossEntropy())\n",
-    "\n",
+    "model = paddle.Model(PetModel(num_classes))\n",
+    "model.prepare(optim, SoftmaxWithCrossEntropy())\n",
     "model.fit(train_dataset, \n",
-    "    val_dataset, \n",
-    "    epochs=EPOCHS, \n",
-    "    batch_size=BATCH_SIZE\n",
-    ")"
+    "          val_dataset, \n",
+    "          epochs=EPOCHS, \n",
+    "          batch_size=BATCH_SIZE)"
    ]
   },
   {
@@ -887,7 +928,8 @@
    "metadata": {
     "colab": {},
     "colab_type": "code",
-    "id": "Ur088_vjeSdR"
+    "id": "Ur088_vjeSdR",
+    "tags": []
    },
    "outputs": [],
    "source": [
@@ -912,10 +954,12 @@
    "metadata": {
     "colab": {},
     "colab_type": "code",
-    "id": "1mfaFkO5S1PU"
+    "id": "1mfaFkO5S1PU",
+    "tags": []
    },
    "outputs": [],
    "source": [
+    "print(len(predict_results))\n",
     "plt.figure(figsize=(10, 10))\n",
     "\n",
     "i = 0\n",
@@ -934,8 +978,9 @@
     "    plt.title('Label')\n",
     "    plt.axis(\"off\")\n",
     "    \n",
-    "    \n",
-    "    data = val_preds[0][mask_idx][0].transpose((1, 2, 0))\n",
+    "    # 模型只有一个输出，所以我们通过predict_results[0]来取出1000个预测的结果\n",
+    "    # 映射原始图片的index来取出预测结果，提取mask进行展示\n",
+    "    data = predict_results[0][mask_idx][0].transpose((1, 2, 0))\n",
     "    mask = np.argmax(data, axis=-1)\n",
     "    mask = np.expand_dims(mask, axis=-1)\n",
     "\n",
@@ -961,7 +1006,7 @@
   "kernelspec": {
    "display_name": "Python 3.7.4 64-bit",
    "language": "python",
-   "name": "python_defaultSpec_1599452401282"
+   "name": "python37464bitc4da1ac836094043840bff631bedbf7f"
   },
   "language_info": {
    "codemirror_mode": {
@@ -973,9 +1018,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.4-final"
+   "version": "3.7.4"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 1
-}
\ No newline at end of file
+}
-- 
GitLab