fix lr 9.12

a45248a4 · swtkiwi · 02b3916d · a45248a4
隐藏空白更改
内联并排

Showing with 112 addition and 141 deletion

paddle2.0_docs/linear_regression/linear_regression.ipynb paddle2.0_docs/linear_regression/linear_regression.ipynb +112 -141

未找到文件。
--- a/paddle2.0_docs/linear_regression/linear_regression.ipynb
+++ b/paddle2.0_docs/linear_regression/linear_regression.ipynb
@@ -18,7 +18,7 @@
    "id": "6lPmRFntXYIp"
   },
   "source": [
-    "# 简要介绍\n",
+    "## 简要介绍\n",
    "经典的线性回归模型主要用来预测一些存在着线性关系的数据集。回归模型可以理解为：存在一个点集，用一条曲线去拟合它分布的过程。如果拟合曲线是一条直线，则称为线性回归。如果是一条二次曲线，则被称为二次回归。线性回归是回归模型中最简单的一种。 \n",
    "本示例简要介绍如何用飞桨开源框架，实现波士顿房价预测。其思路是，假设uci-housing数据集中的房子属性和房价之间的关系可以被属性间的线性组合描述。在模型训练阶段，让假设的预测结果和真实值之间的误差越来越小。在模型预测阶段，预测器会读取训练好的模型，对从未遇见过的房子属性进行房价预测。"
   ]
@@ -30,7 +30,7 @@
    "id": "OEOMtGXCZaRR"
   },
   "source": [
-    "# 数据集介绍\n",
+    "## 数据集介绍\n",
    "本示例采用uci-housing数据集，这是经典线性回归的数据集。数据集共7084条数据，可以拆分成506行,每行14列。前13列用来描述房屋的各种信息，最后一列为该类房屋价格中位数。"
   ]
  },
@@ -47,14 +47,14 @@
   "cell_type": "markdown",
   "metadata": {},
   "source": [
-    "# 训练方式一\n"
+    "## 训练方式一\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
-    "## 环境设置"
+    "### 环境设置"
   ]
  },
  {
@@ -90,7 +90,7 @@
   "cell_type": "markdown",
   "metadata": {},
   "source": [
-    "## 数据处理"
+    "### 数据处理"
   ]
  },
  {
@@ -139,13 +139,13 @@
   ],
   "source": [
    "# 画图看特征间的关系,主要是变量两两之间的关系（线性或非线性，有无明显较为相关关系）\n",
-    "features_np = np.array([x[:13] for x in housing_data],np.float32)\n",
-    "labels_np = np.array([x[-1] for x in housing_data],np.float32)\n",
-    "data_np = np.c_[features_np,labels_np]\n",
-    "df = pd.DataFrame(data_np,columns=feature_names)\n",
+    "features_np = np.array([x[:13] for x in housing_data], np.float32)\n",
+    "labels_np = np.array([x[-1] for x in housing_data], np.float32)\n",
+    "data_np = np.c_[features_np, labels_np]\n",
+    "df = pd.DataFrame(data_np, columns=feature_names)\n",
    "matplotlib.use('TkAgg')\n",
    "%matplotlib inline\n",
-    "sns.pairplot(df.dropna(),y_vars=feature_names[-1],x_vars=feature_names[:])\n",
+    "sns.pairplot(df.dropna(), y_vars=feature_names[-1], x_vars=feature_names[:])\n",
    "plt.show()"
   ]
  },
@@ -169,11 +169,11 @@
   ],
   "source": [
    "# 相关性分析\n",
-    "fig, ax = plt.subplots(figsize=(15,1)) \n",
+    "fig, ax = plt.subplots(figsize=(15, 1)) \n",
    "corr_data = df.corr().iloc[-1]\n",
-    "corr_data = np.asarray(corr_data).reshape(1,14)\n",
-    "ax = sns.heatmap(corr_data, cbar=True,annot=True)\n",
-    "plt.show()\n"
+    "corr_data = np.asarray(corr_data).reshape(1, 14)\n",
+    "ax = sns.heatmap(corr_data, cbar=True, annot=True)\n",
+    "plt.show()"
   ]
  },
  {
@@ -183,13 +183,7 @@
    "id": "IUhqen8LWAYM"
   },
   "source": [
-    "***数据归一化处理***\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
+    "***数据归一化处理***<br>\n",
    "下图为大家展示各属性的取值范围分布："
   ]
  },
@@ -201,7 +195,7 @@
    {
     "data": {
      "text/plain": [
-       "<matplotlib.axes._subplots.AxesSubplot at 0x1a324e6910>"
+       "<matplotlib.axes._subplots.AxesSubplot at 0x1a3e2b4e50>"
      ]
     },
     "execution_count": 6,
@@ -222,7 +216,7 @@
    }
   ],
   "source": [
-    "sns.boxplot(data=df.iloc[:,0:13])"
+    "sns.boxplot(data=df.iloc[:, 0:13])"
   ]
  },
  {
@@ -237,13 +231,10 @@
   "metadata": {},
   "source": [
    "\n",
-    "做归一化（或 Feature scaling）至少有以下3个理由：\n",
+    "做归一化（或 Feature scaling）至少有以下2个理由：\n",
    "\n",
    "*   过大或过小的数值范围会导致计算时的浮点上溢或下溢。\n",
    "*   不同的数值范围会导致不同属性对模型的重要性不同（至少在训练的初始阶段如此），而这个隐含的假设常常是不合理的。这会对优化的过程造成困难，使训练时间大大的加长.\n",
-    "\n",
-    "*   很多的机器学习技巧/模型（例如L1，L2正则项，向量空间模型-Vector Space Model）都基于这样的假设：所有的属性取值都差不多是以0为均值且取值范围相近的。\n",
-    "\n",
    "\n"
   ]
  },
@@ -255,7 +246,7 @@
   "source": [
    "features_max = housing_data.max(axis=0)\n",
    "features_min = housing_data.min(axis=0)\n",
-    "features_avg = housing_data.sum(axis=0) / 506"
+    "features_avg = housing_data.sum(axis=0) / housing_data.shape[0]"
   ]
  },
  {
@@ -267,7 +258,7 @@
    "BATCH_SIZE = 20\n",
    "def feature_norm(input):\n",
    "    f_size = input.shape\n",
-    "    output_features = np.zeros(f_size,np.float32)\n",
+    "    output_features = np.zeros(f_size, np.float32)\n",
    "    for batch_id in range(f_size[0]):\n",
    "        for index in range(13):\n",
    "            output_features[batch_id][index] = (input[batch_id][index] - features_avg[index]) / (features_max[index] - features_min[index])\n",
@@ -281,9 +272,9 @@
   "outputs": [],
   "source": [
    "#只对属性进行归一化\n",
-    "housing_features = feature_norm(housing_data[:,:13])\n",
+    "housing_features = feature_norm(housing_data[:, :13])\n",
    "# print(feature_trian.shape)\n",
-    "housing_data = np.c_[housing_features,housing_data[:,-1]].astype(np.float32)\n",
+    "housing_data = np.c_[housing_features, housing_data[:, -1]].astype(np.float32)\n",
    "# print(training_data[0])"
   ]
  },
@@ -295,7 +286,7 @@
    {
     "data": {
      "text/plain": [
-       "<matplotlib.axes._subplots.AxesSubplot at 0x1a326f51d0>"
+       "<matplotlib.axes._subplots.AxesSubplot at 0x1a3e4cd4d0>"
      ]
     },
     "execution_count": 10,
@@ -319,9 +310,9 @@
    "#归一化后的train_data,我们看下各属性的情况\n",
    "features_np = np.array([x[:13] for x in housing_data],np.float32)\n",
    "labels_np = np.array([x[-1] for x in housing_data],np.float32)\n",
-    "data_np = np.c_[features_np,labels_np]\n",
-    "df = pd.DataFrame(data_np,columns=feature_names)\n",
-    "sns.boxplot(data=df.iloc[:,0:13])"
+    "data_np = np.c_[features_np, labels_np]\n",
+    "df = pd.DataFrame(data_np, columns=feature_names)\n",
+    "sns.boxplot(data=df.iloc[:, 0:13])"
   ]
  },
  {
@@ -334,7 +325,7 @@
    "ratio = 0.8\n",
    "offset = int(housing_data.shape[0] * ratio)\n",
    "train_data = housing_data[:offset]\n",
-    "test_data = housing_data[offset:]\n"
+    "test_data = housing_data[offset:]"
   ]
  },
  {
@@ -344,7 +335,7 @@
    "id": "JkEt541Cl0s8"
   },
   "source": [
-    "# 模型配置\n",
+    "### 模型配置\n",
    "线性回归就是一个从输入到输出的简单的全连接层。\n",
    "\n",
    "对于波士顿房价数据集，假设属性和房价之间的关系可以被属性间的线性组合描述。"
@@ -362,10 +353,10 @@
   "source": [
    "class Regressor(paddle.nn.Layer):\n",
    "    def __init__(self):\n",
-    "        super(Regressor,self).__init__()\n",
-    "        self.fc = paddle.nn.Linear(13,1,None)\n",
+    "        super(Regressor, self).__init__()\n",
+    "        self.fc = paddle.nn.Linear(13, 1,)\n",
    "\n",
-    "    def forward(self,inputs):\n",
+    "    def forward(self, inputs):\n",
    "        pred = self.fc(inputs)\n",
    "        return pred"
   ]
@@ -383,17 +374,15 @@
   "metadata": {},
   "outputs": [],
   "source": [
-    "iter = 0\n",
-    "iters = []\n",
+    "train_nums = []\n",
    "train_costs = []\n",
    "\n",
-    "def draw_train_process(iters,train_costs):\n",
-    "    plt.title(\"training cost\" ,fontsize=24)\n",
+    "def draw_train_process(iters, train_costs):\n",
+    "    plt.title(\"training cost\", fontsize=24)\n",
    "    plt.xlabel(\"iter\", fontsize=14)\n",
    "    plt.ylabel(\"cost\", fontsize=14)\n",
-    "    plt.plot(iters, train_costs,color='red',label='training cost')\n",
-    "    plt.show()\n",
-    "    "
+    "    plt.plot(iters, train_costs, color='red', label='training cost')\n",
+    "    plt.show()"
   ]
  },
  {
@@ -403,7 +392,7 @@
    "id": "oxD989B_cBjF"
   },
   "source": [
-    "# 模型训练\n",
+    "### 模型训练\n",
    "下面为大家展示模型训练的代码。\n",
    "这里用到的是线性回归模型最常用的损失函数--均方误差（MSE），用来衡量模型预测的房价和真实房价的差异。\n",
    "对损失函数进行优化所采用的方法是梯度下降法"
@@ -427,20 +416,21 @@
     "output_type": "stream",
     "text": [
      "start training ... \n",
-      "Pass:0,Cost:503.44180\n",
-      "Pass:50,Cost:79.73357\n",
-      "Pass:100,Cost:132.61421\n",
-      "Pass:150,Cost:9.58433\n",
-      "Pass:200,Cost:39.33120\n",
-      "Pass:250,Cost:17.30551\n",
-      "Pass:300,Cost:22.21836\n",
-      "Pass:350,Cost:55.45938\n",
-      "Pass:400,Cost:14.99360\n",
-      "Pass:450,Cost:36.95673\n"
+      "Pass:0,Cost:740.21814\n",
+      "Pass:50,Cost:36.40338\n",
+      "Pass:100,Cost:86.01823\n",
+      "Pass:150,Cost:50.86654\n",
+      "Pass:200,Cost:31.14208\n",
+      "Pass:250,Cost:20.54596\n",
+      "Pass:300,Cost:22.30817\n",
+      "Pass:350,Cost:24.18756\n",
+      "Pass:400,Cost:22.22965\n",
+      "Pass:450,Cost:39.25978\n"
     ]
    }
   ],
   "source": [
+    "import paddle.nn.functional as F \n",
    "y_preds = []\n",
    "labels_list = []\n",
    "\n",
@@ -449,39 +439,36 @@
    "    # 开启模型训练模式\n",
    "    model.train()\n",
    "    EPOCH_NUM = 500\n",
-    "    iter = 0\n",
-    "    optimizer = paddle.optimizer.SGD(learning_rate = 0.001, parameters = model.parameters())\n",
+    "    train_num = 0\n",
+    "    optimizer = paddle.optimizer.SGD(learning_rate=0.001, parameters=model.parameters())\n",
    "    for epoch_id in range(EPOCH_NUM):\n",
-    "        train_cost = 0\n",
    "        # 在每轮迭代开始之前，将训练数据的顺序随机的打乱\n",
    "        np.random.shuffle(train_data)\n",
    "        # 将训练数据进行拆分，每个batch包含20条数据\n",
    "        mini_batches = [train_data[k:k+BATCH_SIZE] for k in range(0, len(train_data), BATCH_SIZE)]\n",
-    "        for batch_id,data in enumerate(mini_batches):\n",
-    "            features_np = np.array(data[:,:13],np.float32)\n",
-    "            labels_np = np.array(data[:,-1:],np.float32)\n",
+    "        for batch_id, data in enumerate(mini_batches):\n",
+    "            features_np = np.array(data[:, :13], np.float32)\n",
+    "            labels_np = np.array(data[:, -1:], np.float32)\n",
    "            features = paddle.to_tensor(features_np)\n",
    "            labels = paddle.to_tensor(labels_np)\n",
    "            #前向计算\n",
    "            y_pred = model(features)\n",
-    "            cost = paddle.nn.functional.mse_loss(y_pred,label=labels)\n",
-    "            train_cost = [cost.numpy()]\n",
+    "            cost = F.mse_loss(y_pred, label=labels)\n",
+    "            train_cost = cost.numpy()[0]\n",
    "            #反向传播\n",
    "            cost.backward()\n",
    "            #最小化loss，更新参数\n",
    "            optimizer.step()\n",
    "            # 清除梯度\n",
    "            optimizer.clear_grad()\n",
+    "            \n",
    "            if batch_id%30 == 0 and epoch_id%50 == 0:\n",
-    "                print(\"Pass:%d,Cost:%0.5f\"%(epoch_id,train_cost[0][0]))\n",
+    "                print(\"Pass:%d,Cost:%0.5f\"%(epoch_id, train_cost))\n",
    "\n",
-    "            iter = iter + BATCH_SIZE\n",
-    "            iters.append(iter)\n",
-    "            train_costs.append(train_cost[0][0])\n",
+    "            train_num = train_num + BATCH_SIZE\n",
+    "            train_nums.append(train_num)\n",
+    "            train_costs.append(train_cost)\n",
    "        \n",
-    "            \n",
-    "          \n",
-    "\n",
    "model = Regressor()\n",
    "train(model)"
   ]
@@ -493,7 +480,7 @@
   "outputs": [
    {
     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAEjCAYAAADHWv01AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dd7wcVf3/8deHQABBIZBAMAFDCfqlKkSKqEgRAUUixR98FRIMRkEERaUpguWLAkpTeheRYugIAQSC1MClBVIghVRCeiWk3s/vjzPj7t27s3f33t2d2Xvfz8djHzNzpp2dnZnPzjlnZszdERERKWattDMgIiLZpSAhIiKJFCRERCSRgoSIiCRSkBARkUQKEiIikkhBQjoNM7vFzNzMzq/ycidHy/1KNZcr0gjWTjsD0vjMbDDQD7jf3d9INzfSCLTPNA4FCamGwcC+wGQgzQN+JvAOMLfKy50ILAeWVXm5XdlgsrHPSBsUJKTTcPezgbNrsNwDqr1MkUahOgkREUmkICHtZmaDzcwJxQYAN0cVvPFncuG0ZjYiGv6OmT1jZvOi9IFRejcz28/MLjezV81slpmtNLP3zew+M9u/RH6KVlybWb84T9HwTmZ2p5l9YGbLzWycmZ1rZt0Tllu04rrIdzrMzJ42s4VmttTMXjKzY9vYhn3N7EYzmxHlZZKZXWpmPQqXXykzW8fMhprZk2Y2x8xWmNkUM3s8St+gyDzrmtnpZjbSzBaZ2Udm9o6ZXWJmvUusa1cz+1u0rVaY2ZLouww3s5+Y2cfytxll7DOSEe6ujz7t+gD/D/gAWAk4sCgajj+v5E07OJpmBHBF1L8GmB91B0bT7RSNiz/LgaUFaeck5OeWaPz5Ben98uY9iFC34MDCaN3xuPsTljs5Gv+VgvT873Ru3ndaWJDfnyQsdxdgXt50S/LyNgE4PV5+O36bPsDrecteAywAmvPSCr9PL+C1gm2/OG94PrBXkXUdmrcPxPMtKtgGn6l0n9EnG5/UM6BP43+ik6QDg0tME59Ql0Qnql8DG0fjPgFsFvVvD9wNfAPYHLAofTPgV8DqaP49i6yjnCCxALgL6BeN2wA4K+/keWiR5bYVJBZE+fpV3nfaHPhnNP4jYJOCedclVLI78C6wT5S+FnAIoRJ+QXuCRLTsV6N55wDHAxtE49YHBgCXFm5D4NG8YHA00C1KHwCMisZ9APQsmG9iNO4hYPu89E8AXwKui7d3JfuMPtn4pJ4BfRr/U2GQcOCCDqwr/sd+c5Fx5QSJx+PAUzDNQ9H4m4qMaytIOPDLIvOtB8yOxh9fMO6EvACyTZF598wLXCMq3EYnk/tHv0uZ83wp77scXGT85lHwcOC3eemb5c23eTX3GX2y8VGdhNTbGuCSDsz/UNTdp53z/9Gjs1SB+6PuTu1Y5nLgssJEd18OPJaw3COi7jB3n1Rk3pGEE2l7HB91b3b3UWXOc1TUbXL34UXyMwu4Jhr8dt6o+MoQYItKMyrZpyAh9TbB3Uvex2Bm65vZT81shJnNNrNVeRXPr0eTfbKd638lIX1G1O3RjmWOcfcPK1zu56LucyWW+2ylGTGzdYDdo8FHKph1t6j7dIlpnoq628eV3u7+EfBMlP6Ymf3KzD5rZt0qWLdkmIKE1NucUiPNbAvCzVWXEFrA9AJWRPPNInejXKuWOeVw9yUJo5ZH3XXasdikZZZabs+oO7PEvO+3Iy+bkLv/aWoF8/WKujNKTDM96hq5/AOcCIwlFD39jhDIF5rZv8zsu2am+7EamIKE1NuaNsZfRqi8ngQcSajw3dDdN3P33sBetc5gg7MOzr9upTNExWW7AN8iVFKPBTYktHq6DRhpZht2MF+SEgUJyYzoPoXDo8HvuPu97r6gYLLN65ytWomviEqV47enjH8eoaUVwKcqmC++wis1T9+o6xQ8+sTdV7v7/e7+A3ffgZD3XxCupHYDzqsgL5IhChJSDXHFZUf/xfYk90/29YRpDuzgOrIi/n5fLDHNlypdqLuvIjR/hfBPvlyvRd19zSzpd4xvZHy3RB1MnI8P3P1P5Cr09y2YpFr7jNSYgoRUw+Kou3EVlhO3PNq5cGRUX/HjDq4jK+6LukeaWb/CkWb2eWC/di77b1F3sJntUuY8w6LujuSu5vLzsznww2jw7rz0dUoEFQhNfKF1MVa19hmpMQUJqYbRUfcIM9uovQtx96XAS9HgTWb2WQAzW8vMDiC0ouks/zz/Qbiren1guJntDWDB1whNche1c9k3Eir/1wWeNLPj8h6Lsb6Z7WFm15vZnvEM7v4sEDd9vcnMjopbKJnZ7oT7S3oQGg9cnreuHYG3o0dvbB8HjCh4HEm4axxyTYFjVdlnpPYUJKQabiM8ZuGLwNzoOUSTzaxU884kPyX8+9wZeN3MlhIey/FvYFNgSJXynKroHoqjCY/w+DTwgpktAT4knKyXEloKQWjdVcmyVwDfBN4mFOH9DVhsZvOj5Y8ktEhav2DW4wnBpQfhbvGlZrYYaCJUTC8AvuXu8wrm24FwB/c7wEdmNo9QFzEM2Cia//cF81Rzn5EaUpCQDnP3ccBXCSe3RUBvQgVo31LzJSxrJLA34Z/0AkLT0dnAtcBngTerk+v0eXjZzq7AzYTHXawTdS8B9iBXbr+wHcueRnicxqmEezGWAB8jNIt9DPg+8HLBPHMI2/5nhBP7KqA7MJ5Qt7Cju79YsKqxhBvxriFq+kp4HMfiaL0/JjxyZHH+TNXcZ6S24ufiiEjGmNltwHeB37j7+SlnR7ooXUmIZJCZbUO4TwTgiTTzIl2bgoRISszscDO7wMx2jB6nEb/P4XDCIzDWB15y9+dTzah0aSpuEkmJmZ0IXB8NNpMrz48fYzEFOMDdJ6aQPRFAQUIkNdH9EScSblL7FKEl0nJC09gHgcvdveJKa5Fq6lRBomfPnt6vX7+0syEi0lBeffXVue7eq9i4TvV0xn79+tHU1JR2NkREGoqZTUkap4prERFJpCAhIiKJFCRERCSRgoSIiCRSkBARkUQKEiIikkhBQkREEilIxGbNgvvua3s6EZEupFPdTNchBx0Eo0bB0qWwwQZp50ZEJBN0JRGbNCl0m5tLTyci0oUoSIiISCIFCRERSaQgUagTPRVXRKSjFCRERCSRgkQhs7RzICKSGQoShVTcJCLyXwoSMV1BiIi0oiAhIiKJFCRiKmYSEWlFQUJERBIpSAAsWBCe2SQiIi0oSABcckmu/8wzYcWK9PIiIpIhChKFrrkGbrwx7VyIiGSCgkQxq1alnQMRkUxQkBARkUQKEiIikkhBQkREEilIQOsb6XRjnYgIoCAhIiIlKEiIiEgiBQkREUmkICEiIokUJEREJJGCBKg1k4hIAgUJgAsuSDsHIiKZpCBRyqxZsHJl2rkQEUlNXYOEmf3UzEab2dtmdoeZrWdmW5vZSDMbb2Z3mVn3aNp1o+EJ0fh+9cwra9ZA794waFBdVysikiV1CxJm1gc4FRjg7jsB3YBjgAuBS929P7AAGBLNMgRY4O7bAZdG09WHOzQ3h/5hw+q2WhGRrKl3cdPawPpmtjbwMWAmsD8Qn4lvBQZG/YdHw0TjDzAzq2NeRUS6vLoFCXefAfwJmEoIDouAV4GF7r46mmw60Cfq7wNMi+ZdHU2/aeFyzWyomTWZWdOcOXNq+yVERLqYehY39SBcHWwNfBLYADikyKRxe9RiVw2t2qq6+3XuPsDdB/Tq1ata2RUREepb3HQg8J67z3H3VcC9wBeAjaPiJ4C+wPtR/3RgS4Bo/EbA/Lrk9B//qMtqRESyrp5BYiqwl5l9LKpbOAAYAzwNHBVNMwh4IOp/MBomGv+Ue53uemtqqstqRESyrp51EiMJFdCvAW9F674OOBM43cwmEOocboxmuRHYNEo/HTirXnkVEZFg7bYnqR53Pw84ryB5ErBHkWmXA0fXI18iIlKc7rhui57rJCJdmIJEEt2SISKiICEiIskUJEREJJGChIiIJFKQSKIKaxERBYk2qQJbRLowBQkREUmkICEiIokUJNqiugkR6cIUJJKoLkJEREFCRESSKUiIiEgiBQkREUmkIJFk6dK0cyAikjoFiSTPPpt2DkREUqcgISIiiRQkREQkkYJEkvgmOt1MJyJdmIJEEgUHEREFiTbpzmsR6cIUJEREJJGCRJJVq9LOgYhI6hQkkhxzTNo5EBFJnYJEkjVr0s6BiEjqFCRERCSRgoSIiCRSkGiL7pcQkS5MQUJERBIpSIiISCIFCRERSaQgISIiiRQkyvXee3DssbBiRdo5ERGpm7oGCTPb2MyGmdk4MxtrZnub2SZm9oSZjY+6PaJpzcyuMLMJZjbKzHarZ15bOflkuPNOeOqpVLMhIlJP9b6SuBwY7u6fAXYFxgJnAU+6e3/gyWgY4BCgf/QZClxd57wGegqsiHRhdQsSZvYJ4MvAjQDuvtLdFwKHA7dGk90KDIz6Dwf+5sFLwMZmtkW98vtfuk9CRLqwel5JbAPMAW42s9fN7AYz2wDY3N1nAkTdzaLp+wDT8uafHqW1YGZDzazJzJrmzJlT228QMln7dYiIZEQ9g8TawG7A1e7+OeBDckVLxRQr52l1hnb369x9gLsP6NWrV3VyWjQ3KnYSka6nnkFiOjDd3UdGw8MIQWNWXIwUdWfnTb9l3vx9gffrlFcREaGOQcLdPwCmmdmno6QDgDHAg8CgKG0Q8EDU/yBwfNTKaS9gUVwslSoVN4lIF7J2ndf3Y+B2M+sOTAJOIASqu81sCDAVODqa9hHgUGACsCyaNj0qbhKRLqiuQcLd3wAGFBl1QJFpHfhRzTMlIiKJdMd1pVTcJCJdiIJEuepd3HTrrTB2bH3XKSJSoN51Eo0nrSuHwYPTXb+ICLqSqJxO2iLShShIlEutm0SkC1KQaIuCg4h0YQoS5VIxk4h0QQoSIiKSqOwgYWY3mdnHi6RvYGY3VTdbGdLcDDNmqNhJRLqkSq4kBgHrF0lfHzi+OtnJqL33TjsHIiKpaPM+CTPbhPDYbgN6mNnqvNHdgK8Ds2qTvYyYNg123TX0q25CRLqQcm6mm0t4j4MTntpayIHzqpmpTFJxk4h0QeUEif0IVxFPAUcC8/PGrQSmuLve8yAi0gm1GSTc/RkAM9samBo9nbVz2XpreO+98qbthF9fRCRJJRXX/YA94gEzG2xmz5nZtWa2YdVzVk+//nXb0+QXN7nD5Mk1y46ISFZUEiQuA3oDRG+XuxYYBewNXFz9rNVR/DC9ct1wQ7j6ePHFmmRHRCQrKgkS2wJvRf1HAk+4+8nA94HDqp2xzHKHF14I/ePGpZsXEZEaqyRIOKHJK4Q3yQ2P+j8ANq1mpjJJrZtEpAuqJEi8ApxrZscBXwIejdL7EQKFiIh0MpUEiZ8AnwX+Cvyfu0+M0o8GXqh2xkREJH1lv5nO3d8Gdiky6ufAmqrlKOvUBFZEupCKX19qZtsAOxDqKMa6+6Sq5yqLCpvAioh0AWUHCTP7BHAjoWVTcy7Z7gGGuPuSGuQvO4oFBlVmi0gnV0mdxOWE4qb9CE9+XZ/QymkXwj0UIiLSyVQSJL4JnOjuz7j7qugzAhgKDKxJ7rJEVw0i0gVVEiTWB+YVSZ8PrFed7IiISJZUEiSeB35nZh+LE8xsA+A3dKUmsKq0FpEupJLWTacT7rKeYWajCK2bdgWWAQfVIG/ZotZNItIFVXKfxFtmth3wXeAzhHdM/B243d0/qlH+REQkRZU0gf0/YJq7X1OQ/kMz6+Pu51Y9d1nkrkpsEekyKqmTOA54vUj6a8Dx1clOhi1cGLqvvJJuPkRE6qiSILEZMKdI+lxg8+pkJ8Oefjp0L7ww3XyIiNRRJUFiKuHpr4W+DEwvdyFm1s3MXjezh6Phrc1spJmNN7O7zKx7lL5uNDwhGt+vgryKiEgVVBIkrgUuNbPvm9m20Wco8GfgugqWcxowNm/4QuBSd+8PLACGROlDgAXuvh1waTSdiIjUUdlBwt3/TAgUVwDvRp/Lgevd/aJylmFmfYGvAzdEwwbsDwyLJrmV3N3bh0fDROMPiKZP3/DhbU8jItIJVPQUWHc/28x+T3gKrAFj3H1pBYu4DDgD+Hg0vCmw0N1XR8PTgT5Rfx9gWrTe1Wa2KJp+biV5rolZs0I3IzFLRKRWKiluAsDdP3T3V9z95UoChJl9A5jt7q/mJxdbRRnj8pc71MyazKxpzpxi9eoiItJeFQeJDtgH+KaZTQbuJBQzXQZsbGbxFU1f4P2ofzqwJUA0fiPCc6JacPfr3H2Auw/o1atXbb+BiEgXU7cg4e5nu3tfd+8HHAM85e7fAZ4GjoomGwQ8EPU/GA0TjX/KvUGeh3H11aEoSlc2ItLg6nklkeRM4HQzm0Coc7gxSr8R2DRKPx04K6X8Ve6mm0J38uRUsyEi0lEVv760GqL3UIyI+icBexSZZjlwdF0zJiIiLWThSqLzaZBSMRGRtihI1JKayIpIg1OQEBGRRAoSIiKSSEGiK3v+edhhB1i2LO2ciEhGKUjUQqNUXJ9+OowdC2+9lXZORCSjFCRip55a+TxtVUyr4lpEGpyCRKyaJ/RGuZJolHyKSGoUJERXPCKSSEGiFhrtpKsrChFJoCAR64rFTSIibVCQiLU3SEycGOZ97LHqLbPeGiWfIlJ3ChId9cILofv3v+fSdCUhIp2EgkS1NGJgaMQ8i0hdKUh0VFxUk3/CVfFN5R55BAYNgoMPhubmtHMjIpFU3ieRSe09sRebr1H+oWcpmH3967n+Dz+Ej388vbyIyH/pSqIj8oNBscCQpZNwMY0SzEQkNQoSHTF4cGNfScSyHsxEJDUKEh21alXoNlpgyJe1vFc7P/Pnd82HGH7wAdx5Z9q5kAanIBFr77/pwYOrt6xqWrEieyf/enOHJUtgjz1gl13Szk39HXwwHHssLFyYdk6kXBMnwjXXpJ2LFhQkaiHtk/PUqbDeenDddeVNn4WgVguXXgqf+EQ48LqiadNCd/XqdPMh5fvCF+Ckk3IlFBmgIFEtWaq4Hj8+dO++O531Z8U997R/3tWr4YwzYO7c6uWn3jpr8O/M5s9POwetKEgU2mOP9s3XVkunNLSVj6zks1AW8vXww3DxxXDKKWnnpOOysD2lYSlIxAYNCt0jjmjf/IsWVS8vHVXsBr/OYvRoWLCgvGk78k96zZrQTeOy3x2uuALmzevYcnQl0bgydOwqSMR23jn8MNtt177581vPjBpVnTy1V7lBIqsnkVL52mmnUG7bmb36Kpx2Wu6PS0dl6IQjbcjgMakgUWiffdo3X5YeJVHujtaoJ49x48qbLoMHXFlWrAjdcq+YkjTKFeXo0bnvnLaVK8NH/ktBotA667RvvmJBolFOUlnLZ9ZPalI9c+eGq8Pvfz/tnAQ9ekDPnmnnIlPHgIJEtcyenXYOWsvQjpaKjgS/rr7t6mXJktB99tn6rvfll3OtAPMtWxbytHgxnH9+rm6qXrL2hw0FidY68mC5NWtgzpzc8CWXdDw/hf78Z3jvvdLTZHBHa1iNvC0bpbgpDXvuCdtvnzz+jDPgN7+BYcNqn5dZs3K/UQZ/KwWJQt27t/+HOvFE2Gyz3PDf/ladPMXmzIGf/xwOPLC86Wuxw119NXz729Vfblqam0tvpwwetGVr5ACXtg8/DN24ruSjj8L2vPLK6q7n3Xehd2+47LKW6Rn67RQkqumWWyqfxz38Wynnrti43mPp0tLTlfsPsj0nwJNPhn/+s/L5KtGefK1eHR5nUOndxd26wb77tk5P8yCtdmBq5ECXlsLfP76p8o9/rO564qcBFL7+OEO/mYJE2oYNg6OPDjduVUulxQwZ+tfSbldeGR5ncNVVubRyv1e9y8PrpRF+1wydDIuqdTFQ4W+Uwd9MQaLWzjmn9Pi4wnv69NrnpVG050CJH2fQ0WajWVDtE0XWT8RZlPRHq1Yn8Qz/RnULEma2pZk9bWZjzWy0mZ0WpW9iZk+Y2fio2yNKNzO7wswmmNkoM9utXnmtqj/8oXotJCrdkZ5/vjrrbVSFB/SIEeXPm+GDtmyNUHGdwX/OQOt81fpKonD5GfrN6nklsRr4mbv/D7AX8CMz2wE4C3jS3fsDT0bDAIcA/aPPUODqOua1uj7zmZbD774bdo7XXqvN+rJ64JWrVgfIfvtVPk+jb0vJNhU35bj7THd/LepfAowF+gCHA7dGk90KDIz6Dwf+5sFLwMZmtkW98tuqtUFHTJjQcvihh0L39tsrW07+DjRtWnjOVNwKI2m6rkzboX4mTUo7B7WRoX/0aUmlTsLM+gGfA0YCm7v7TAiBBIjbkPYBpuXNNj1KK1zWUDNrMrOmOfn3KHTUaadVb1nlqHRnPOssuO8+uP/++q2zWj76qHFa8DTySaJeQfL222HbbeHf/6583qxu36Rtl5U6CXe49da2WzpWQd2DhJltCNwD/MTdF5eatEhaqy3p7te5+wB3H9CrV69qZbNxZOk9FuWYNw8+9rFQV1NrHTkBZXkbVqrWJ+KXXw7d0aPbv4ysbu9ab7v21hu98EJ4K+aPflT1LBWqa5Aws3UIAeJ2d783Sp4VFyNF3fj5FtOBLfNm7wu8X6+8Vl2xYiHIvVqynIMk3pFmz4Z//KNlWr5yD7g0DswPPgjdv/89eZr2HJjFvsszz1S+nFhneJtdvSquq7H8rF1R1LviulLxFUR8PNVQPVs3GXAjMNbd859X8SAQPxN5EPBAXvrxUSunvYBFcbFUQ9p//1AXkV+Mdccd8Ktfhf6HH65/ntI4MBuhxQ3AmWemnYOOq/efgPasL6tXEPXW3tZNdTiO1q75GnL2AY4D3jKzN6K0c4A/Aneb2RBgKnB0NO4R4FBgArAMOKGOea2+l1+Gb34z9G+1VejOzIt5U6fC8uXh3dRJavVC+3oeqI0SJGKd4STWKNs6i+pd3JTBUoC6BQl3f47i9QwABxSZ3oHaF7ilYerU4umldsiePYu/qazR6iQKD4ott4RNNy0+TSVqfTDfcQd84xsdewBkvTVaQM6SelVcZ/lYjeiO6ywZMQLGjCk+rq1XWa5YEU5k7pXveLffDjNmtEw780z4znfC1U1HX+E5YQLccEPoL8zb9Onw5pst07JW4fz66/C//wtDh1Y+74UXwtNPVz9PWdKR3yvrASzDT2etl3oWN0lbDj00dCvZIeNpf/1ruOgi2Gijlv/Mywkal1wCjzwCY8fm0i66KHRLVZCXa889w2MzTjyxZb5q8Ta/WjStjSsJp00rPW0xZ52VW05n8vDD8D//E5q+xjoSoLP2jzrtx3JkaH/RlUSji3em+Epg/vyWO3J8InYP705O8n4bDcfyA0il4ucq5Qcsd7jppvYvs1AtTzLFHu9R6dNm01DLbXLYYdC/f3nTTpjQdnv+DJ0UgfoFrY4WCdZhuylINLr45B3vbIX/zpubQ5HOn/4EAwbA8OG5cfk7WFs72/Llld8hXsgd1lor1z9rVseWV7jsWsg/WbiH52Httx+cd15t1hevJ8vLq3S5/fvDIYcUH5e1K4h6a4DvryDR6C66CP7yl5Yn33zNzaFy+IwzwvAhh+Ten/DGG7npliyB224rva7vfrdjec2/kpg4MfkBhPnlwGedVfw1k0mam8OrJ6sp/0CO26V35MqqXsr5l9rc3LH7Scr13HO1X0ct1KtOQsVNDSpuqpom9/A2uFJOPbXlCSH/pPa977We/j//Ce+wKHT88WFcR9+od9ttyQ8vzM/bo4+WXs5774WK369/PQznF5eNHx+ubgr99rehXqZWxUG1/Oc3Y0ZoJFCtdZSznEsvha98JdRJtVclJ7TZs0O+4kd4ZOhk2EJarZsy2ARWQaKUtB5adkLeLSFrrRXeBleuwiARVzwXSnp37777wqBBxcflW7Ysedzxx8Puu7dOj+smKhW3rhowIJe2/fZhPUlK1b9MnQrXX195PjpyQlu4EF56KXm7LV0KffvCD3/Y/nUkKZXvceNCtxrvMynnxDVyZOhefnnl86YhrSuJWs9XAQWJUrp1gyeeqP962/Ma1PzipnoccK+8Ai++GB7W15Y4P5ttVl7e4mniE33STYRPPpm8jL32Sh63//6hOWu5xVLF8lzpwXnyybD33rk/AG+8Ed4VHl/xxI9teeih6h34pbZ1U1NYT6U3cbVl/nz4whdgypTS07X3O3760+X9iemoeldcF3IP9V7xVXSKFCTastNOaeegPHHrkeeea/mPu1oK/wFPmxZOBsWuGGLxTYP5J4RKnlH17W+H7sKFcO+9ydNVKn4bYH5x1y23hKK2trS3NcqiRaEbF8Mde2x4V3hc35LU8CA2blyoTyoMys3NYd4//rH8K7UHHoDPfx5uvjm3vhUrQp3TzA4++eaOO8Kfh7gJdbncw1VGfGWT5N13O14cWol6FYcVC9a//W3bxYBm4dg/77zwx60GFCTa0rt3dstN88U32918c22W/8UvthyOi7HGjg2V0PFJMN+nPtU6rb3/0I48snXaggXF6yXKdcwxuf4TTshV6D/wQC79xRdz/flXafGLo+IHAbZ1w2HSP/b4rYVx+rx5xYPVaaeFlmnxuPnzw8khXu/ZZ7e8P2bZslCnA/D44y2XFQemIUNyT3C9447Qei2+r6Ncq1eH94sXKnbMFHuUeP722GuvcO9FtTzxRFh+qRtRk+rF8vP15JPwzjut06uhGk1glywJAaVUEWsHKEiUq9QzlbLgqafqu778g2u77WDjjWHUqNb/hAsPqn792l72++/DddeVl48f/7i86WIrVrQ9zcCBuf733899h5deyn2/uHXTGWeEA7R79zDdsceWl4/4xPWLX4Rufv3XL3/ZctpFi3In+vhksummoWFFsUe8LF7csr7mpJNajhs1KjccP977hRdCN+kd4XPnFk/P/3NgVvok+tWv1u7pqqNH536b5uYQPOOrmcGDw3rmzYOdd4YHH8zNd/XVrYNooQMPrF2xT7nbw73lVWRh02zIFTlXmYJEuRql2ClNu+4a6nE6aued4Qc/KG/a4cMra/La1kMS21rvb3/bcvjee1veM3Hnnbn+/PcrxEF1+fIQeOIXZA0fHpjtmZ0AAA8tSURBVE7iSXUo77wTAnBszRq49trQv2BBqMAvtNFGcM89xZe30UalmzovWdI67ZlnoFev4i+4qnX9Sf/+uauLpDqopqZwfF58cRg+4YQQtGMPPxyuYrbbDt5+Gw4/PDfuoYfga19r/Wj4eLjad1wPGxaCTlsK32b55z+H97DMmhX2gfjp0ZALjjWqR1GQKFdWW190ddOnhxNfuWXpCxYUPxHG2rqCKXzOVDFxEVixyttp06BPwQsWr7kmeVl/+lPraUu1gCp8Bld7TZoEK1eG/qam0H322fLnnz4d3nqr449emTAh1FM0N7c+uV5/fTgu47L4uBvXWeTf5b18eek/CIV3hFfSRLe5ObxEq5ynNB99dC7YjR+fezJ0vJ74auHGG1vOd8cdoTttWvhjEbcSy59XQSJlChLZVm4TzvY8CuQLX6hs+gULwv4yZEjl68q3ejX8618t09p60GP8/K/2GjEiPHJj221h3XXDy6HKKaIDOOWU3JvSHnoIdtklPBesmPjE1tb3iRV7SVUc0JOaiL/0Uq4/PhmXUuwGybvvbnu+4cPhnHNC0efSpaGYq7k5BNkhQ0LgXrq0daX8qafmivcKg9GIEbn+wvqu/HuAatFCrZC7d5rP7rvv7jWz557xz6GPPqU/F16Yfh4KPz/9adiPO7qc++93nzkzN3zssaWnP+KIlsMPPZTrnzgx19+vX65/9Gj3Cy5wX7gwebnu7p//fMu0bt3a/x3feMPdrLxpt9vOfdGi3LkhTj/8cPcf/Sj0X355y/Ri+e/dOze8994tl7Xjjrn+nXZy32230P/KK+4PPJAbt//+7pMnh/6bbmr36Q1oci9+XtVTYMulKwlpZJdemvyvvhL5lfqQKwZJkl83UCj/CbL5dtwxdOMWRUmKtRTrSAMO9/KmmzAhFHFC69cSx/Vjjz2WSyv2qPgnn2z56tFS63777Vz/6tXJld0qbkqZgoSUK6uvPq3HTWiFCo+bww4rPt3kya3T4ia8xcyaVfyYPKDV+8vK87WvtW++uFUYhJN1/Dy0/PsbijWsKKwody+v/uZ3v2s5vHx5qA9JWk8VKEiU66qrwjNuRBpVPW9Cq4ZSNzf27l3dP27tfSLxV7+a629uDpX15ShsrjpyZMurifyWcfnGjWv5qJ0XXsjVzSS98bKDFCTK9dnPdv43jIlUW1vFUR2RXzGdBQ8/XP603/9+67TC51kV496ymXU+FTeJiHRiP/tZ2jkoSkFCRKQzKLfivUIKEiIijaJUZX6NKEiIiEgiBYmOqNEDtUREKqaK64z5wx9CiycRkSxQnUTGVPrcfRGRBqQg0REbbJB2DkREakpBoiOSbmoREak31Ulk0Cc/CffdB5tsknZORKSrU51ERg0c2PLZ7yIiaejI+95LUJCoBl1JiEja8l9GVEUKEpUq9upIPUZcRNKmOomMuPrq1mV/m26aTl5ERGJdsU7CzA42s3fMbIKZZffGhHXXbfkD3XsvfOc7ueFttgndLbes7nqPO651WrGXt4hI5/fJT9ZksZkNEmbWDbgSOATYATjWzHZIN1dtuPVWePxx+Na34Pe/D2lf+hI0NcHNN8OYMXD//SH9scfCS9Y33hjWWy+3jIsvTl7+3Lnw+uvw3HMwe3ZYn3vLIrB11sn1z58P48fDX/7ScjlxIGlqCssrdNppLYdXrIBly8KrIZubc2/qjV/h+Nxz8Oyz4UXwsXfegWeegQMPDMPxi1KOOip850cfDS+3P//8kH7JJeH1k+6tXxifL15erGdPuP320H/yyaF7zjlhOY8+Gn6PCy4I3/Wyy1rOu/fesGhR6N9vv9aPat5339Bt641fc+e2TuvRo3Xac8+F112WenNdUrPqXXaBAQNCf//+YT8ZOBD23LPldN/8Zum8lmPYsORxCxaUnnfPPWGvvYqP+9SnWg5vvjl897uV5Q3goIMqnwfgoYfaN18pX/5y9ZdZrlNOaTn8q1/VZj1JL79O+wPsDTyWN3w2cHapeXbfffd2vwg8dUcemXtB+hFHuO+6q/s557j/4hfud90VXj6fZPnyli9Yv/JK9xEjWk6zZIn7ggXuM2a0nn/KFPd//9v9qqvCC9xjH37o3tycvN7p092feab095o3z/2ee0L/xImll5fv7393P/fcMO8//+l+3325cSNHuj//vPuYMe5z5rScb+XK5HUsXer+mc+E7blwYevxzc3uP/iB+wknhG05ZUpu3MCBIe2HP3Q/4ICQdsIJ7ltvHfoPPDCMP/fc0D3tNPf33nOfMMH93Xdbr2vMGPdly9y32y5MP2ZMyJ+7+5o17j//eUifPNn95pvdZ81K3lYbbpj77WMLFoS0K64IvxO49+2bG79wofvixbnhxx8Pv3dszRr3T386zDdwoPtRR4V9yN29d++W3/WDD3L736pVYZqf/CRsy0KPPOI+aVLLtFWr3Dfd1P2223Jpu+8elhf/vuC+777uK1aE4XHj3C+80P2NN9xfey38dvvum8vHCy+EY+avfw2/d76lS8M+dNxx7j/7WZj3zjtzy46NHx/yNGZMWEb8W82Y4T5qVG66Dz4Ix+uiRbn1g/tJJ4X9/x//cH/0UfeNNsqN697d/d57w+/8yithupUr3bfYIozv0yd0hw4N2+u999xvuMH9jjvCfhnvv//5T8tjv52AJk84r5rXqByro8zsKOBgdz8xGj4O2NPdTymYbigwFGCrrbbafcqUKXXPaybMnAlrrw29eqWdk8bnDgsXtrwaWLEiXJltsUXxeVavDp/11gv/xA87LBRDtmXx4rCurbZqf36nTAmvuzz00ORprroKDjkEtt66/OUuXx6+d3zFGJs5E959N3elBeE1mnPnVudKppgPP4Tu3VteKRdyh3/9Cw4+OBwL1TZxItx1F5x9dnIl8Zo14cGfb74JO+wQ8hybOzdcifXpE6bJL0EoZsYM2Gyz0t8ZwlX80qXh920nM3vV3QcUHZfhIHE08LWCILGHu/84aZ4BAwZ4U1NTvbIoItIplAoSma2TAKYD+TW9fYH3U8qLiEiXlOUg8QrQ38y2NrPuwDHAgynnSUSkS6lBwV11uPtqMzsFeAzoBtzk7qNTzpaISJeS2SAB4O6PAI+knQ8Rka4qy8VNIiKSMgUJERFJpCAhIiKJFCRERCRRZm+maw8zmwO095brnkCRh/BIHm2j0rR92qZtVFpa2+dT7l70cQ2dKkh0hJk1Jd1xKIG2UWnaPm3TNioti9tHxU0iIpJIQUJERBIpSORcl3YGGoC2UWnaPm3TNiotc9tHdRIiIpJIVxIiIpJIQUJERBIpSABmdrCZvWNmE8zsrLTzU2tmNtnM3jKzN8ysKUrbxMyeMLPxUbdHlG5mdkW0bUaZ2W55yxkUTT/ezAblpe8eLX9CNG/Ca7yyw8xuMrPZZvZ2XlrNt0nSOrImYfucb2Yzov3oDTM7NG/c2dF3fcfMvpaXXvRYi14JMDLaDndFrwfAzNaNhidE4/vV5xtXxsy2NLOnzWysmY02s9Oi9Mbfh5Lea9pVPoTHkE8EtgG6A28CO6Sdrxp/58lAz4K0i4Czov6zgAuj/kOBRwED9gJGRumbAJOibo+ov0c07mXCO8otmveQtL9zGdvky8BuwNv13CZJ68jaJ2H7nA/8vMi0O0TH0brA1tHx1a3UsQbcDRwT9V8DnBT1nwxcE/UfA9yV9rZI2D5bALtF/R8H3o22Q8PvQ6lv3LQ/0UZ/LG/4bODstPNV4+88mdZB4h1gi6h/C+CdqP9a4NjC6YBjgWvz0q+N0rYAxuWlt5guyx+gX8FJsObbJGkdWfwU2T7nUzxItDiGCO+E2TvpWItOenOBtaP0/04Xzxv1rx1NZ2lvizK21QPAVzvDPqTiJugDTMsbnh6ldWYOPG5mr5rZ0Chtc3efCRB1N4vSk7ZPqfTpRdIbUT22SdI6GsUpUXHJTXnFHJVun02Bhe6+uiC9xbKi8Yui6TMrKhL7HDCSTrAPKUiEfzGFOnu74H3cfTfgEOBHZvblEtMmbZ9K0zsTbZPgamBb4LPATODPUXo1t09DbTsz2xC4B/iJuy8uNWmRtEzuQwoSISJvmTfcF3g/pbzUhbu/H3VnA/cBewCzzGwLgKg7O5o8afuUSu9bJL0R1WObJK0j89x9lruvcfdm4HrCfgSVb5+5wMZmtnZBeotlReM3AuZX/9t0nJmtQwgQt7v7vVFyw+9DChLwCtA/al3RnVA59mDKeaoZM9vAzD4e9wMHAW8TvnPckmIQoUyVKP34qDXGXsCi6JL2MeAgM+sRFTMcRChHngksMbO9otYXx+ctq9HUY5skrSPz4hNT5FuE/QjCdzomapm0NdCfUOla9FjzUJj+NHBUNH/hto63z1HAU9H0mRL9rjcCY939krxRjb8PpV3Bk4UPoaXBu4SWF79MOz81/q7bEFqVvAmMjr8voZz3SWB81N0kSjfgymjbvAUMyFvW94AJ0eeEvPQBhBPGROCvNEZF4x2EIpNVhH9tQ+qxTZLWkbVPwva5Lfr+owgnqi3ypv9l9F3fIa91W9KxFu2XL0fb7Z/AulH6etHwhGj8Nmlvi4Tt80VC8c8o4I3oc2hn2If0WA4REUmk4iYREUmkICEiIokUJEREJJGChIiIJFKQEBGRRAoSIh1gZreY2cNp50OkVtQEVqQDzGwjwnG00MxGEB6Ad0rK2RKpmrXbnkREkrj7omov08y6u/vKai9XpD10JSHSAWZ2C9CT8PyhQQWjt3b3yWa2A3Ax4Z0MHxHuiv2pu39QsIxngR8D3d290Z4GK52U6iREquM04EXgZsIz/bcApkXPN/oP4XEKewAHAhsCD5pZ/vG3L7ALcDBwQB3zLVKSiptEqsDdF5nZSmBZfIUAYGYnAW+6+5l5accTnmQ6gPA8IoDlwPfcfUUdsy3SJgUJkdraHfiymS0tMm5bckHibQUIySIFCZHaWgv4F/DzIuNm5fV/WJ/siFRGQUKkelYC3QrSXgO+DUxx91X1z5JIx6jiWqR6JgN7mFk/M+sZVUxfSXib2l1mtqeZbWNmB5rZdfHLn0SyTEFCpHr+RLiaGAPMAbby8KrYfYBmYDjhRU9XAiuij0im6T4JERFJpCsJERFJpCAhIiKJFCRERCSRgoSIiCRSkBARkUQKEiIikkhBQkREEilIiIhIov8P04Q/+p84/QEAAAAASUVORK5CYII=\n",
+      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
@@ -507,7 +494,7 @@
   "source": [
    "matplotlib.use('TkAgg')\n",
    "%matplotlib inline\n",
-    "draw_train_process(iters,train_costs)"
+    "draw_train_process(train_nums, train_costs)"
   ]
  },
  {
@@ -524,7 +511,7 @@
    "id": "YC73FnkakWbY"
   },
   "source": [
-    "# 模型预测\n"
+    "### 模型预测\n"
   ]
  },
  {
@@ -536,17 +523,17 @@
     "name": "stdout",
     "output_type": "stream",
     "text": [
-      "No.0: infer result is 11.88,ground truth is 8.50\n",
-      "No.10: infer result is 5.40,ground truth is 7.00\n",
-      "No.20: infer result is 14.77,ground truth is 11.70\n",
-      "No.30: infer result is 16.40,ground truth is 11.70\n",
-      "No.40: infer result is 13.51,ground truth is 10.80\n",
-      "No.50: infer result is 15.88,ground truth is 14.90\n",
-      "No.60: infer result is 18.62,ground truth is 21.40\n",
-      "No.70: infer result is 15.36,ground truth is 13.80\n",
-      "No.80: infer result is 18.03,ground truth is 20.60\n",
-      "No.90: infer result is 21.45,ground truth is 24.50\n",
-      "平均误差为: 12.579632779346012\n"
+      "No.0: infer result is 12.15,ground truth is 8.50\n",
+      "No.10: infer result is 5.21,ground truth is 7.00\n",
+      "No.20: infer result is 14.32,ground truth is 11.70\n",
+      "No.30: infer result is 16.11,ground truth is 11.70\n",
+      "No.40: infer result is 13.42,ground truth is 10.80\n",
+      "No.50: infer result is 15.50,ground truth is 14.90\n",
+      "No.60: infer result is 18.81,ground truth is 21.40\n",
+      "No.70: infer result is 15.42,ground truth is 13.80\n",
+      "No.80: infer result is 18.16,ground truth is 20.60\n",
+      "No.90: infer result is 21.48,ground truth is 24.50\n",
+      "Mean loss is: [12.195988]\n"
     ]
    }
   ],
@@ -556,18 +543,21 @@
    "\n",
    "infer_features_np = np.array([data[:13] for data in test_data]).astype(\"float32\")\n",
    "infer_labels_np = np.array([data[-1] for data in test_data]).astype(\"float32\")\n",
+    "\n",
    "infer_features = paddle.to_tensor(infer_features_np)\n",
-    "fetch_list = model(infer_features).numpy()\n",
+    "infer_labels = paddle.to_tensor(infer_labels_np)\n",
+    "fetch_list = model(infer_features)\n",
    "\n",
    "sum_cost = 0\n",
    "for i in range(INFER_BATCH_SIZE):\n",
    "    infer_result = fetch_list[i][0]\n",
-    "    ground_truth = infer_labels_np[i]\n",
+    "    ground_truth = infer_labels[i]\n",
    "    if i % 10 == 0:\n",
-    "        print(\"No.%d: infer result is %.2f,ground truth is %.2f\" % (i, infer_result,ground_truth))\n",
-    "    cost = np.power(infer_result-ground_truth,2)\n",
+    "        print(\"No.%d: infer result is %.2f,ground truth is %.2f\" % (i, infer_result, ground_truth))\n",
+    "    cost = paddle.pow(infer_result - ground_truth, 2)\n",
    "    sum_cost += cost\n",
-    "print(\"平均误差为:\",sum_cost / INFER_BATCH_SIZE)"
+    "mean_loss = sum_cost / INFER_BATCH_SIZE\n",
+    "print(\"Mean loss is:\", mean_loss.numpy())"
   ]
  },
  {
@@ -578,7 +568,7 @@
   "source": [
    "def plot_pred_ground(pred, ground):\n",
    "    plt.figure()   \n",
-    "    plt.title(\"Predication v.s. Ground\", fontsize=24)\n",
+    "    plt.title(\"Predication v.s. Ground truth\", fontsize=24)\n",
    "    plt.xlabel(\"ground truth price(unit:$1000)\", fontsize=14)\n",
    "    plt.ylabel(\"predict price\", fontsize=14)\n",
    "    plt.scatter(ground, pred, alpha=0.5)  #  scatter:散点图,alpha:\"透明度\"\n",
@@ -593,7 +583,7 @@
   "outputs": [
    {
     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEjCAYAAAA/ugbCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO29eZhcZZX4/zm9d7qT7iydhZCFJAKBKIthE9GwI+PAgKKjgKAizoyibKOIjMLMqDOIxK/gT4zKDgoqCAqyE5BhTRBCIBAgC5B0Op2E7qST3vv8/njv7b5VXVV9q7r2Op/nqaeq3vve9557b9U973nfc84rqophGIZRupTlWgDDMAwjt5giMAzDKHFMERiGYZQ4pggMwzBKHFMEhmEYJY4pAsMwjBLHFEGJICLrRERFZFFU+dle+dLcSJYcIrLIk3ddrmUxjGQRkQrv96sisnuu5fExRRASEbkxcAODr+0i8pKI/Difbmwh4imly0Vk/1zLYiRGRA4UkZ+IyHIR2SwivSLSLiKvicitIvI5EanLtZxGOCpyLUAB0gts8z4L0ATs573OEZF/VNWnciVcCrQDbwDv5FoQ4Gzg48A64KU4dXbh5N2QHZGMICIyDvgV8JlAsQJtQC0w33udDmwVkQtV9easC2okhVkEyfO0qk71XlOAeuALuD9CI/B7EanNqYRJoKp3q+reqvqFXMsSBlV93pP36FzLUmqISCPwNE4J9AK/BA4DqlR1gqrWApOB04D7gAnASTkS10gCUwSjRFV3qeotwDe8oqnAP+VQJMPIFDcA+wI7geNV9V9U9VlV7fMrqGqrqv5BVT8JHAyszJGsRhKYIkgfdwID3ucP+4XRk7EicrqIPCEiW73yCKUhIvUicqmIvOCNuXaJyJsi8jMRmZFIAK/tZ0WkQ0S2ichjIvIPI+wz4mSxiMwXketEZLWI7BSRNhF5xZPpw1F1q0TkH0TkVyLysohs8c5hvYjcFl0/KANuWAjghqh5mHWBuiNOFovIkSJyl4hsEpEe7/1uETkqwT7+sWaLyExP/vdEpFtE1orIVd6wSGhE5DKvzWUj1PucV2+ziIQerhWRuSLyS+/30endm3Ui8riIXCIiE5ORd4RjHcZQB+diVX18pH1UdZmqXh6jrae88z1DRMZ782tveOewJUb9T4vIg95vqVtE3vXmIWLOJYnIMV77byU4n3O8Oo9ElUdM5nq/h9+IyAbv2Gs8eccmaLtcRL7h/f47RaRVRO4VkUMSXrBcoqr2CvECbsSNhS5NUKfFq7MkUHa2vx/wM+9zP26eoR/4p0Dd+bjxcfVevUBH4Ps24PA4x742UK8feB+nmBRnrfjtLorab1C+OO2eB/QF2u7AjdNrrP2ATwa2Ka732Bl1TmdG7fNZYBPQ49Vp9777rxcCdRd5ddbFkfe/A8caiLoOCvwozn7+9pOBrd7n7Z68/rYXgMokfjNzAvvumaDevV6da5No+yBgR6D9HtzwZPDaH5OB3/+mZK5BnLae8tq6CFjrfe70rveWQL1y4NbA+fR59zP4O/9KjPaP8ba/lUCGc7w6j0SVVwTaPwn3n/N/k8HfwrNARYx2K4E/R/3e/fvSA3wqsG33dN2fUd/fXAtQKC9GUAS4iTL/gXNloPxsr2yHt/17QKO3bRww2fvcEPhT3A0c4P/QgNnAzYE/YmPUsU8P/Lh+HGh/CnCT9wPcSZKKADfW67f7e2C+Vy7ANO+4P4naZxFwPXAUMDFQPhNYHPjTz4xxvKXe9rMT3IdFxFEEwD8H5L0GmOSVT2RICStwRox9/W3vA48CC7zyauBLQJe3/d+S/N086+33/TjbxwPdXp2PJNHuk94+/wfsHyivwymJnwIHp/H3v8473s1paMtXBDu8do8Dyrxt8wL1LmNIoX8HqPfKdwf+yJAyODyq/XQpgveBh4F9vW013n7+/To3RrvfZ0hpXQDUeuVzgYeIVNamCArtxciK4OuBG/ypQPnZgfIfJmjf78n+CZA4de7z6lwcKBPgTa/8xhj7iPdj9mVYFLXdl29pVHkl8K637fY0XsffxHswMgpFEHUdfhtn39v9ff0HT2Cbf31WAtUx9r3G2/5Ykuf7DW+/1+Ns9x9Ia+Pd9zj7+Q+jD2fht18TuD4Xp6E9XxF043UuYtQZy5DF818xtpfjJq6H3RPSpwhexk2ER+/7C2/7QwlkvizOdXw90H7eKAKbIxgF4pgtIhcDV3rF63GmYTT9wNUJmjvLe1+s3q8mBr/13o8NlO0PzPM+/yh6B6+tHyY4bjyOxvW8+oF/T2H/ePjX5vA0tgmR1+G/49S5wnufhZvIjMXVqtodo/xP3vuCJOW6A3cN9xKRA2Ns/5z3/tsE9z0W2733aUnKkwrBuYb3Y1UQkTHeXEysVzwZ/6Kqq+JsOwHnkdcNXBW9UVX7GbrPR4rIpHCnkhQ/UdWeGOXxfgu+zJ3A/4veSVW7gJ+kVcI0YXEEyfNxb2IzFs24Mf9YP563VHXYRBiAuElgPxjt9yIyEKseUOW9ByeN/YfLZlV9I85+T+NM1WTu96He+8uqmpTPvohMAL4GfALYCzfsVR5Vbbdk2gyBfx1aVfXVWBVU9Q0R2QBM9+o/G6PaC3Ha96/B+GSEUtUWEXkMp7w/D7zob/MekIu8r7cn0y7wV+BM4DYR+TlwD/CiqvYm2U66KMMNRcYi+t77PJOgPf9+vqiq7XHqLMUNG5V59R8aQcZkSfa3EJR5R5x9nxi1VBnAFEHyBAPKFDf2vgY3/PJrVY3ZYwJaE7QZ7DE1hZBhTIz6cR/WqtrteWNMDdG2j/+nTirQTET2AR4j8qGwg6EJ4yrcHyjdUacjXgeP93CKIN51jvcH7vLeU/nP3I5TBJ8VkX8P9Pw/i3uIvaKqybpZXgTsCRyCGz//DtAlIk/jPNhu8nqg6WBr4HNMRaiqHbjhOQBEZG8gXm/fJ9F/IszvepeIvI+zWML8b5JlpN9CZVS5L8PGBG3mZSCkDQ0lTzCgbJqqzlPV41T1xwmUALjhgXgE70ODqsoIr9kpyC0jVxlVfZ8bcErgRZypPFZVx6nqFFWdipuAHk37I1GdoXZHw124h8fuwMcC5f6wULLWAKraigvmOh43f/ESTskeBVwHvCIiabG6PIWy3vv6oXS06ZHoP+GTj/dzNGTqdz8qTBHkBy2Bz/skua/fq4r7pxeRKiLHecOwyXufFXYHEZmJG3vvB05S1Qe9nmKQeMMHo8W/DjNHqOcPwSXqjaYVVd2Om+gH7+EvInNw10oZmvtJtl1V1YdU9RuqegCuR/ovOM+UeaR3PHqp936ciET3hDOBf3/i/v5EZAxDFkrwfvoBbjUJ2m9IXbS4jPhfJDtzOkljiiAPUNW1DCmDU5Pc3R9zniIie8ap8xGSH9Lwx88/JCLTQ+4z+JBNMK9wTIL9/bmRVHpN/nWoE5GYE8He9ZkeVT9b+L3+T3sPUt8aeFpV18fZJylUdZuq/hLndglDAXrp4Jfe+xTgy2lsNx7+/dlbROINaS5i6BkWvJ9t3vtUEYk3P3HQ6MSLiS/DgSJSH6dOOu9J2jBFkD/c6L3/m4jMj1fJ81QK9mZeAvwIym/Hqg9ckoI8j+LGM8txsQlh8Cf1pojI5BiyfBA3YRoP3xOmMayQAYLX4dI4dS733tcBz6dwjNFwH+76TMT5zac8LCQiZQkecODmYyCNwyqq+gxD3jJXiciR6Wo7Dg/gghergIujN3rn7yu8x6McMV7HzeWV4wIco/fdi8ykgfkrTuZaXCBm9HGrgQszcNzRk2v/1UJ5ESKyOM5+Z4fZD/fwe9uruxnnTlof2D4D+Aqu13F21L7BgLL/JTKg7AZSDyj7bKDdO4G9A9umefL8LFBWxlDsweN4wUG4SbVTccNNW4gfEPYDb9vfcHMlsa7TogT7B+W9Bi+gjeEBZafH2NffNjvOcWf7dUbxG7rea2M5Q1GnTQnq+7ElfVHlk3BxB9/BuTD6wVhluEnpDcSI/2DIv16Bj6YgfyMuzkK939R1OO+yikCdety8xf2BY+0e1Y4fRzAssC+q3ncZChq7hJABZV4df/t6nEVchlMMJ3hlfsRwojiCmH7+uGG3YffF2/Z9fxvwTYYCyubglJsFlBXyiwwrAq/uPOC1wA+lH+exEUzpoMBZMfYNppjo837o6UgxcaEnh9/2DhKnmDglqv52hoKf1gNnEP9Bvnegbi/ugbYOeCpQZ1G8/b3twRQTwVQeftlIKSZmx9k+268zit9Q8EGswP0j1E+kCILt9OAUbDAVyJvAbgmOn7Qi8NoYh+sUBI/vX+c2ItN5bMG5EUcH74VVBOXAbYH2fI+94HGHRfcG/ktbA3WDqU6WA+eTGUUQnWKih6G0GHmbYsKGhvIIVX0Ll1ri33A96m24P14fsALXy/04cEuMfb+Oe8g+h3uYCs5n+ZOq+rNRyHS1J9MNuIdyJc4DZgUuaOaCqPp34zxXHsYpjUqcArjKa+e9BMd6HdejfQA3jDIVN1kYesEfVb0MFwx3D+5BVI97INyLy73znbBtZYDHcLEmPkkPC3m8D/wj7vq/gDvPBtzD7nnc0NgBqprIjTElVHW7qn4Gl1hxMc5C3YaLqgVYjXt4n4570P1cVePFxYx0rH5VPR2X9voRXKeiHueeeTuwUFWXxNn3LZy18jvc9SnHWav/BXwUN4STdtTFcfwTTtG8glNW/TjlcATud5l3iKfFDMMwjBLFLALDMIwSxxSBYRhGiWOKwDAMo8QxRWAYhlHiFGTSuUmTJuns2bNzLYZhGEZBsXz58i2qOixBX0EqgtmzZ7NsWcJlYA3DMIwoRCRmOhMbGjIMwyhxTBEYhmGUOKYIDMMwSpysKQIRqRGR50XkZRF5VUSu8Mr3EJHnRORNEbnDy51vGIZhZIlsWgTdwFGquh9uofETRORQXLbMxar6AVwOlWzkOjcMwzA8sqYI1OEneqr0XopLUPYHr/wmMpMn3DAMw4hDVucIRKRcRF7C5dt/GJd/v01V/aXl/IXFDcMwjCyRVUXgpZXdH5dW+GAg1kpcMdOhisi5IrJMRJa1tmZtuVnDMIz84Omn4dprIQMZo3PiNaSqbbjFsA8FGkXED2zbHZdrPNY+S1R1oaoubGoaFhhnGIZRnPT3w377weGHw3nnQUf6l1LIptdQk4g0ep9rcaslrcItwPJpr9pZ5OnCDYZhGFnn/vuhogJWrHDfH3kExo5NvE8KZDPFxDTgJm/R6TLgTlX9i4i8BvxORP4b+DvwmyzKZBiGkX90d8OMGeAPgx9+ODz5JJRlpu+eNUWgqitwSxVGl6/BzRcYhmEYt90GZ5wx9P2FF2DhwowesiCTzhmGYRQd27dDQ8PQ99NOgzvuAJGMH9pSTBiGYeSan/40Ugm88QbceWdWlACYRWAYhpE7Nm+GKVOGvp93HvzsZ1kXwywCwzCMXHDppZFK4L33cqIEwBSBYRhGdlm3zg35/OhH7vt//ZcLEpueu6QKNjRkGIaRLb70JbjhhqHvW7fChAm5k8fDLALDMIxMs3KlswJ8JXDddc4KyAMlAGYRGIZhZA5VOPFEeOAB972mxlkBY8bkVq4ozCIwDMPIBE8/7SKBfSXwhz9AZ2feKQEwi8AwDCO99PfDgQcO5QeaMwdefx0qK3MrVwLMIjAMw0gXl14amSTu0Ufh7bfzWgmAWQSGYRijJzo9RIaTxKWbwpDSMAwjXzn++Egl8MtfwlNPFYwSALMIDMMwUmPNGpg7N7JsYCBr+YHSSeGoLMMwjHxBJFIJ/PnPzlW0AJUAmEVgGIYRnqVL4cgjI8sysIZwtjGLwDAMIwwikUrgT38qCiUApggMwzASc9NNw4d8VOHkk3MjTwawoSHDMIx4RCuALCwbmQvMIjAMw4jmsstiWwFFqATALALDMIwhBgagvDyybP16mDkzN/JkCbMIDMMwAE49NVIJ1NQ4K6DIlQCYRWAYRqkTKyNoezuMG5cbeXKAWQSGYZQuc+dGKoHDD3dWQAkpATCLwDCMUqS1FSZPjizr7XWZQ0sQswgMwygtRCKVwL/8i7MCSlQJgFkEhmGUCq+/DvPnR5YVaJK4dGMWgWEYxY9IpBL46U8LOklcujGLwDCM4uXxx+GooyLLiiQ/UDoxi8AwjOJEJFIJ3HOPKYE4mCIwDKO4uPHG2OkhTjopJ+IUAllTBCIyQ0QeF5FVIvKqiHzTK79cRDaIyEve68RsyWQYRpEhAl/84tD3ZcvMCghBNi2CPuAiVZ0PHAp8TUT28bYtVtX9vdf9WZTJMIxiIF6SuA9/ODfyFBhZmyxW1Wag2fu8Q0RWAdOzdXzDMIqQEk0Sl25y4jUkIrOBA4DngMOBr4vIF4BlOKvh/VzIZRhGbljV3M4DK1vY0NbJ9MZaTlgwhfnTGhLvNHUqtLQMfa+thV27MitokZL1yWIRqQf+CJyvqtuBXwBzgf1xFsNP4ux3rogsE5Flra2tWZPXMIzMsqq5nSVPrqW9s5dpDTW0d/ay5Mm1rGpuj73Dzp1uGCioBNrbTQmMgqwqAhGpxCmB21T1LgBVbVHVflUdAH4FHBxrX1VdoqoLVXVhU1NT9oQ2DCOjPLCyhYbaShpqKykTGfz8wMqW4ZVFoL4+sqwEk8Slm2x6DQnwG2CVql4dKJ8WqHYKsDJbMhmGkXs2tHUytiZylHpsTQUb2jqHCt5+e/hkcE+PeQSliWzOERwOnAm8IiIveWWXAp8Tkf0BBdYBX82iTIZh5JjpjbW0d/bSUFs5WLajq4/pjbXuS7QCOOQQePbZLEpY/GTTa+gpIFZiD3MXNYwS5oQFU1jy5FrAWQI7uvpo7+zli11vg+wVWdmSxGUEyzVkGEYoUvLsCcH8aQ2c+7E9Itq+/OQFkZWOOw4efHDUxzJiY4rAMIwR8T17GmorIzx7zv3YHmlTBvOnNcC118JnzovcaPMAGcdyDRmGMSJJefakigicF1AC3/ueKYEsYRaBYRgjsqGtk2kNNRFlwzx7UuXII2Hp0sgyUwBZxSwCwzBGZHpjLTu6+iLKIjx7UkUkUgn8+temBHKAWQSGYYxIPM+ezx60e2oNxvL8MQWQM8wiMAxjRHzPnobaSprbu2iorUxtori/f7gSePppUwI5xiwCwzBCMejZkypmBeQtZhEYhpFZtm0brgQ2bDAlkEeYRWAYRuYwK6AgMEVgGEbKxI02XrkSPvjByMqdnVBTE7shI6eYIjAMIyXiRRsv/ucDhlfOkBWQqbQXpYbNERiGkRLR0cYHLl86XAkMDGRUCSS1oI0Rl9AWgYh8AvgaMAc4XlXfFZFzgLWq+mimBDQMIz8JRhtfcFxUltAPfABWr87o8YOKCBh8f2Bli1kFSRLKIhCR04E7gTeBPQA/cXg58K3MiGYYRj4zvbGWj1/9H8OUwOKH3si4EoCQC9oYoQhrEXwL+Iqq/s6zAnyeBf4z/WIZhYCNz5Y20Qpg2fGncdsXL+XcBVOycvwRF7QxQhNWEXwAeCZGeQdgi4WWIJlOS2ykl7Qq7dmzYf36iKKL73yJ6Y21nJvFzkDa016UMGEnizcCe8Yo/xjwdvrEMQqFrKQlNtJCWidVRSKVwFVXgSpXnbYfFxy7Z1Y7AWlLe2GEtgiWAD8LDAvNEJEjgCuByzMhmJHfZDQtsZFWRppUDWUtZCgwbLSWyqjTXhhASItAVa8E7gIeBuqAx4HrgOtU9eeZE8/IVzKWlthIO4kmVUe0Fvr6hiuBxx5LmxIw98/8ILT7qKp+V0R+AOyDUyCvqWpHxiQz8hobny0cEk2qJrQWdmsc1taqjW1p64GHdf80p4TME9Z9dKqI7K6qu1R1mao+r6odIrK7iGTHRcDIK2x8tnA4YcEU2jt7ae/sZUB18PMJC6bEtBYmd20f5hG05JbHufyelWntsYdx/zSrITuEtQhuwcUR/Cqq/Hjgs8Bx6RTKKAxsfLYw8JV2sFf92YN2Z/60hmHWwrDAMLy4AMC/0+kK2Arj/mlBY9khrCI4CPh6jPK/AT9OnziGkb8U8hBFPKXtD/HNWPUiX77kCxHbLrn1OZqaGiKGDdLpEBBmeNGcErJDWEVQAVTHKK+JU24YRUWxxk3Mn9YQN0nclIdXZzRgK5Gl4mNBY45Md0LCxhE8B/xrjPKvAS+kTRrDyFOKMm7i298e7hEUSBKXaG4hXcyf1sAFx+4ZNw4hGzLkO9mYJwlrEXwXeExE9gP8BHNHAQcAx6RNGsPIU4puiCJEXECYHnumyQcZck025klCKQJVfVZEDgP+HTgVEOBF4N9U9eW0SGIYeUw6hyhyOtfQ0ADbt0eWJYgJyAeHgHyQIZdkoxMSej0CVX1ZVc9Q1X1VdR/vsykBoyRI1xBFTt0hRSKVQEWFLRtZAGQjeDOuIhCRCcHPiV5pk8Yw8pR0xU3kZK5BZPhQkCr09mbumEbayMY8SaKhoVYRmaaqm4EtQKyug3jl5WmTyDDylHQMUWR9riFaAZx4Itx3X2aOZWSEbMyTJFIERwHbvM9HjvZAIjIDuBmYCgwAS1T1/3kWxR3AbGAd8BlVfX+0xzOMfCRr7pAZShJn5IZMz5PEVQSq+gSAiFQA+wJ/UtWNozhWH3CRqr4oImOB5SLyMHA28Kiq/o+IXAJcAnx7FMcxjJwx0kRwxnM0dXdDTaTFseHaJUz/2lfS075RlIiG6CWIyE5gH1VdP2LlsAcWuQe41nstUtVmEZkGLFXV4XHuARYuXKjLli1LlyiGkRaCQWfBh3z0XELGvIZiWAGX37MypgzZoJAjsYsVEVmuqgujy8PGETwLfBhIiyIQkdm4GITngCmq2gzgKYPJcfY5FzgXYObMmekQwzDSSlh/77Sb+W++CXtGrht106/vZ9vMuaHyA2XigV2skdjFSlj30V8BV4nI+SJyhIgcGHwlc0ARqQf+CJyvqttHqu+jqktUdaGqLmxqakrmkIaRFXKymLrIMCXwkwdfZ9vMuaFkyJQ7q68Ue/r6eW7tNp5fu401rR3c8kzaBhWMNBJWEdyOm8y9GngCWBZ4hU4xISKVOCVwm6re5RW3eENCeO+bw7ZnGPlEtL/3lo4unlzdyqsb21n88Or0xgrcccfwoaDt21n80BtJ+Zxnyp11Q1snXb19vPhOG929/dRXl4MqT7211VJI5yFhFcEeCV5zwjQgIgL8BlilqlcHNt0LnOV9Pgu4J6RMhpFXBP29N+/o5Jm3t9HR1cd+uzekN3BMBP75nyPLVGHs2KR9zjNlxUxvrGVV8w6qK8qoqSxHvFiG8WMKPD9TkRJ2qcr1iV4hj3U4cCZwlIi85L1OBP4HOFZE3gSO9b4bRsERDDp7+d3tjK2p4JA5E5gyrjY9Pe1zz02YJC5ahjCBb5mKWj1hwRTe39WLqqKqdPX20903wD67jS3c/ExFTOilKr25gPNxS1UCrAIWq+qLYfZX1adwAWixODqsHIaRz/gTwX7gWFngwT2qnnYScQHJTEZnyp11/rQGjpg3kZUbt7Oju49xNZUsmD6OyvJyJo+tHLkBI6uEUgQicjouGOwx4H6v+FDgeRE5W1VvzZB8hlGQpC1wbNw42LEjomjVxjbn5fP7l0N7+cTzDBopanU0HkVnHDaLJU+uZWBggOb2Lp5ds43K8jLOO2ruyDsbWSVsHME6XCTwD6PKvwN8VVVnZ0S6OFgcgZHvhI0pSEgMK2DVxrak2001vmHPKXU8sqp1VOdw34oNXPPo2/QNKBPqKpk6roby8jJzI80Ro40jaMKtWRzN74H/GI1ghlGMjCo/TIJhoAceXp10bvow8Q2rmtu56sHVbOnopruvnzdbdnDvS718aPeGUeXBX92yk0PnToywjNo7e23N4TwjrCJ4HFgEvBVVvgjnTmoYBU0mgqpSChyLVgLnnw+LFw9+TSVpXZh9bn1mPWu37GRsTQXjairp7hugtaOHtzd3MHtSfehjpXJsI/eEVQR/BX4kIgtxUcbg5ghOBS4XkVP9ioH4AMMoCPIiCjbkZHB1ufDk6lZ6+gcYV1PJvMl1VJaXJ5x7CDNf8fd326mvLqem0iUSrqksZ0xVGRvauyLaSnaew9YcLgzCKoJrvPfBNA8Brg18tpTURsGRiaUAQ1sYPT1QXR1ZdtddcMopMdvc2N5FR1cf9dXldPb08czb29hjUh2fPX7PYfV9wngGKYpEOfU11FTQ0tFDe2dvyh5FGU+yZ6SFsHEEZSFfpgSMgiPdQVWh0zaIDFcCqjGVADjFNGtiHYfMmUB1VQV9A07OKeOqEyqsMLEFB8xopKO7n67e/kG//wEVDp8zcVSL8aRrQR8js4SOIzCMYiXdwxcjWhjvvQczZkTu9OabMG9ewnaHYhMqaRrrxt0HVGmOGr5JhTMPm0Vzexfbdvawo6uPqooyZk4cwzeO+UBu5kqMrGKKwCh5wgxfJDOZnHCCdBQLxqSqsMLMgcyf1sC3TtjL0kaXKKYIjJInlqvnQbMbeWBlC795ah3V5cLG9i5mTawLNZkc64Hd9OyTXPT9qOm1XbugNv5DPJ5fPyQ33p6z9NhGwWCKwChakunFBx+C0T3oJ1e30tHVNzgsM9JkcrSFcdHxew8/4AhWQKxe/COrWjlmfhOrW3ZGxCYAfPeuFfz93XYU5YAZjZx52KxB2cyFMzsU8kI8pgiMomQ0LqHRPeie/gHKRFm6upXG2irqayqYM2kMHd19Mff3LYy+L53DBx/4Q+TGkMNA8Xrxq1t2csGxew6e463PrOexN1rp7Omnqb6SMVUVPLdmG83tXXzrhL2YP63BXDizQF64II+CUF5DIrJGRCbGKG8UkTXpF8swRsdo8uxHexGVi9Da0Utnj8ur393bzwtr36eqPF4ORZi/W+OISmBVs1un4OLfvzxsvYKRPJn8B8/Kjdvp7x+gokzY3NHLhvZOtu3q4bWN2wcXgUk2NbWRPJla1yFbhLUIZhM7PqAamJ42aYyiIpemcrLDIUFZ39m2i96+/sGIWhHoH1DGVA39BZQ4qXSrqqC3N7IshhUwUg9ypF784Apg/QN09w/Q2zdAV+8AZWXQ6JX7i8CMKt2FEYpCH35LqAiCEcPAP4hI0Mj9GGQAACAASURBVBG6HJc+el0G5DIKnFybyskMh0TL2tPbz4vvtAEwc2IdnT0DTKyrpL6mcjCl8j67jaW7P+oBn4RH0EgTuCN5MvkPngoRunoH6B8Y8A4v7Ojuo66qYnARGH/+wx786SO6k1NVLuzo6ivY4beRLALftlXc6mJBenFK4KI0y2QUAdmK1vXbDHrWrG7ZyWvN7by7tZM9p9Qza1Id72zdyRstHew+vpbFD6+OsE6iZd2jyVkCzdu7qawoZ0J9FdPGVUfk3Gnv7B3Kq5+CS+hIPciRevG+olOgqryMnf0DiAKiqAp9A2qLwGSIWJ2clu3dDKgya2JdQUZQJ1QEqloGICJrgYNUdUtWpDIKnnSbyrH+fFc+8AZlIsyYMIZpDTWs29LBHS+8w9iaCsrLhAGFVza0s3lHF227+gaVQrR1EkvWWZPqqKos56rT9ouIFB72J49WAqeeCn/844jnE8ZiSdSL9y2Gzt5+ZkyoYc2WnfT0KeUC42oqGFdbSXVFxbBFYArZsyVfiNnJmTCG3r5+GmorC3L4LdQcgarukWlBjOIiG9G623b2ALBguvuzrWndyc7uflRh1sQxdPcN0NeldHT3R6RCjrZORpI1Vu/88pMXDBcypEcQjD4Hjy/T9+99jW0dPcxrGktHVy8NY6pQVUQkZlBcIXu25AvxOjnN7X2DHl2FRtgVyq4HXlXVn0SVXwjso6rnZEI4o3BJd7KxZ9/ewrvvd7K9y03ENtRU0N2v1FcPTeA2b++iplLo6R9gQ1sn3X0DlAGbd3Rx5N6TI9oLWidhZB3snXd3Q03kQ+DWb/yI1k+eygnexGwY0jGBO39aA1ectM/gw725bRcvvdtOR3cfcybVccz8poj2MjFcV4oUoztuWK+hExnKQBrkMeDi9IljFAvp9FS5b8UGVm3agQ4ofQMDKNDa0UNVudDXr2zp6GJSvXs49/QpPf0DVJWXUVVeRndfP719A7yzdWfEGP9IPf6YssaYC7j8npVOeaTQu07HBK4v+y3PrGfVpg6mNtSwz25jqa6o4JFVrcxpqrfAsjRTjBlVwyqCRqAjRvlOYEL6xDHynVSjdRPtDyRs86Zn3mFifRWb2rsQESrKhN7+Abr6Bhgjwv2vbOIDk+upqypnY2cvYyrLKS+D/oEB+hWmjKvhjZYOxtdVj9zjj8Xbbw9LCHfjb/7KukkzMtq7Dnut509roGlsDUftPTmilxotTzH2ZHNBMbrjhgooA1bjrIJo/oHhq5YZRUro9MpJ7H/lA29w1YOrE7bZsr2LSXVVVFeUUV4m9A+o98MVpoyrplyEbTt7EYHaCqGmsoyefufp31hTwUfmTWT38bWppUIWGZ4VVJWVY6elNXV1NMle6zCptC2wLH3Mn9bABcfuyVWn7ccFx+5Z0EoAwlsEPwGuE5HJuOEgcDEE5wNfy4RgRvYZqQc62jHmMBO+sdqcMq6G7Z29jKmuoL9fqSgXtu3soboCxlRXMr6+hsPmTKS9s5cX1m3zLAalvqaCeU11VFWUs+9utclN5N17L5x8cmRZRwfU1QGZ710ne63DeiEVW0/WSA9hvYZuEpEa4DLgO17xBuBCVb0hU8IZ2SOMR8lox5hj7d/TN4AS6W0T3eZZh83kP//8Gt19A+zq6UdE6O0bYPr4Grr7Bth3t3GD++3WWEN9tXuApjx+GyIuINPjxMle67DyWGCZEYuwQ0Oo6i9VdQYwBZiqqjNU9brMiWakk0R5bSBcrpTpjbXs6IpMtJZMLzjW/lUVZVRXRGYviW5zTlM9sybWUVVRRmW5UF4G1ZVl1FSWc+DMxsFFWnZ09dFUX82YyjKeX7uNR1a10NPXH34Y6MtfHq4EVGO6hWZ65a1kr7WtBGaMhqSzj6pqayYEMTJHunr7o+0Fx9p/Ql0VZZ7Pe7w2H1jZwj67NXDY3EmDZeu2dPDGpg6qKsoZUGVHVx/rt+4cDDA7ev7kwbZCkUJ0cCZ716lca+vtG6kSVxGIyArg46r6voi8AsT9V6jqhzIhnJEc8cb4w4w3Z2OMOdb+3zphr0FZ4rUZS0nNnFjHrt7ISM7dGmqorChPbg6jogL6+yPLkggMy1Skro3nG9kkkUXwR6Db+/yHBPWMPCBRrz+dvf3R9jrj7Z+ozXhKah/Pc8Pn4t+/zIT6JDx5RrFsJGQ+Utd6+Ea2iKsIVPWKWJ+N/CRRr78QPUqCPe3gUpGJlFRoT55RKgCfTEfqWl4gI1vYCmV5Rqp//kS9/i9/dHZBeZRE97R3dPVRJkJPXz/N7X1xlVQoqyZaCXzqU/CH1AzeTEbqWl4gI5skmiNYS4J5gSCqOidtEpUwo/nzJ+oN51tvfyTiZXdsqK1MGAuQ8DzTZAUEyWQswa3PrGdNawc9/QOMq6lk3uS6QS+ufL1vRuGSyCK4NvC5HrgQeB54xis7DDgYF2w2Il7iuk8Cm1V1gVd2OfAVwPdEulRV7w8rfLExmqGGkXrD+dLbH4lVze089NomUBhbW8m8pjqaxtaE7mkPO8+uruFK4IYb4OyzRy1rpmIJVjW387e3ttJYW8HY6gq6evtZvr6NA2Y2sKEt9jrJhjEaEs0RDD7gReRG4H9V9YfBOiLyHWDfkMe6Eadcbo4qX6yqV4Vso6gZzVBDofX6Y3Hfig1c89jbtGzvorJMGFDlxXd6OXBmI1UV5cn3tDNgBQTJ1DV/YGUL48e4ToCIUFPp4ixe27iDRXtNTrSrYaRE2DmCU4EDY5T/nqFI44So6pMiMjvk8UqS0Q41pKPXP9IcRbonMP32Xmtu58X1bYzzooM3vt9Fy/ZuJo+t4tWN25nTVB++p71mDcydG1n26quwzz4pyxmPTFhaG9o6mT9tLC+964L+qivKQJX3O/ssL5CREcJGFu8EFsUoXwTsGqUMXxeRFSJyvYiMj1dJRM4VkWUisqy1tThj2nKdFGykRGejTToX73jrtnSwckM727t6aW7vpLt3gOnja6muKGPrzh56+zW5JHHRSkA1I0ogU0xvrKWmsoIDZzZSXVlOR3c/iPDReRMLysIzCoewimAx8HMRuU5EzvZe1+HWKFg8iuP/ApgL7A80k2C+QVWXqOpCVV3Y1NQ0ikPmL9lMExAr5cRIaSbCpKFIhgdWtjAwMMAbLR109Q5QXSEorkcs4lYZaxxTxbH7hLA6fve74UNBu3aldSgoW/gdgqqKcg7ZYwIH7zGBOU31nHnYrFyLZhQpYZPOXSki64BvAp/xilcBZ6nqnakeXFUHnyAi8ivgL6m2VSxkY1I3nnfSjq5e5k8bF1E3OEeR6hxGvOGkDW2dNLd3UV1RRm1VOdKtbg2BAWVrRzfjaquoLC8b2SLK8FxAtimG+R6jsAgdR+A98FN+6MdCRKaparP39RRgZTrbN2ITzztpQ1snO7r64s5RpDKHkcgldnpjLX9/530m1lUxYUwVzb0DVJVDf9kAO7r6GVcD5x09N/4D8NRT4e67I8sKWAEEKRQvL6M4CK0IvDTUn8QN5fxSVdtEZC7wvqpuC7H/b3FzCpNE5D3g+8AiEdkfF6+wDvhq0mdgJE28nn1DbcVgkrZY7pCpuEv6Sqe3v5/n125ne1cvVeVl3PrMes44bBYPvrqJ7V19jKupYGJdFVt39jC2spLdxtdyxUn7xH8YFpkVYBi5JOzi9fOAR3DxBI04b6E24F+97yMuXq+qn4tR/JvQkhYw+ZYqIFHunhMWTIk7JJHKkMWGtk4qy+Hv77RTXVE26Bf/t7e2csZhszjvqLlc8+jbbNvZy4S6SvaeOpby8rL4cyNJKIB8u+6Gka+IhuhFichfgI24B38bsJ+qrhGRjwE3qOrchA2kmYULF+qyZcuyeciUCQ6NBHvR6ZwETvaBlw2ZfBY/vJqlb2wGGPSH7+p12T4X7TWZC47dM7z8SSqBbJ2jYRQKIrJcVRdGl4cdGvoIcKiq9kvkn/EdYLc0yFe0ZCMxWbJpKdIxGRn24X3Cginc/fcNjK+tQFXp7hugu2+A/Wc0DE4yjzgensIwUKavu2EUE8kknauMUTYTSM2JvETIZGIySP2BN5rJyGSUz/xpDXx03kRe3bidju5+6msq2He3cVQF1g1IqFSilcBpp8GdI/ssZPq6G0YxETaO4CFcriEfFZFxwBXAfWmXqogY7fKOI7GhrZOxNUnk4I/BSMtYRpNsPMGZh81iTlM9B+8xgUP2mEBVRflgoFy8IDVEYi8bGUIJQOavu2EUE2EVwYXAR0XkDaAGuAPn5TMVuCQzohUHmY4WHu0DL5Vo4WSVT6JAuWilMqGsn8X/fEBkAzfdlLRH0Giue7KK0TAKnbABZRs9N8/P4XIOlQFLgNtUtSBs7Vx5kGQ6OGi0GTBTGVpKJZ4g3lBUcAjnguP2Gr5jii6hqV53WwfAKEVGVAQiUgnciksRfT1wfcalSjO5/nNnMjhotIomlbH0dKZfnt5YS+Xq1/n610+OKL/p1/dz1pc/kXR7QVK57skqRnNRNYqBERWBqvaKyHGEzDKajxS7B8loFE2qvft0WTmxrIALfvd3zv3YHkm3lQ6SUYy57mAYRroI6zV0Fy4VdUGuG1DoHiSZ7HWm2rsftZXz29/C5z8fUXTpzc/QNHUC5+awV52MYiz2DoZROoRVBO8Al4nIEcAyXFrqQVT16nQLlk4yuaRgpsl0r3O0vfuUlFScuIAfDi/NOskoxkLvYBiGT1hFcDbwPvAh7xVEgbxWBJlaUjAbZKPXmWrvPmkl9fWvw89/HlmWZ/mBklGMhdzBMIwgYb2GcjNgmyYKJa1vrN51Pvc6k1JSBZQkLqxiLOQOhmEESSayGAARqQdQ1Y70i5M58j2tb7zedW1lWcLU0LkklJJasMAtExkkTxVAshRKB8MwRiKZNNTn4wLLpnvfN+KGhH6qYTLXGQmJ17vu7etPmBo6l4w4NFJAVkCq5HsHwzDCEDYN9ZXAucCPgWe84sOA7wHTgG9lRLoCJZUJ1Hi961XNu5gytprn125DUQ6Y0Zg37onxhkYuP3nB8MpFpgAMo5gIm2LiHOAcVf2Bqj7mvX4AfAX4cubEKzxSXeA9VqqI9Vt28t77nVRWlHP0/MkcssdEOnsHMil+UsRKHTEsPcS3vmVKwDDynGTmCFbEKQurTEqCVL18gr3r7r4+Xtu4g7VbdjJ1XA29/f2USWVe+qkPDo2UwDCQYRQrYR/iNwNfi1H+r8At6ROnsFnV3M5Dr23iuTVbeWbNVlp3dAHhvHz83nVvXz//95Zb+XNifRU1lWUsX9/Glo7wbWWV7u7hSuDPfzYlYBgFRFiLoBr4vIgcDzzrlR2CW5TmNhH5mV9RVb+RXhELA39IqKq8zC3A0tvPi++0ceDMRqoqykN5+cyf1sCksTUctfdkGmoreWbNVrp7+6muEN7avJNJ9TV54zEEmBVgGEVCWItgb+BFoBmY5b02eWXzgQ96rxizhKWBPyS0YPo4evrdw7C6XHh14/ak0k4HUzzPa6qju28AVGnv7El7CuuUaWkZrgTeeceUgGEUKGEDyo7MtCCFju/1UyaVfHhWI29t3kl7Zw9lkmAh9hgEXTKbxtZw4MxGXt24nTIpo6G2Mvd+6mYFGEbRkXRAmRGb4AN8Un0Nk+prBr8n8+COdsmsqihnTlN97l1Gn38eDjkksqy7G6qqciOPYRhpwzx+0kS6ViJLtJpXzhAZrgRUTQkYRpFgFkGaSGe6gUxHq4YOeLvhBvjSlyLLAsNAtiiLYRQHUojZIRYuXKjLli3LtRgFSTCnUTAaeJjVET0XMGsWrFuXfDuGYeQNIrJcVRdGl9vQUIkRvVi8//mBlS2uwsknD1cCqhFKIFQ7hmEUDKYISoyge6rPYJCaCNx779CGc86J6xGUsB3DMAoKmyMoMWJlDP3SmUczfvOGyIojDBnaoiyGUTyYRVBiRHs3XXDcXpFK4OqrQ8UFpMtLyjCM3GMWQYnhezfN361x+MYkHAdsURbDKB5MEZQaPT3DlcBzz8HBByfdlC3KYhjFQdaGhkTkehHZLCIrA2UTRORhEXnTex+fLXlKEhGoro4sU01JCRiGUTxkc47gRuCEqLJLgEdV9QPAo953I91s2jTcJXTTJssRZBgGkMWhIVV9UkRmRxWfDCzyPt8ELAW+nS2ZSgJLEmcYxgjkeo5giqo2A6hqs4hMjldRRM7FrZvMzJkzsyRe9klb2obnnoNDD40s6+mBysrY9Q3DKFkKxn1UVZeo6kJVXdjU1JRrcTJCqusdD0NkuBJQNSVgGEZMcq0IWkRkGoD3vjnH8uSUUadt+PWvY6eHsKEgwzASkGtFcC9wlvf5LOCeHMqSc0aVtkEEvvKVoe9z5pgCMAwjFFmbIxCR3+ImhieJyHvA94H/Ae4UkS8D7wCnZUuefCE4J/DOtl309PazR1P94PYR0zZcdhn84AeRZaYADMNIgmx6DX0uzqajsyVDvhFM5TytoYbePrfgPcCsSXWDqZ0/e9DusRuIHgb63vfgiisyLLVhGMVGrr2GSprgnADA7EnOEmje3k1VZXn8tA1HHQWPPx5ZZlaAYRgpYoogh/gL3geZObGOyopyrjptv9g7RVsBd90Fp5ySIQkNwygFTBHkkKRSOVtgmGEYGSLXXkMlTahUzr29w5XAihWmBAzDSBumCHKIn8q5obaS5vYuGmorI9f8FYGqqsidVOGDH8y+sIZhFC02NJRjYqZybmmBqVMjy7ZsgYkTsyeYYRglgymCfMPmAgzDyDI2NJQvbNw4XAn09JgSMAwj45giyAdEYPr0oe8nnWRJ4gzDyBo2NJRLVqyA/aLiBcwCMAwjy5hFkCtEIpXAkiWmBAzDyAlmEWSbv/4VTjwxsswUgGEYOcQUQTaJngx+6CE49tjcyGIYhuFhQ0PZ4Be/iL1gjCkBwzDyALMIMk2s9BAWGWwYRh5hiiBTXHghLF4cWWZzASVHcOGh6Y21nLBgyvBIcsPIMTY0lG76+50VEFQCGzeaEihB/IWH2jt7mdZQQ3tnL0ueXMuq5vZci2YYEZgiSCdPPAEVASNryhSnAKZNy51MRs4ILjxUJjL4+YGVLbkWzTAisKGhdNDXB/vuC6tXD5V1dEBdXe5kMnJOrIWHxtZUsKGtM0cSGUZszCIYLX/6k0sF4SuBJ590VoApgZJnemMtO7r6IsriLjxkGDnEFEGqdHbC2LFDy0QefTQMDMARR+RWLiNvCLXwkGHkAaYIUuH662HMGDf8A/Dyy/DII7FTSBsly4gLDxlGnmBzBMnQ1gbjxw99P+MMuOWW3Mlj5D0xFx4yjDzDLIKwXHllpBJ4+21TAoZhFAVmEYxEczPsttvQ94svhh//OHfyGIZhpBlTBIm46CK4+uqh75s2udgAwzCMIsKGhmLx1ltu4tdXAlde6VxCTQkYhlGEmEUQzemnw+23D31va4MGm+wzDKN4MUXg89JLcMABQ99vuAHOPjupJizBmGEYhYgNDanCkUcOKYHx412wWApKwBKMGYZRiJS2InjiCSgrg6VL3fd774Vt26CmJuFusbAEY4ZhFCp5MTQkIuuAHUA/0KeqCzN6wOgkcfPnuwVjKlK/HJZgzDCMQiWfLIIjVXX/jCuBWEniXnttVEoALMGYYRiFSz4pgszzxBMZSxJnCcYMwyhU8kURKPCQiCwXkXNjVRCRc0VkmYgsa21tTe0oU6fC4YdnJEmcJRgzDKNQEc2DJRRFZDdV3Sgik4GHgfNU9cl49RcuXKjLli3LnoCGYRhFgIgsjzX8nhcWgapu9N43A3cDB+dWIsMwjNIh54pAROpEZKz/GTgOWJlbqQzDMEqHfHAfnQLcLW68vgK4XVUfyK1IhmEYpUPOFYGqrgH2y7UchmEYpUrOh4YMwzCM3GKKwDAMo8QxRWAYhlHimCIwDMMocfIioCxZRKQVWJ/i7pOALWkUp1AoxfO2cy4dSvG8UznnWaraFF1YkIpgNIjIsowntstDSvG87ZxLh1I873Sesw0NGYZhlDimCAzDMEqcUlQES3ItQI4oxfO2cy4dSvG803bOJTdHYBiGYURSihaBYRiGEcAUgWEYRolTUopARNaJyCsi8pKIFOXKNiJyvYhsFpGVgbIJIvKwiLzpvY/PpYyZIM55Xy4iG7z7/ZKInJhLGdONiMwQkcdFZJWIvCoi3/TKi/Z+Jzjnor3XIlIjIs+LyMveOV/hle8hIs959/kOEalK+RilNEcgIuuAhapatIEnIvIxoAO4WVUXeGVXAttU9X9E5BJgvKp+O5dypps453050KGqV+VStkwhItOAaar6oremx3Lgn4CzKdL7neCcP0OR3mtxOfrrVLVDRCqBp4BvAhcCd6nq70TkOuBlVf1FKscoKYugFPCW+NwWVXwycJP3+SbcH6eoiHPeRY2qNqvqi97nHcAqYDpFfL8TnHPRoo4O72ul91LgKOAPXvmo7nOpKQIFHhKR5SJybq6FySJTVLUZ3B8JmJxjebLJ10VkhTd0VDRDJNGIyGzgAOA5SuR+R50zFPG9FpFyEXkJ2Ixb1/1toE1V+7wq7zEKhVhqiuBwVT0Q+ATwNW84wShefgHMBfYHmoGf5FaczCAi9cAfgfNVdXuu5ckGMc65qO+1qvar6v7A7rg13efHqpZq+yWlCFR1o/e+Gbgbd0FLgRZvbNUfY92cY3mygqq2eH+gAeBXFOH99saM/wjcpqp3ecVFfb9jnXMp3GsAVW0DlgKHAo0i4q8yuTuwMdV2S0YRiEidN7mEiNQBxwErE+9VNNwLnOV9Pgu4J4eyZA3/YehxCkV2v71JxN8Aq1T16sCmor3f8c65mO+1iDSJSKP3uRY4Bjc38jjwaa/aqO5zyXgNicgcnBUAbq3m21X1BzkUKSOIyG+BRbgUtS3A94E/AXcCM4F3gNNUtagmVuOc9yLcUIEC64Cv+mPnxYCIfBT4G/AKMOAVX4obMy/K+53gnD9Hkd5rEfkQbjK4HNd5v1NV/9N7pv0OmAD8HThDVbtTOkapKALDMAwjNiUzNGQYhmHExhSBYRhGiWOKwDAMo8QxRWAYhlHimCIwDMMocUwRGBlFRP4iIjfmgRw3ishfsni8y4OZUNPY7o0i8r0MtLtORC4eZRtL0yROxhCRP4jIhbmWI98wRWDkFBE5W0Q6Rq4Zur3ZIqIisjBdbabIVcDH09mgiHwQl1Dup+ls1+Mg4P8LHEtF5NMJ6odGRE4VkQdFpNVrd1GMOtUico2IbBGRnSJyr4jsHlVnpoj82du+RUR+Fp16WUQ+7uUS6xKRNSLyL1GHugK4TEQa0nFuxYIpgiJmNPnJ841CORcRKRORclXtUNWtaW7+POCPmcgnpKqtqror2f1EZJKI3CQi7wAfFZG1InK3H8XvUQc8jUubHI+fAp/CBYYdAYwD/iIi5d5xyoH7gLHe9s/homoHcwqJyB7A/d6xDgB+BFwjIp8KnOcrwBrgjGTPtahRVXsVwAv3Z7oZl3O/BfgO8BfgxkCddcDlwPVAG/B7r/yDwCNAJy5V841AQ2C/G4G/RB3vcmBldB1cHvQNwPvADcCYQJ0xXj1fxkujZYw6xiJcJGjwdXm8cwFme3UWRrWjwKcDn4OvpWHlTyDfJ4GXgC5c/vsPB+qc7Z3vibi0Bn3Agujr59U9CxcR2+1dn+C9a8AtRr4Z2AE8ETxPXFRpG3BSVJvrgIujypYC10bVuQz4JbAdl6ny3+O1430OXsN1Ca7RLcCb3rV6HveQ/k/cGgjRdSd57S2KKm8AeoDTA2UzcJHDx3vfP+F9nxGoc4Z3T8Z53/8XeDOq7V8Dz0SVfQ94Ktf/6Xx6mUVQOPwEN9RwCi4P+X64P100FwKvAwuBS0VkDPAA7mF1sLf/R3AP2GQ5AveQOwb4rNfWNwPbrwKOxfXsjsb1yhJleH0aOB/YBUzzXsGFRSLOJaSMfrKxE7z2Tk1C/nhcBXzbk2MNcJ93XX1qcA/arwL7AOujGxCRr+IexDcAH8Ipjle9bYLr7U7HKZ0DgCeBxwI5dD6Ee2CmurLeBTgldCDugXmliBwWp+5B3vtXcNfwIE9Of9jt7EDdA4BbVXUpsEtV/6aq31PV95OQ7cO4HPsP+QWq+i4un85HvKLDcPmF3g3s9yBQ7e3v13mISB4EFnqJ6nyeBw728vYYuJw7Rp7jpdz9EvAFVX3YK/syrmcXzROqemVg368A9cCZ6hbywFuL4XERmaeqbyUhynbgX9XlQF8lIr/HPfB/5Mn4ZeBLqvqgd5wvxpERAFXtEZF291E3hTiX2SFkbPXet8ZoM678I7T5XzHO6fO43ia43vp5qro8IGt0G/8B/FQjk8P59Y/E5clpUtVOv76I/CNwJnAlMAvXm451ncLwkKpe632+RkS+gTv3Z6IrqmqrJ39b1DXsBd4A2gNl/wd8QUSWkzpTgX4geuXAFm+bX6clavsWb79gnUditFGBs0b83EMbcYpnN1xe/5LHLILCYC7uh/u8X6CqO4mdYTG6xzgfWOErAY+ncWb2PknK8ZoOLYQB7g/lL3oyF6gi8GBRt6rSK0keI0i615VOJH8iYp1T8Nr14YaOYiIik3G9/UfjVPkwblitVUQ6/BfOepnr1akFetWlWU6FFVHfw577IKq6QVX3VtW7A8UX4hKfLQY+LiKvici/+2P7o0SIzLEfLzFaojoSo9xXtmYReJhFUBjE+jHHY2eMfUf6Aw0EjuFTyXB6Y+zvdyaGdYHTQPS5+A/BwWNFmfwjkUj+0dCtqv0Jto90bcpwPddYQ33+xPAWoEpExmjkpG467l3KeB2S7wLfFZHngWuAa722/zdkM5twVtUkhiw6cIrqyUCdw6P2m+Tt1xKoMzWqzmScog5O3E/w3lsxALMICoW3cH/kwcU2vDHqBSH2fQ3YL8qL4yO4e7/K+96KGwsOsn+KMh4akLEuhIw9uD9zhI9YGgAAA0pJREFUGPw/blDWaDl7vPd09Eh9Yp3TqvjVI1HVFtwE9dFxqrwITAEGVPWtqJe/qIxvcURbcRH3TkRqgL3DypaAXpK/hrtU9RZcuvePJrHfcu94x/oFnuvofJz1Cs4qmx/lUnosbuJ9eaDOMVFtHwssU9WgIlwAbPTui4EpgoLAG464HvhfETlaRPbBjU+XMbKVcBuuZ32ziHxQ3PKcvwTuCswPPAYcICJfEpF5IvIthve+wsj4G0/GY0VkX0/mkR4m64Aab59JUZOw0cfoBJ4Fvi0i+4rIR4icXAbnddMJHC8iU9LkL35Z1Dn1ALcn2cYPgPNF5AIR2VNE9heRi7xtj+DG2u8RkU+IyB4icpiIXCEiR4Abt8cpjOgH7GPA6SKyKCBfMlZSPNYBR4vIVPHW/xWR6SLyuoic4lcSkcWe736D+yqH4h6+fw/UmSAi+zPUKZjnnf9U79zacb+dH4vIMSJyAM4baQVDY/4P4SbXbxaRA0TkGODHwK90yJ32OmB3EfmpiMwXkXNwXl3Rv5EjcA4UhocpgsLhYtyCHPfiViZagRtD70q0kzeMcDzOL/t53CpGz+Amn/06D+ICbX6A613NJhBclKSMj+N6hI/j5jCeTLSDqj6N+wP/Fte7/dYIx/DlfgGn0C6Laq8P+AZwDm4cPB2rc12C89p6EfgA8ElvSCQ0qvoL4Gs4T5yVuAfRvt42xXkRPYZbZvEN3MIyexG5/OAS4PSopn/k7XcP7mH5lCfnaLkIN4n9LkMP9UpPpqByfQe42qv3MdwiSPcAPwzUOclr43Hv+6+878FgrwuAu4A7cEqxA/hHf8jNe/8HnIfZ/3n17sL95vDqrMVdx4/hLKjvAt9Q1T/6dTyL6RRPBsPDFqYpUESkGuem+GNVLaqFuvMFcRGwj+O8eaI9WrKOd89fx3mP/S3X8kQjIktVdVGu5UiEiHwNOFlVj8u1LPmETRYXCJ65PB/Xqx+L82sfi+sZGSWAqnaLyFkMTXYaydOLi9A2ApgiKCwuxJnmvrvix1Q1rp++UXyoasKhtlyS79YAgKouybUM+YgNDRmGYZQ4NllsGIZR4pgiMAzDKHFMERiGYZQ4pggMwzBKHFMEhmEYJc7/D1pvx9MAIkqnAAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
@@ -619,7 +609,7 @@
   "cell_type": "markdown",
   "metadata": {},
   "source": [
-    "# 训练方式二\n",
+    "## 训练方式二\n",
    "我们也可以用我们的高层API来做线性回归训练，高层API相较于底层API更加的简洁方便。"
   ]
  },
@@ -633,59 +623,39 @@
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
-      "step 10/51 - loss: 459.0659 - 2ms/step\n",
-      "step 20/51 - loss: 529.2217 - 2ms/step\n",
-      "step 30/51 - loss: 632.7692 - 2ms/step\n",
-      "step 40/51 - loss: 611.4449 - 2ms/step\n",
-      "step 50/51 - loss: 787.7990 - 2ms/step\n",
-      "step 51/51 - loss: 616.6230 - 2ms/step\n",
+      "step 20/51 - loss: 520.8663 - 1ms/step\n",
+      "step 40/51 - loss: 611.7135 - 1ms/step\n",
+      "step 51/51 - loss: 620.0662 - 1ms/step\n",
      "Eval begin...\n",
-      "step 10/13 - loss: 412.7979 - 845us/step\n",
-      "step 13/13 - loss: 394.4999 - 962us/step\n",
+      "step 13/13 - loss: 389.7871 - 1ms/step\n",
      "Eval samples: 102\n",
      "Epoch 2/5\n",
-      "step 10/51 - loss: 498.4369 - 2ms/step\n",
-      "step 20/51 - loss: 872.9701 - 1ms/step\n",
-      "step 30/51 - loss: 660.2790 - 2ms/step\n",
-      "step 40/51 - loss: 1086.9590 - 2ms/step\n",
-      "step 50/51 - loss: 569.2678 - 3ms/step\n",
-      "step 51/51 - loss: 416.6243 - 3ms/step\n",
+      "step 20/51 - loss: 867.4678 - 3ms/step\n",
+      "step 40/51 - loss: 1081.1701 - 2ms/step\n",
+      "step 51/51 - loss: 420.8705 - 2ms/step\n",
      "Eval begin...\n",
-      "step 10/13 - loss: 413.6576 - 3ms/step\n",
-      "step 13/13 - loss: 391.9444 - 3ms/step\n",
+      "step 13/13 - loss: 387.2432 - 1ms/step\n",
      "Eval samples: 102\n",
      "Epoch 3/5\n",
-      "step 10/51 - loss: 639.1314 - 2ms/step\n",
-      "step 20/51 - loss: 839.7043 - 1ms/step\n",
-      "step 30/51 - loss: 658.3038 - 1ms/step\n",
-      "step 40/51 - loss: 855.3226 - 1ms/step\n",
-      "step 50/51 - loss: 863.4664 - 1ms/step\n",
-      "step 51/51 - loss: 415.3571 - 1ms/step\n",
+      "step 20/51 - loss: 810.1555 - 2ms/step\n",
+      "step 40/51 - loss: 840.3570 - 2ms/step\n",
+      "step 51/51 - loss: 421.0806 - 2ms/step\n",
      "Eval begin...\n",
-      "step 10/13 - loss: 414.4321 - 868us/step\n",
-      "step 13/13 - loss: 389.4324 - 892us/step\n",
+      "step 13/13 - loss: 384.7417 - 693us/step\n",
      "Eval samples: 102\n",
      "Epoch 4/5\n",
-      "step 10/51 - loss: 660.5611 - 1ms/step\n",
-      "step 20/51 - loss: 649.4131 - 1ms/step\n",
-      "step 30/51 - loss: 578.6218 - 1ms/step\n",
-      "step 40/51 - loss: 697.6048 - 1ms/step\n",
-      "step 50/51 - loss: 784.4253 - 1ms/step\n",
-      "step 51/51 - loss: 423.0613 - 1ms/step\n",
+      "step 20/51 - loss: 647.1215 - 1ms/step\n",
+      "step 40/51 - loss: 682.9673 - 1ms/step\n",
+      "step 51/51 - loss: 422.0570 - 1ms/step\n",
      "Eval begin...\n",
-      "step 10/13 - loss: 415.2260 - 598us/step\n",
-      "step 13/13 - loss: 386.9349 - 702us/step\n",
+      "step 13/13 - loss: 382.2546 - 591us/step\n",
      "Eval samples: 102\n",
      "Epoch 5/5\n",
-      "step 10/51 - loss: 1080.4787 - 2ms/step\n",
-      "step 20/51 - loss: 726.1576 - 2ms/step\n",
-      "step 30/51 - loss: 873.2540 - 1ms/step\n",
-      "step 40/51 - loss: 566.3094 - 1ms/step\n",
-      "step 50/51 - loss: 578.0419 - 1ms/step\n",
-      "step 51/51 - loss: 459.7528 - 1ms/step\n",
+      "step 20/51 - loss: 713.3719 - 1ms/step\n",
+      "step 40/51 - loss: 567.0962 - 1ms/step\n",
+      "step 51/51 - loss: 456.8702 - 1ms/step\n",
      "Eval begin...\n",
-      "step 10/13 - loss: 415.9169 - 707us/step\n",
-      "step 13/13 - loss: 384.4219 - 805us/step\n",
+      "step 13/13 - loss: 379.7527 - 985us/step\n",
      "Eval samples: 102\n"
     ]
    }
@@ -702,18 +672,19 @@
    "    \n",
    "#step2:定义模型\n",
    "class UCIHousing(paddle.nn.Layer):\n",
-    "  def __init__(self):\n",
-    "    super(UCIHousing, self).__init__()\n",
-    "    self.fc = paddle.nn.Linear(13, 1, None)\n",
+    "    def __init__(self):\n",
+    "        super(UCIHousing, self).__init__()\n",
+    "        self.fc = paddle.nn.Linear(13, 1, None)\n",
    "\n",
-    "  def forward(self, input):\n",
-    "    return self.fc(input)\n",
+    "    def forward(self, input):\n",
+    "        pred = self.fc(input)\n",
+    "        return pred\n",
    "\n",
    "#step3:训练模型\n",
    "model = paddle.Model(UCIHousing())\n",
    "model.prepare(paddle.optimizer.Adam(parameters=model.parameters()),\n",
    "              paddle.nn.loss.MSELoss())\n",
-    "model.fit(train_dataset, eval_dataset, epochs=5, batch_size=8)"
+    "model.fit(train_dataset, eval_dataset, epochs=5, batch_size=8, log_freq=20)"
   ]
  }
 ],