diff --git a/5_nn/2-mlp_bp.ipynb b/5_nn/2-mlp_bp.ipynb index e64ba53..99808a1 100644 --- a/5_nn/2-mlp_bp.ipynb +++ b/5_nn/2-mlp_bp.ipynb @@ -1011,7 +1011,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1025,7 +1025,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.9" + "version": "3.9.7" } }, "nbformat": 4, diff --git a/6_pytorch/1-tensor.ipynb b/6_pytorch/1-tensor.ipynb index f3dcb0f..4e50967 100644 --- a/6_pytorch/1-tensor.ipynb +++ b/6_pytorch/1-tensor.ipynb @@ -4,14 +4,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Tensor and Variable\n", + "# PyTorch\n", "\n", + "PyTorch是基于Python的科学计算包，其旨在服务两类场合：\n", + "* 替代NumPy发挥GPU潜能\n", + "* 提供了高度灵活性和效率的深度学习平台\n", + "\n", + "PyTorch的简洁设计使得它入门很简单，本部分内容在深入介绍PyTorch之前，先介绍一些PyTorch的基础知识，让大家能够对PyTorch有一个大致的了解，并能够用PyTorch搭建一个简单的神经网络，然后在深入学习如何使用PyTorch实现各类网络结构。在学习过程，可能部分内容暂时不太理解，可先不予以深究，后续的课程将会对此进行深入讲解。\n", "\n", - "张量(Tensor)是一种专门的数据结构，非常类似于数组和矩阵。在PyTorch中，我们使用张量来编码模型的输入和输出，以及模型的参数。\n", "\n", - "张量类似于`NumPy`的`ndarray`，不同之处在于张量可以在GPU或其他硬件加速器上运行。事实上，张量和NumPy数组通常可以共享相同的底层内存，从而消除了复制数据的需要(请参阅使用NumPy的桥接)。张量还针对自动微分进行了优化，在Autograd部分中看到更多关于这一点的内介绍。\n", "\n", - "`variable`是一种可以不断变化的变量，符合反向传播，参数更新的属性。PyTorch的`variable`是一个存放会变化值的内存位置，里面的值会不停变化，像装糖果（糖果就是数据，即tensor）的盒子，糖果的数量不断变化。pytorch都是由tensor计算的，而tensor里面的参数是variable形式。\n" + "![PyTorch Demo](imgs/PyTorch.png)\n" ] }, { @@ -20,6 +23,12 @@ "source": [ "## 1. Tensor基本用法\n", "\n", + "张量(Tensor)是一种专门的数据结构，非常类似于数组和矩阵。在PyTorch中，我们使用张量来编码模型的输入和输出，以及模型的参数。\n", + "\n", + "张量类似于`NumPy`的`ndarray`，不同之处在于张量可以在GPU或其他硬件加速器上运行。事实上，张量和NumPy数组通常可以共享相同的底层内存，从而消除了复制数据的需要(请参阅使用NumPy的桥接)。张量还针对自动微分进行了优化，在Autograd部分中看到更多关于这一点的内介绍。\n", + "\n", + "`variable`是一种可以不断变化的变量，符合反向传播，参数更新的属性。PyTorch的`variable`是一个存放会变化值的内存位置，里面的值会不停变化，像装糖果（糖果就是数据，即tensor）的盒子，糖果的数量不断变化。pytorch都是由tensor计算的，而tensor里面的参数是variable形式。\n", + "\n", "PyTorch基础的数据是张量(Tensor)，PyTorch 的很多操作好 NumPy 都是类似的，但是因为其能够在 GPU 上运行，所以有着比 NumPy 快很多倍的速度。本节内容主要包括 PyTorch 中的基本元素 Tensor 和 Variable 及其操作方式。" ] }, @@ -32,10 +41,8 @@ }, { "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true - }, + "execution_count": 2, + "metadata": {}, "outputs": [], "source": [ "import torch\n", @@ -44,10 +51,8 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true - }, + "execution_count": 3, + "metadata": {}, "outputs": [], "source": [ "# 创建一个 numpy ndarray\n", @@ -63,13 +68,11 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": true - }, + "execution_count": 9, + "metadata": {}, "outputs": [], "source": [ - "pytorch_tensor1 = torch.Tensor(numpy_tensor)\n", + "pytorch_tensor1 = torch.tensor(numpy_tensor)\n", "pytorch_tensor2 = torch.from_numpy(numpy_tensor)" ] }, @@ -96,10 +99,8 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": true - }, + "execution_count": 5, + "metadata": {}, "outputs": [], "source": [ "# 如果 pytorch tensor 在 cpu 上\n", @@ -128,9 +129,7 @@ { "cell_type": "code", "execution_count": 7, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "# 第一种方式是定义 cuda 数据类型\n", @@ -161,9 +160,7 @@ { "cell_type": "code", "execution_count": 8, - "metadata": { - "collapsed": true - }, + "metadata": {}, "outputs": [], "source": [ "cpu_tensor = gpu_tensor.cpu()" @@ -697,6 +694,7 @@ "metadata": {}, "source": [ "## 参考\n", + "* [PyTorch官方说明文档](https://pytorch.org/docs/stable/)\n", "* http://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html\n", "* http://cs231n.github.io/python-numpy-tutorial/" ] diff --git a/6_pytorch/2-autograd.ipynb b/6_pytorch/2-autograd.ipynb index 2a65563..644bd57 100644 --- a/6_pytorch/2-autograd.ipynb +++ b/6_pytorch/2-autograd.ipynb @@ -15,16 +15,7 @@ "\n", "从 PyTorch 0.4版本起， `Variable` 正式合并入 `Tensor` 类，通过 `Variable` 嵌套实现的自动微分功能已经整合进入了 `Tensor` 类中。虽然为了的兼容性还是可以使用 `Variable`（tensor）这种方式进行嵌套，但是这个操作其实什么都没做。\n", "\n", - "以后的代码建议直接使用 `Tensor` 类进行操作，因为官方文档中已经将 `Variable` 设置成过期模块。" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import torch" + "**以后的代码建议直接使用 `Tensor` 类进行操作，因为官方文档中已经将 `Variable` 设置成过期模块。**" ] }, { @@ -32,12 +23,13 @@ "metadata": {}, "source": [ "## 1. 简单情况的自动求导\n", - "下面我们显示一些简单情况的自动求导，\"简单\"体现在计算的结果都是标量，也就是一个数，我们对这个标量进行自动求导。" + "\n", + "下面展示一些简单情况的自动求导，\"简单\"体现在计算的结果都是标量，也就是一个数，对这个标量进行自动求导。" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -49,6 +41,8 @@ } ], "source": [ + "import torch\n", + "\n", "x = torch.tensor([2.0], requires_grad=True)\n", "y = x + 2\n", "z = y ** 2 + 3\n", @@ -65,18 +59,18 @@ "z = (x + 2)^2 + 3\n", "$$\n", "\n", - "那么我们从 z 对 x 求导的结果就是 \n", + "那么我们从 $z$ 对 $x$ （当$x=2$）求导的结果就是 \n", "\n", "$$\n", "\\frac{\\partial z}{\\partial x} = 2 (x + 2) = 2 (2 + 2) = 8\n", "$$\n", "\n", - "如果你对求导不熟悉，可以查看以下[《导数介绍资料》](https://baike.baidu.com/item/%E5%AF%BC%E6%95%B0#1)网址进行复习" + ">如果对求导不熟悉，可以查看[《导数介绍资料》](https://baike.baidu.com/item/%E5%AF%BC%E6%95%B0#1)进行复习。" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -97,12 +91,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "对于上面这样一个简单的例子，我们验证了自动求导，同时可以发现发现使用自动求导非常方便。如果是一个更加复杂的例子，那么手动求导就会显得非常的麻烦，所以自动求导的机制能够帮助我们省去麻烦的数学计算，下面我们可以看一个更加复杂的例子。" + "上面简单的例子验证了自动求导的功能，可以发现使用自动求导非常方便，不需要关系中间变量的状态。如果是一个更加复杂的例子，那么手动求导有可能非常的麻烦，所以自动求导的机制能够帮助我们省去繁琐的数学公式推导，下面给出一个更加复杂的例子。" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -124,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -136,12 +130,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "如果你对矩阵乘法不熟悉，可以查看下面的[《矩阵乘法说明》](https://baike.baidu.com/item/%E7%9F%A9%E9%98%B5%E4%B9%98%E6%B3%95/5446029?fr=aladdin)进行复习" + "> 如果对矩阵乘法不熟悉，可以查看[《矩阵乘法说明》](https://baike.baidu.com/item/%E7%9F%A9%E9%98%B5%E4%B9%98%E6%B3%95/5446029?fr=aladdin)进行复习。" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -196,12 +190,12 @@ "source": [ "## 2. 复杂情况的自动求导\n", "\n", - "上面我们展示了简单情况下的自动求导，都是对标量进行自动求导，那么如何对一个向量或者矩阵自动求导？" + "上面展示了简单情况下的自动求导，都是对标量进行自动求导，那么如何对一个向量或者矩阵自动求导？" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -222,7 +216,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -280,7 +274,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -289,7 +283,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -446,7 +440,7 @@ "k = (k_0,\\ k_1) = (x_0^2 + 3 x_1,\\ 2 x_0 + x_1^2)\n", "$$\n", "\n", - "我们希望求得\n", + "希望求得\n", "\n", "$$\n", "j = \\left[\n", @@ -460,7 +454,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -473,7 +467,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -504,7 +498,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 12, "metadata": { "scrolled": true }, diff --git a/6_pytorch/3-linear-regression-gradient-descend.ipynb b/6_pytorch/3-linear-regression.ipynb similarity index 70% rename from 6_pytorch/3-linear-regression-gradient-descend.ipynb rename to 6_pytorch/3-linear-regression.ipynb index f2306c2..2db4de0 100644 --- a/6_pytorch/3-linear-regression-gradient-descend.ipynb +++ b/6_pytorch/3-linear-regression.ipynb @@ -69,8 +69,8 @@ "最后我们的更新公式就是\n", "\n", "$$\n", - "w := w - \\eta \\frac{\\partial f(w,\\ b)}{\\partial w} \\\\\n", - "b := b - \\eta \\frac{\\partial f(w,\\ b)}{\\partial b}\n", + "w = w - \\eta \\frac{\\partial f(w,\\ b)}{\\partial w} \\\\\n", + "b = b - \\eta \\frac{\\partial f(w,\\ b)}{\\partial b}\n", "$$\n", "\n", "通过不断地迭代更新，最终我们能够找到一组最优的 $w$ 和 $b$。" @@ -93,7 +93,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 1, @@ -113,17 +113,10 @@ "execution_count": 2, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Matplotlib is building the font cache; this may take a moment.\n" - ] - }, { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 2, @@ -132,7 +125,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -208,7 +201,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -217,7 +210,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -234,13 +227,6 @@ "plt.legend()" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**思考：红色的点表示预测值，似乎排列成一条直线，请思考一下这些点是否在一条直线上？**" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -256,30 +242,21 @@ "cell_type": "code", "execution_count": 7, "metadata": {}, - "outputs": [], - "source": [ - "# 计算误差\n", - "def get_loss(y_, y):\n", - " return torch.sum((y_ - y) ** 2)\n", - "\n", - "loss = get_loss(y_, y_train)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "tensor(733.2964, dtype=torch.float64, grad_fn=)\n" + "tensor(704.5194, dtype=torch.float64, grad_fn=)\n" ] } ], "source": [ - "# 打印一下看看 loss 的大小\n", + "# 计算误差\n", + "def get_loss(y_, y):\n", + " return torch.sum((y_ - y) ** 2)\n", + "\n", + "loss = get_loss(y_, y_train)\n", "print(loss)" ] }, @@ -297,7 +274,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -307,15 +284,15 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "tensor([-135.3880])\n", - "tensor([-239.5816])\n" + "tensor([-117.3280])\n", + "tensor([-234.3059])\n" ] } ], @@ -327,7 +304,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -345,22 +322,22 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 12, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -387,18 +364,18 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "epoch: 19, loss: 17.798984092741378\n", - "epoch: 39, loss: 16.14508120463308\n", - "epoch: 59, loss: 15.55101918276564\n", - "epoch: 79, loss: 15.33763961353287\n", - "epoch: 99, loss: 15.26099545058815\n" + "epoch: 19, loss: 21.218688263809952\n", + "epoch: 39, loss: 19.55484974487415\n", + "epoch: 59, loss: 18.824963796393106\n", + "epoch: 79, loss: 18.50477882805245\n", + "epoch: 99, loss: 18.364321569910107\n" ] } ], @@ -419,22 +396,22 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 14, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAAD4CAYAAADFAawfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAAW+0lEQVR4nO3df5DU9X3H8df7+CGi1DgHcTT07rRTDUR+CKfFTkVUBBIyjdTMNPYSQxKDhmhpZpLRlJmaDmFSZzohMU3Uq6VOwxkn4I/aKVUSfwRn1OidQWNAwZADD205DkuUHwXu3v3je3vAsct993a/3/18d5+PmRvYvXX3s9/B1372/fll7i4AQLjqKt0AAMCpEdQAEDiCGgACR1ADQOAIagAI3MgknnT8+PHe1NSUxFMDQFXq6OjY4+4T8v0ukaBuampSe3t7Ek8NAFXJzHYU+h2lDwAIHEENAIEjqAEgcInUqPM5cuSIurq6dOjQobResuqNGTNGEydO1KhRoyrdFAAJSi2ou7q6NG7cODU1NcnM0nrZquXu6unpUVdXl84///xKNwdAglIrfRw6dEj19fWEdJmYmerr6/mGAqSorU1qapLq6qI/29rSed3UetSSCOky43oC6Wlrk5YskQ4ciG7v2BHdlqSWlmRfm8FEAIhh+fJjIZ1z4EB0f9II6piampq0Z8+eSjcDQIXs3Fnc/eUUbFAnWQtyd/X19ZXvCQFUvYaG4u4vpyCDOlcL2rFDcj9WCyolrDs7OzVp0iQtXbpUM2bM0IoVK3TppZdq6tSpuvPOOwced91112nmzJn62Mc+ptbW1jK8GwDVYOVKaezYE+8bOza6P2lBBnVStaA333xTN954o+666y7t2rVLL730kjZt2qSOjg5t3LhRkrR69Wp1dHSovb1dd999t3p6ekp7UQBVoaVFam2VGhsls+jP1tbkBxKllGd9xJVULaixsVGzZs3S17/+dW3YsEGXXHKJJOmDDz7Qtm3bNHv2bN1999169NFHJUlvv/22tm3bpvr6+tJeGEBVaGlJJ5gHCzKoGxqicke++0txxhlnSIpq1N/85jd18803n/D7Z599Vj//+c/1wgsvaOzYsZozZw7zlAFUXJClj6RrQfPnz9fq1av1wQcfSJJ27dql3bt3a9++fTr77LM1duxYvfHGG3rxxRfL84IAUIIge9S5rxbLl0fljoaGKKTL9ZVj3rx52rJliy6//HJJ0plnnqk1a9ZowYIFuvfeezV16lRddNFFmjVrVnleEABKYO5e9idtbm72wQcHbNmyRZMmTSr7a9U6ritQHcysw92b8/0uyNIHAOAYghoAAkdQA0DgCGoACBxBDQCBI6gBIHAEdR4PPPCA3nnnnYHbN910kzZv3lzy83Z2durBBx8s+r9bvHix1q1bV/LrA8imcIO6Umfe6OSgvv/++zV58uSSn3e4QQ2gtoUZ1EnscyppzZo1uuyyyzR9+nTdfPPN6u3t1eLFi3XxxRdrypQpWrVqldatW6f29na1tLRo+vTpOnjwoObMmaPcAp4zzzxTt99+u2bOnKm5c+fqpZde0pw5c3TBBRfo8ccflxQF8hVXXKEZM2ZoxowZev755yVJd9xxh5577jlNnz5dq1atUm9vr77xjW8MbLd63333SYr2Irn11ls1efJkLVy4ULt37y7pfQPIOHcv+8/MmTN9sM2bN590X0GNje5RRJ/409gY/znyvP4nP/lJP3z4sLu7f+UrX/FvfetbPnfu3IHHvPfee+7ufuWVV/rLL788cP/xtyX5+vXr3d39uuuu82uvvdYPHz7smzZt8mnTprm7+/79+/3gwYPu7r5161bPXY9nnnnGFy5cOPC89913n69YscLd3Q8dOuQzZ8707du3+8MPP+xz5871o0eP+q5du/yss87ytWvXFnxfALJPUrsXyNRYe32Y2TJJX5Zkkv7Z3b+X3EeHEtnn9KmnnlJHR4cuvfRSSdLBgwe1YMECbd++XbfddpsWLlyoefPmDfk8o0eP1oIFCyRJU6ZM0WmnnaZRo0ZpypQp6uzslCQdOXJEt956qzZt2qQRI0Zo69ateZ9rw4YNeu211wbqz/v27dO2bdu0ceNG3XDDDRoxYoTOO+88XX311cN+3wCyb8igNrOLFYX0ZZIOS3rCzP7T3bcl1qoE9jl1d33+85/Xd77znRPuX7lypZ588kn98Ic/1E9/+lOtXr36lM8zatSogdO/6+rqdNpppw38/ejRo5KkVatW6ZxzztGrr76qvr4+jRkzpmCbfvCDH2j+/Pkn3L9+/XpOGAcwIE6NepKkF939gLsflfQLSYsSbVUC+5xec801Wrdu3UC9d+/evdqxY4f6+vp0/fXXa8WKFXrllVckSePGjdP7778/7Nfat2+fzj33XNXV1enHP/6xent78z7v/Pnzdc899+jIkSOSpK1bt2r//v2aPXu2HnroIfX29urdd9/VM888M+y2AMi+OKWP1yWtNLN6SQclfUJS++AHmdkSSUskqaHUHf4T2Od08uTJ+va3v6158+apr69Po0aN0ne/+10tWrRo4KDbXG978eLFuuWWW3T66afrhRdeKPq1li5dquuvv15r167VVVddNXBgwdSpUzVy5EhNmzZNixcv1rJly9TZ2akZM2bI3TVhwgQ99thjWrRokZ5++mlNmTJFF154oa688sphv28A2Rdrm1Mz+5Kkr0r6QNJmSQfd/WuFHs82p+nhugLVoeRtTt39X9x9hrvPlrRXUnL1aQDACeLO+viwu+82swZJfyHp8mSbBQDIiXsU18P9Neojkr7q7u8N58XcndkMZRSnbAUg++KWPq5w98nuPs3dnxrOC40ZM0Y9PT2ES5m4u3p6egpO/UM2VHCnBGRIaofbTpw4UV1dXeru7k7rJavemDFjNHHixEo3A8OU2ynhwIHodm6nBKl8BzmjOqR2uC2AEzU15V/X1dgo9S9yRQ3hcFsgQAnslIAqRVADFVJoXVip68VQfQhqoEIS2CkBVYqgBiqkpUVqbY1q0mbRn62tDCTiZKnN+gBwspYWghlDo0cNgPncgaNHDdQ45nOHjx41UOOWLz8W0jkHDkT3IwwENVDjmM9dBgnXjghqoMYxn7tEudrRjh3RMdy52lEZw5qgBmoc87lLlELtiKAGahzzuYuQr8SRQu2ITZkAII7B02Ok6KvH6adLPT0nP77I3bXYlAkAijW497xsWf4Sh5R47YigBoDB8g0Q5us1S9LevYnXjih9AMBghTYLz6dMG4hT+gCAYsQdCExpegxBDaC2xFmcUmgSeX19RabHENQAakfcxSmFJpd///tRmaOvL/ozpTmMBDVQQexal7K4i1MCm1zOYCJQIYWm5bLYJEF1dVFPejCzqJdcQQwmAgFi17oKyOjGJgQ1UCHsWlcBGd3YhKAGKiSjnbtsC6z2HBdBDVRIRjt32dfSUpGZG6UgqIEKyWjnDhXAmYlABXEKOeKgRw0AgSOoAdSULC4yovQBoGYMXmSUW0EuhV2CokcNoGZkdZERQQ1gSFksF+ST1UVGBDWAU4q74VwWZHWREUEN4JSyWi7IJ6uLjGIFtZl9zcx+Y2avm9lPzGxM0g0DUJykyhNZLRfkk9VFRkMGtZl9RNJfS2p294sljZD0maQbBiC+JMsTWS0XFJLBFeSxSx8jJZ1uZiMljZX0TnJNAlCsJMsTWS0XpCnpwdYhg9rdd0n6R0k7Jb0raZ+7bxj8ODNbYmbtZtbe3d1d3lYCOKUkyxNZLRekJY3B1iFPeDGzsyU9LOkvJf2vpLWS1rn7mkL/DSe8AOlqaooCYrDGxujrPZJTrmtf6gkvcyX9zt273f2IpEck/Wn8lweQtMTLE9UykToBaQy2xgnqnZJmmdlYMzNJ10jaUr4mAChVouWJappInYA0BltjHW5rZn+vqPRxVNKvJN3k7v9X6PGUPoAqQl3llMp1SHHJh9u6+53u/lF3v9jdP3eqkAaQQacqbVTTROoEpDHYyu55QK0baku5hob8PeqsTqROQNIHQLCEHKh1Q03CrtGJ1CGNnxLUQK0bqrRRgxOpQxs/JagxIKQeBFIUZ9pCFtddlyC0jagIakgKrweBMoj7yVujpY1TCW38lKCGpPB6EBiG44N5/Hjpi1+M98lbg6WNoYS2EVWsedTFYh519tTVRf8/D2YWfdtF4PJN5s2Huc+xlGtudDFKnkeN6hdaDwJFyveVKB/mPscS2pcMghqSKFNmXtwA5pM3tpDGTwlqSAqvB4EixQlgPnkzi6DGgJB6EChSvq9Eo0ZJ9fV88lYBlpAD1SAXwMuXR2WQhoYovAnmqkBQA9Ui6Q0nUDGUPoBKWrpUGjkyKk+MHBndBgahRw1UytKl0j33HLvd23vs9o9+VJk2IUj0qIFKaW0t7n7ULIIaqJTe3uLuR80iqIFKGTGiuPtRswhqoNzi7lqXO0Ul7v2oWQwmAuU01LFWx8sNGLa2RuWOESOixzKQiEHYPQ8oJ07sxjCxex6QltB2nEdVIKgDxJFYGcZ+sUgAQR0YjsTKuJUrdXT0iZsjHR3NrnUoDUEdGI7EyrY2tejL3qpONapPpk416sveqjaxBweGj8HEwHAkVrYxlojhYjAxQyhxVkAZBwUYS0QSCOrAcCRWyso8KMAHLZJAUAeGI7FSVuZBAT5okQRq1KhtCQwKtLVx0AqKd6oaNUvIUdsaGvKP/pVQq+CgFZQbpQ/UNmoVyACCGrWNQQFkAKUPgFoFAkePGgACR1ADQOCGDGozu8jMNh3383sz+5sU2gYAUIwatbu/KWm6JJnZCEm7JD2abLMAADnFlj6ukfRbd88z8RQAkIRig/ozkn6S7xdmtsTM2s2svbu7u/SWAQAkFRHUZjZa0p9LWpvv9+7e6u7N7t48YcKEcrUPAGpeMT3qj0t6xd3/J6nGAABOVkxQ36ACZQ8AQHJiBbWZjZV0raRHkm0OAGCwWEvI3f2ApPqE2wIAyIOViQAQOIIaAAJHUGP4yngoLIDC2OYUxWtrk5Ytk3p6jt2XOxRWYstQoMzoUaM4uVO7jw/pnBIOhQVQGEGN4uQ7tft4O3em1xagRhDUKM5QQVzCobAA8iOocUycwcFTBTGHwgKJIKgRydWed+yQ3I8NDg4O63yndktSfT2HwgIJIagRyVd7zjc4mO/U7jVrpD17CGkgIebuZX/S5uZmb29vL/vzIkF1dVFPejAzqa8v/fYANcbMOty9Od/v6FEjUqj2zOAgUHGZCWoWwSUsX+2ZwUEgCJkI6rjjXChBvtpzgcFBPjSBdGWiRt3UFIXzYI2NUmdn2V4GMeQ+NI8fdxw7lgkfQKkyX6MutMYihEVwtda7jDs5BED5ZCKoQx3nqsWSTMgfmkC1ykRQhzrOVYu9y1A/NIFqlomgLmKcK1W12LsM9UMTqGaZCGopCuXOzmjtRWdn5UNaSqF3GWABPNQPTaCaZSaoQ5RY77KtTRo/XvrsZ4MsgIf4oQlUM4K6BIn0LtmYH8AgBHWJyt67ZGN+lEmAlTMME2cmhoaN+VEGgxcmcaRlttGjDg0b86MManHqaDUjqEPDxvwog1qcOlrNCOrQsDE/yoCFSdWFoA4R899QIhYmVReCGqhCLEyqLgR1qZgDhUDxxax6MD2vFMyBApACetSlYA4UgBQQ1KVgDhSAFBDUpWAOFIAUENSlYA4UgBTECmoz+5CZrTOzN8xsi5ldnnTDMoE5UABSEHfWx/clPeHunzaz0ZLyrHGuUS0tBDOARA0Z1Gb2B5JmS1osSe5+WNLhZJsFAMiJU/q4QFK3pH81s1+Z2f1mdkbC7QIA9IsT1CMlzZB0j7tfImm/pDsGP8jMlphZu5m1d3d3l7mZQHJYXIrQxQnqLkld7v7L/tvrFAX3Cdy91d2b3b15woQJ5WwjkJjc4tIAj6YEBgwZ1O7+35LeNrOL+u+6RtLmRFsFpITFpciCuLM+bpPU1j/jY7ukLyTXJCA9LC5FFsQKanffJKk52aYA6WtoiMod+e4HQpGdlYmM+CABLC5FFmQjqBnxQUJYXIosMHcv+5M2Nzd7e3t7+Z6wqSn/99PGxmhHdADIODPrcPe8JeZs9KgZ8QFQw8IJ6lPVoNlOFEANCyOoh6pBM+IDoIaFEdRDrTpgxAdADQtjMLGuLupJD2YWHaEMAFUu/MFEatAAUFAYQU0NGgAKCiOoqUEDQEFhBLWkNrWoSZ2qU5+a1Kk2EdIAIMXfPS9Rudl5uYkfudl5Ep1qAAiiR82ewABQWBBBzQpxACgsiKBmdh4AFBZEUDM7DwAKCyKomZ0HAIUFMetDikKZYAaAkwXRowYAFEZQA0DgCGoACBxBjWHjYHggHcEMJiJbWPYPpIceNYaFZf9AeghqDAvL/oH0ENQYFpb9A+khqDEsLPsH0kNQY1hY9g+kh1kfGDaW/QPpoEcNAIEjqAEgcAQ1AASOoA4YS7QBSAwmBosl2gBy6FEHiiXaAHJi9ajNrFPS+5J6JR119+YkGwWWaAM4ppjSx1XuviexluAEDQ1RuSPf/QBqC6WPQLFEG0BO3KB2SRvMrMPMluR7gJktMbN2M2vv7u4uXwtrFEu0AeSYuw/9ILPz3P0dM/uwpJ9Jus3dNxZ6fHNzs7e3t5exmQBQ3cyso9D4X6wetbu/0//nbkmPSrqsfM0DAJzKkEFtZmeY2bjc3yXNk/R60g0DAETizPo4R9KjZpZ7/IPu/kSirQIADBgyqN19u6RpKbQFAJAH0/MAIHCxZn0U/aRm3ZLyLNeoCeMl1frCIK4B10DiGkjFXYNGd5+Q7xeJBHUtM7P2Wl9izzXgGkhcA6l814DSBwAEjqAGgMAR1OXXWukGBIBrwDWQuAZSma4BNWoACBw9agAIHEENAIEjqIfJzBaY2Ztm9paZ3ZHn9y1m9lr/z/NmVnWrO4e6Bsc97lIz6zWzT6fZvqTFef9mNsfMNpnZb8zsF2m3MWkx/j84y8z+w8xe7b8GX6hEO5NkZqvNbLeZ5d0DySJ391+j18xsRtEv4u78FPkjaYSk30q6QNJoSa9KmjzoMX8q6ez+v39c0i8r3e60r8Fxj3ta0npJn650u1P+N/AhSZslNfTf/nCl212Ba/C3ku7q//sESXslja5028t8HWZLmiHp9QK//4Sk/5JkkmYNJwvoUQ/PZZLecvft7n5Y0kOSPnX8A9z9eXd/r//mi5ImptzGpA15DfrdJulhSbvTbFwK4rz/v5L0iLvvlAa2Ca4mca6BSxpn0a5uZyoK6qPpNjNZHu3Nv/cUD/mUpH/zyIuSPmRm5xbzGgT18HxE0tvH3e7qv6+QLyn6RK0mQ14DM/uIpEWS7k2xXWmJ82/gQklnm9mz/acj3Zha69IR5xr8k6RJkt6R9GtJy9y9L53mBaPYvDhJMYfb4hjLc1/eeY5mdpWioP6zRFuUvjjX4HuSbnf33v5tcqtJnPc/UtJMSddIOl3SC2b2ortvTbpxKYlzDeZL2iTpakl/JOlnZvacu/8+4baFJHZeFEJQD0+XpD887vZERT2GE5jZVEn3S/q4u/ek1La0xLkGzZIe6g/p8ZI+YWZH3f2xVFqYrDjvv0vSHnffL2m/mW1UtGVwtQR1nGvwBUn/4FGx9i0z+52kj0p6KZ0mBiFWXpwKpY/heVnSH5vZ+WY2WtJnJD1+/APMrEHSI5I+V0U9qOMNeQ3c/Xx3b3L3JknrJC2tkpCWYrx/Sf8u6QozG2lmYyX9iaQtKbczSXGuwU5F3yhkZudIukjS9lRbWXmPS7qxf/bHLEn73P3dYp6AHvUwuPtRM7tV0pOKRr5Xu/tvzOyW/t/fK+nvJNVL+lF/j/KoV9FOYjGvQdWK8/7dfYuZPSHpNUl9ku5396o5xi7mv4EVkh4ws18rKgHc7u5VtfWpmf1E0hxJ482sS9KdkkZJA9dgvaKZH29JOqDoW0Zxr9E/fQQAEChKHwAQOIIaAAJHUANA4AhqAAgcQQ0AgSOoASBwBDUABO7/AXHnjGNFpFY8AAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -456,9 +433,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "经过 100 次更新，我们发现红色的预测结果已经比较好的拟合了蓝色的真实值。\n", - "\n", - "现在你已经学会了你的第一个机器学习模型了，再接再厉，完成下面的小练习。" + "经过 100 次更新，可以发现红色的预测结果已经比较好的拟合了蓝色的真实值。" ] }, { @@ -478,26 +453,19 @@ "\\hat{y} = w_0 + w_1 x + w_2 x^2 + w_3 x^3 \n", "$$\n", "\n", - "这样就能够拟合更加复杂的模型，这就是多项式模型，这里使用了 $x$ 的更高次，同理还有多元回归模型，形式也是一样的，只是出了使用 $x$，还是更多的变量，比如 $y$、$z$ 等等，同时他们的 $loss$ 函数和简单的线性回归模型是一致的。" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n" + "这样就能够拟合更加复杂的模型，这里使用了 $x$ 的更高次，同理还有多元回归模型，形式也是一样的，只是除了使用 $x$，还是更多的变量，比如 $y$、$z$ 等等，同时他们的 $loss$ 函数和简单的线性回归模型是一致的。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "首先我们可以先定义一个需要拟合的目标函数，这个函数是个三次的多项式" + "首先定义一个需要拟合的目标函数，这个函数是个三次的多项式" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -524,7 +492,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "我们可以先画出这个多项式的图像" + "多项式的的曲线绘制" ] }, { @@ -535,7 +503,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 16, @@ -608,7 +576,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "接着我们可以定义需要优化的参数，就是前面这个函数里面的 $w_i$" + "接着定义需要优化的参数，就是前面这个函数里面的 $w_i$" ] }, { @@ -644,7 +612,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 20, @@ -677,7 +645,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "可以发现，这两条曲线之间存在差异，我们计算一下他们之间的误差" + "可以发现，这两条曲线之间存在差异，计算一下他们之间的误差" ] }, { @@ -750,7 +718,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 25, @@ -783,7 +751,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "因为只更新了一次，所以两条曲线之间的差异仍然存在，我们进行 100 次迭代" + "因为只更新了一次，所以两条曲线之间的差异仍然存在，下面进行 100 次迭代" ] }, { @@ -835,7 +803,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 27, @@ -877,11 +845,9 @@ "collapsed": true }, "source": [ - "## 5. 练习题\n", - "\n", - "上面的例子是一个三次的多项式，尝试使用二次的多项式去拟合它，看看最后能做到多好\n", + "## 练习题\n", "\n", - "**提示：参数 `w = torch.randn(2, 1)`，同时重新构建 x 数据集**" + "* 上面的例子是一个三次的多项式，尝试使用二次的多项式去拟合它，看看最后能做到多好\n" ] } ], diff --git a/6_pytorch/4-logistic-regression.ipynb b/6_pytorch/4-logistic-regression.ipynb index eaf2864..f536112 100644 --- a/6_pytorch/4-logistic-regression.ipynb +++ b/6_pytorch/4-logistic-regression.ipynb @@ -4,16 +4,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# 逻辑斯蒂回归模型" + "# 逻辑回归的PyTorch实现" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "上一节课我们学习了简单的线性回归模型，这一节我们会学习第二个模型：逻辑斯蒂回归模型(Logistic Regression)。\n", - "\n", - "逻辑斯蒂回归是一种广义的回归模型，其与多元线性回归有着很多相似之处，模型的形式基本相同，虽然也被称为回归，但是其更多的情况使用在分类问题上，同时又以二分类更为常用。" + "逻辑回归是一种广义的回归模型，其与多元线性回归有着很多相似之处，模型的形式基本相同，虽然也被称为回归，但是其更多的情况使用在分类问题上。" ] }, { @@ -22,60 +20,19 @@ "source": [ "## 1. 模型形式\n", "\n", - "逻辑斯蒂回归的模型形式和线性回归一样，都是 $y = wx + b$，其中 $x$ 可以是一个多维的特征，唯一不同的地方在于逻辑斯蒂回归会对 $y$ 作用一个 logistic 函数，将其变为一种概率的结果。 \n", + "逻辑回归的模型形式和线性回归一样，都是 $y = wx + b$，其中 $x$ 可以是一个多维的特征，唯一不同的地方在于逻辑斯蒂回归会对 $y$ 作用一个 logistic 函数，将其变为一种概率的结果。 \n", "\n", "$$\n", "h_\\theta(x) = g(\\theta^T x) = \\frac{1}{1+e^{-\\theta^T x}}\n", "$$\n", "\n", - "Logistic 函数作为 Logistic 回归的核心，我们下面讲一讲 Logistic 函数，也被称为 Sigmoid 函数。" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 1.1 Sigmoid 函数\n", - "Sigmoid 函数非常简单，其公式如下\n", + "Logistic 函数作为 Logistic 回归的核心，也被称为 Sigmoid 函数。Sigmoid 函数非常简单，其公式如下\n", "\n", "$$\n", "f(x) = \\frac{1}{1 + e^{-x}}\n", "$$\n", "\n", - "Sigmoid 函数的图像如下" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "%matplotlib inline\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "plt.figure()\n", - "plt.axis([-10,10,0,1])\n", - "plt.grid(True)\n", - "X=np.arange(-10,10,0.1)\n", - "y=1/(1+np.e**(-X))\n", - "plt.plot(X,y,'b-')\n", - "plt.title(\"Logistic function\")\n", - "plt.show()" + "![logistic function](imgs/logistic_function.png)" ] }, { @@ -90,78 +47,60 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "另外一个 Logistic 回归的前提是确保你的数据具有非常良好的线性可分性，也就是说，你的数据集能够在一定的维度上被分为两个部分，比如\n", + "### 1.1 损失函数\n", "\n", - "![linear_sep](imgs/linear_sep.png)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "可以看到，上面绿色的点和蓝色的点能够几乎被一个黑色的平面分割开来" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 1.2 损失函数\n", - "前一节对于回归问题，我们有一个 loss 去衡量误差，那么对于分类问题，我们如何去衡量这个误差，并设计 loss 函数呢？\n", + "Logistic 回归使用了 Sigmoid 函数将结果变到 $0 \\sim 1$ 之间，对于任意输入一个数据，经过 Sigmoid 之后的结果我们记为 $\\hat{y}$，表示这个数据点属于第二类的概率，那么其属于第一类的概率就是 $1-\\hat{y}$。\n", + "* 如果这个数据点属于第二类，我们希望 $\\hat{y}$ 越大越好，也就是越靠近 1 越好\n", + "* 如果这个数据属于第一类，那么我们希望 $1-\\hat{y}$ 越大越好，也就是 $\\hat{y}$ 越小越好，越靠近 0 越好\n", "\n", - "Logistic 回归使用了 Sigmoid 函数将结果变到 0 ~ 1 之间，对于任意输入一个数据，经过 Sigmoid 之后的结果我们记为 $\\hat{y}$，表示这个数据点属于第二类的概率，那么其属于第一类的概率就是 $1-\\hat{y}$。如果这个数据点属于第二类，我们希望 $\\hat{y}$ 越大越好，也就是越靠近 1 越好，如果这个数据属于第一类，那么我们希望 $1-\\hat{y}$ 越大越好，也就是 $\\hat{y}$ 越小越好，越靠近 0 越好，所以我们可以这样设计我们的 loss 函数\n", + "所以我们可以这样设计我们的 loss 函数\n", "\n", "$$\n", - "loss = -(y * log(\\hat{y}) + (1 - y) * log(1 - \\hat{y}))\n", + "loss = - \\left[ y * log(\\hat{y}) + (1 - y) * log(1 - \\hat{y}) \\right]\n", "$$\n", "\n", - "其中 y 表示真实的 label，只能取 {0, 1} 这两个值，因为 $\\hat{y}$ 表示经过 Logistic 回归预测之后的结果，是一个 0 ~ 1 之间的小数。如果 y 是 0，表示该数据属于第一类，我们希望 $\\hat{y}$ 越小越好，上面的 loss 函数变为\n", + "其中 $y$ 表示真实的 label，只能取 {0, 1} 这两个值，因为 $\\hat{y}$ 表示经过 Logistic 回归预测之后的结果，是一个 $0 \\sim 1$ 之间的小数。\n", "\n", + "* 如果 $y$ 是 0，表示该数据属于第一类，我们希望 $\\hat{y}$ 越小越好，上面的 loss 函数变为\n", "$$\n", - "loss = - (log(1 - \\hat{y}))\n", + "loss = - \\left[ log(1 - \\hat{y}) \\right]\n", "$$\n", - "\n", "在训练模型的时候我们希望最小化 loss 函数，根据 log 函数的单调性，也就是最小化 $\\hat{y}$，与我们的要求是一致的。\n", "\n", - "而如果 y 是 1，表示该数据属于第二类，我们希望 $\\hat{y}$ 越大越好，同时上面的 loss 函数变为\n", - "\n", + "* 而如果 $y$ 是 1，表示该数据属于第二类，我们希望 $\\hat{y}$ 越大越好，同时上面的 loss 函数变为\n", "$$\n", - "loss = -(log(\\hat{y}))\n", + "loss = - \\left[ log(\\hat{y}) \\right]\n", "$$\n", - "\n", - "我们希望最小化 loss 函数也就是最大化 $\\hat{y}$，这也与我们的要求一致。\n", - "\n", - "所以通过上面的论述，说明了这么构建 loss 函数是合理的。" + "希望最小化 loss 函数也就是最大化 $\\hat{y}$，这也与要求一致。\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### 1.3 程序示例\n", + "### 1.2 程序示例\n", "\n", - "下面我们通过例子来具体学习 Logistic 回归" + "下面通过例子来学习如何使用PyTorch实现 Logistic 回归" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 12, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import torch\n", - "from torch.autograd import Variable\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", @@ -174,27 +113,27 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "我们从 `data.txt` 读入数据。读入数据点之后我们根据不同的 label 将数据点分为了红色和蓝色，并且画图展示出来了" + "从 `data.txt` 读入数据，读入数据点之后我们根据不同的 label 将数据点分为了红色和蓝色，并且画图展示出来了" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 13, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -233,23 +172,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "接下来我们将数据转换成 NumPy 的类型，接着转换到 Tensor 为之后的训练做准备" + "接下来将数据转换成 NumPy 的类型，并转换到 Tensor 为之后的训练做准备" ] }, { "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": true - }, + "execution_count": 3, + "metadata": {}, "outputs": [], "source": [ "np_data = np.array(data, dtype='float32') # 转换成 numpy array\n", "x_data = torch.from_numpy(np_data[:, 0:2]) # 转换成 Tensor, 大小是 [100, 2]\n", - "y_data = torch.from_numpy(np_data[:, 2]).unsqueeze(1)\n", - "\n", - "x_data = Variable(x_data)\n", - "y_data = Variable(y_data)" + "y_data = torch.from_numpy(np_data[:, 2]).unsqueeze(1)" ] }, { @@ -261,15 +195,13 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": { - "collapsed": true - }, + "execution_count": 6, + "metadata": {}, "outputs": [], "source": [ "# 定义 logistic 回归模型\n", - "w = Variable(torch.randn(2, 1), requires_grad=True) \n", - "b = Variable(torch.zeros(1), requires_grad=True)\n", + "w = torch.randn((2, 1), dtype=torch.float, requires_grad=True) \n", + "b = torch.zeros(1, dtype=torch.float, requires_grad=True)\n", "\n", "def logistic_regression(x):\n", " return torch.sigmoid(torch.mm(x, w) + b)" @@ -284,22 +216,22 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 16, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -329,7 +261,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "可以看到分类效果基本是混乱的，我们来计算一下 loss，公式如下\n", + "可以看到分类效果不好，计算 loss，公式如下\n", "\n", "$$\n", "loss = -\\{ y * log(\\hat{y}) + (1 - y) * log(1 - \\hat{y}) \\}\n", @@ -338,16 +270,14 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": { - "collapsed": true - }, + "execution_count": 8, + "metadata": {}, "outputs": [], "source": [ "# 计算loss, 使用clamp的目的是防止数据过小而对结果产生较大影响。\n", "def binary_loss(y_pred, y):\n", - " logits = (y * y_pred.clamp(1e-12).log() + \\\n", - " (1 - y) * (1 - y_pred).clamp(1e-12).log()).mean()\n", + " logits = ( y * y_pred.clamp(1e-12).log() + \\\n", + " (1 - y) * (1 - y_pred).clamp(1e-12).log() ).mean()\n", " return -logits" ] }, @@ -355,19 +285,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "注意到其中使用 `.clamp`，这是[文档](http://pytorch.org/docs/0.3.0/torch.html?highlight=clamp#torch.clamp)的内容，查看一下，并且思考一下这里是否一定要使用这个函数，如果不使用会出现什么样的结果。" + "注意到其中使用 `.clamp`，可以查看[函数使用说明文档](https://pytorch.org/docs/stable/generated/torch.clamp.html?highlight=clamp#torch.clamp)，并且思考一下这里是否一定要使用这个函数，如果不使用会出现什么样的结果。" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "tensor(0.7655, grad_fn=)\n" + "tensor(0.7655, grad_fn=)\n" ] } ], @@ -382,26 +312,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "得到 loss 之后，我们还是使用梯度下降法更新参数，这里可以使用自动求导来直接得到参数的导数，感兴趣的同学可以去手动推导一下导数的公式" + "得到 loss 之后，使用梯度下降法更新参数，这里可以使用自动求导来直接得到参数的导数" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 11, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "During Time: 0.306 s\n" - ] - } - ], + "outputs": [], "source": [ - "start = time.time()\n", - "\n", "# 自动求导并更新参数\n", "for i in range(1000):\n", " # 算出一次更新之后的loss\n", @@ -415,31 +334,27 @@ "\n", " # clear w,b grad\n", " w.grad.data.zero_()\n", - " b.grad.data.zero_()\n", - " \n", - "during = time.time() - start\n", - "print()\n", - "print('During Time: {:.3f} s'.format(during))" + " b.grad.data.zero_()\n" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 26, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -469,59 +384,59 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 1.4 torch.optim\n", - "上面的参数更新方式其实是繁琐的重复操作，如果我们的参数很多，比如有 100 个，那么我们需要写 100 行来更新参数，为了方便，我们可以写成一个函数来更新，其实 PyTorch 已经为我们封装了一个函数来做这件事，这就是 PyTorch 中的优化器 `torch.optim`\n", - "\n", - "使用 `torch.optim` 需要另外一个数据类型，就是 `nn.Parameter`，这个本质上和 Variable 是一样的，只不过 `nn.Parameter` 默认是要求梯度的，而 Variable 默认是不求梯度的\n", + "## 2. torch.optim\n", "\n", - "使用 `torch.optim.SGD` 可以使用梯度下降法来更新参数，PyTorch 中的优化器有更多的优化算法，在本章后面的课程我们会更加详细的介绍\n", - "\n", - "将参数 w 和 b 放到 `torch.optim.SGD` 中之后，说明一下学习率的大小，就可以使用 `optimizer.step()` 来更新参数了，比如下面我们将参数传入优化器，学习率设置为 1.0" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# 使用 torch.optim 更新参数\n", - "from torch import nn\n", + "上面的参数更新方式较为繁琐、重复，如果模型参数很多，比如有 100 个，那么需要写 100 行来更新参数。为了方便，可以写成一个函数来更新，其实 PyTorch 已经封装了一个函数来做这件事，这就是 PyTorch 中的优化器 `torch.optim`\n", "\n", - "w = nn.Parameter(torch.randn(2, 1))\n", - "b = nn.Parameter(torch.zeros(1))\n", + "使用 `torch.optim` 需要另外一个数据类型，就是 `nn.Parameter`，默认是要求梯度的，而 tensor 默认是不求梯度的\n", "\n", - "def logistic_regression(x):\n", - " return torch.sigmoid(torch.mm(x, w) + b)\n", + "使用 `torch.optim.SGD` 可以使用梯度下降法来更新参数，PyTorch 中的优化器有更多的优化算法，后面的课程会更加详细的介绍几种常见的优化器。\n", "\n", - "optimizer = torch.optim.SGD([w, b], lr=1.)" + "将参数 $w$ 和 $b$ 放到 `torch.optim.SGD` 中之后，声明一下学习率的大小，就可以使用 `optimizer.step()` 来更新参数了" ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "epoch: 200, Loss: 0.24529, Acc: 0.89000\n", - "epoch: 400, Loss: 0.23901, Acc: 0.89000\n", - "epoch: 600, Loss: 0.23409, Acc: 0.89000\n", - "epoch: 800, Loss: 0.23013, Acc: 0.89000\n", - "epoch: 1000, Loss: 0.22689, Acc: 0.89000\n", + "epoch: 200, Loss: 0.58470, Acc: 0.62000\n", + "epoch: 400, Loss: 0.54856, Acc: 0.66000\n", + "epoch: 600, Loss: 0.51801, Acc: 0.75000\n", + "epoch: 800, Loss: 0.49200, Acc: 0.78000\n", + "epoch: 1000, Loss: 0.46968, Acc: 0.84000\n", "\n", - "During Time: 0.352 s\n" + "During Time: 0.480 s\n" ] } ], "source": [ - "# 进行 1000 次更新\n", + "# 使用 torch.optim 更新参数\n", + "from torch import nn\n", "import time\n", "\n", + "# 定义优化参数\n", + "w = nn.Parameter(torch.randn(2, 1))\n", + "b = nn.Parameter(torch.zeros(1))\n", + "\n", + "# Logistic函数\n", + "def logistic_regression(x):\n", + " return torch.sigmoid(torch.mm(x, w) + b)\n", + "\n", + "# 计算loss, 使用clamp的目的是防止数据过小而对结果产生较大影响。\n", + "def binary_loss(y_pred, y):\n", + " logits = (y * y_pred.clamp(1e-12).log() + \\\n", + " (1 - y) * (1 - y_pred).clamp(1e-12).log()).mean()\n", + " return -logits\n", + "\n", + "# 优化器\n", + "optimizer = torch.optim.SGD([w, b], lr=0.1)\n", + "\n", + "# 进行 1000 次更新\n", "start = time.time()\n", "for e in range(1000):\n", " # 前向传播\n", @@ -538,45 +453,44 @@ " acc = (mask == y_data).sum().item() / y_data.shape[0]\n", " if (e + 1) % 200 == 0:\n", " print('epoch: {}, Loss: {:.5f}, Acc: {:.5f}'.format(e+1, loss.item(), acc))\n", - "during = time.time() - start\n", - "print()\n", - "print('During Time: {:.3f} s'.format(during))" + "\n", + " during = time.time() - start\n", + "\n", + "print('\\nDuring Time: {:.3f} s'.format(during))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "可以看到使用优化器之后更新参数非常简单，只需要在自动求导之前使用**`optimizer.zero_grad()`** 来归 0 梯度，然后使用 **`optimizer.step()`**来更新参数就可以了，非常简便\n", - "\n", - "同时经过了 1000 次更新，loss 也降得比较低了" + "可以看到使用优化器之后更新参数非常简单，只需要在自动求导之前使用**`optimizer.zero_grad()`** 来归 0 梯度，然后使用 **`optimizer.step()`** 来更新参数就可以了，非常方便" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "下面我们画出更新之后的结果" + "下面画出更新之后的结果" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 33, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAzFElEQVR4nO3dd3wU1fr48c9JSOgIBBSvoYhfvJogNdgQURRF4WIDlQsKIl1Frz9REK83UhRQ77XQlN4UARsqitIEpEiA0IINBaUICIpUU/b5/bGJhpBNdpOZnZnN83699pXs7uycZ2dnnz1z5sw5RkRQSinlfVFOB6CUUsoamtCVUipCaEJXSqkIoQldKaUihCZ0pZSKEKWcKrhatWpSp04dp4pXSilPWr9+/S8iUj2/5xxL6HXq1CElJcWp4pVSypOMMbsCPadNLkopFSE0oSulVITQhK6UUhFCE7pSSkUITehKKRUhNKErpVSE0ISulFIRwnMJ/atfvuKpJU/xR+YfToeilFKu4rmE/sHXHzB8xXAav9aYtbvXOh2OUkq5hucS+oDmA/i488ccSz/GlZOv5LFPH+NExgmnw1JKKcd5LqEDtPm/Nmztt5WeTXry4uoXaTi+ISt2rXA6LKWUcpQnEzpApdKVGN9uPIvvXUyWL4urp17NQwse4lj6MadDU0opR3g2oedodX4rNvfdTP9L+zNm3RguGXcJi75f5HRYSikVdp5P6AAVYivw8k0vs/y+5cRGx9J6Rmt6fdCLI6eOOB2aUkqFTUQk9BxX1bqK1N6pDLhyAJM2TqL+uPp8/O3HToellFJhEVEJHaBsTFlGtR7F6vtXU6l0JW5+42a6vteVwycPOx2aUkrZKuISeo5Lz7uUDb02MLjFYGZtnkXi2ETe++o9p8NSSinbRGxCByhdqjTDWg1jXc91nFP+HG576zbunnc3B48fdDo0pZSyXEQn9ByNz23Mup7rGHbtMN7Z/g4JYxN4a+tbiIjToSmllGVKREIHiImOYfDVg9nYeyPnVz6fu9++mzvm3MHPx352OjSllLJEoQndGDPZGHPAGLM1wPPGGPOKMeY7Y8xmY0wT68O0TuLZiay6fxUjrx/Jgm8XkDAmgRmbZjhXW581C+rUgago/99Zs5yJQynlecHU0KcCbQp4/iagXvatFzCu+GHZq1RUKR5v/jib+mzi4uoXc+9799LuzXbs/n13eAOZNQt69YJdu0DE/7dXL03qSqkiKTShi8hyoKA+f7cA08VvDVDZGHOuVQHa6e/V/s7ybst5uc3LLNu5jMSxiUxYPyF8tfXBg+FEnoHFTpzwP66UUiGyog39POCnXPd3Zz92BmNML2NMijEm5eBBd/Q0iY6Kpv9l/dncZzNNzm1Crw970XpGa3b+ttP+wn/8MbTHVYmjLXIqFGE9KSoir4tIkogkVa9ePZxFF+qCqhew+N7FjGs7jrV71lJ/bH3GfDkGn/jsK7RWrdAeLyJNCt6kLXIqVFYk9D1AzVz347Mf85woE0WfpD5s67eN5rWa8+DHD3LN1Gv49tC39hQ4fDiUK3f6Y+XK+R+3iCYFa4Xzx1Fb5FTIRKTQG1AH2BrgubbAx4ABLge+DGadTZs2FTfz+XwyacMkOeu5s6TssLLy4qoXJTMr0/qCZs4UqV1bxBj/35kzLV197doi/lR++q12bUuLiVi5P564OJHY2NO3Y7lyln9kfzIm/8/OGHvKK4zNu6oKEpAigXJ1oCf+XADeBPYBGfjbx+8H+gB9sp83wBhgB7AFSCpsneKBhJ5jz+975B9v/ENIRi6bcJlsO7DN6ZBC4rak4CUzZ/oTdn7bLxw/jqH+GNuZcPPbFnb+mKnAipXQ7bp5JaGL+Gvrb2x+Q+JGxkns0Fh5dvmzkpGVEfqKHKjiaA296AJtu3D9OIaSRO1OuLofuYcmdIvsP7ZfOs7pKCQjTV9rKpt+3hT8ix2q4mjNqugCHd2EM6kFWwewO+HqkZ57aEK32Lxt8+Ts58+WmCExkrw0Wf7I/KPwFzlYxdG2z6IJpobulh9HuxOu1tDdo6CEXmLGcrHSHQl3kNYvjTsT7yT582SSXk9i/d71Bb/IwT7nnTvDzp3g8/n/du5se5ERIb9OSDExEBcHxkDt2vD66+7Ynnb3gA1DhyxlAU3oRRRXLo6Zt89k/t3zOXTyEJdNvIwnFz/JqcxT+b8gTH3OlXU6d/Yn7Nq1/0rgU6bAL7+478fR7oSb37Zwy4+ZyiVQ1d3um5ebXPL69eSv0v297kIyctHoi2TVj6vOXEgbs5XNtGmtZECbXOxVuUxlJt0yiYVdFnIi4wTNJzfn0YWPciIj11UhWsVRFgl0cZM2rSnjT/jhl5SUJCkpKY6UbaejfxzliUVPMC5lHBdUuYBJ7SfRsk5Lp8NSESLnyt/cV5CWK6d1g5LEGLNeRJLye05r6BarWLoiY9uOZWnXpQjCNdOu4YGPHuBY+jGnQ1MRwI3DAehYQe6hCd0m19S5hs19NvPIZY8wLmUc9cfW57MdnzkdlvI4tw3QqWMFuYsmdBuVjy3P/9r8j5XdV1KmVBlumHkDPef35MipI06HpjzKbZ2l3HjEUJJpQg+DK2teSWqfVJ5o/gSTUyeTODaRj775yOmwlAe5rT+4244YSjpN6GFSplQZRlw/gjX3r6FK2Sq0e7Md97x7D4dPFjQZlFKns7KzlBVt31Wrhva4spf2cnFAelY6w5cP59mVzxJXNo6xbcdy+8W3Ox2WKkGs6i1TrRocOnTm43Fx/guwlPW0l4vLxEbH8sy1z7Cu5zr+VvFv3DHnDu6adxcHjh9wOjQV4XJq5V26WNP2fTjAAWagx5W9NKE7qFGNRqztsZbhrYbz3lfvkTg2kdlbZ+PUUZNXaDe5osndIyWQUNu+3XaStqTThO6wmOgYnmzxJBt6baBulbp0ersTt711G3uP7nU6NFfSbnJFl1+PlLxCTcRuO0lbmIivDAQaE8DuWySN5WKVzKxMeeGLF6TMsDJSeURlmbJxivh8PqfDClo4xhLRYVyLrrDx3Ys6tJBXxpCJlOGU0PHQveXrX76WFpNbCMlIm5ltZNdvu5wOqVDh+rLoRAtFV9D47m5OxFaJlMpAQQldm1xc6MK4C1nWbRmv3vQqK3atoP7Y+ryW8pqr29bDdYGJttkWXaDmkb59/f/fc0/kNUPkbmIJdO4govrMB8r0dt+0hh6c7w9/L62mtRKSkVbTWsmOwzssXb9Vh8vhqjlHymGzU/J+3n37Ru72dHqSb7ugTS7e5vP55PWU16XisxWl3PBy8vKalyXLl1Xs9VqZHMN5OOuVNlsviJRmiPw4MYVgOPZNTegR4sfffpSbZt4kJCPNJzWXr3/5uljrs/LLHEk155L0gxHJ5yQKOglsx2cbru+AJvQI4vP5ZOrGqVJ5RGUpM6yMjFo5SjKzMou0Lqu/zJGQCJ3+YQrnNpw5UyQ6uuTV0O16b+EqTxN6BNr7+1655c1bhGTk0gmXytb9W0NeRyQfbheVk9sknD8mBbUve/XIKq9w/ziH62hHE3qE8vl8MnvLbKk2qprEDo2VYZ8Pk/TM9KBf73Rt1I2cbIKw+8ckd+0/UM08OjqyPv9wHvFoDV1Z4sCxA3LX3LuEZKTx+Maycd/GoF8bCc0kVnKyhm7nj0mwPT4ioe3cKW5oQ9d+6BGgevnqzO4wm3fufIe9R/fSbEIznl76NH9k/lHoa3Vi4dM5eSm7nX3sg7ns36qySipXzAMfKNPbfdMauj0OnTgk9757r5CMJI5JlC93f+l0SJ7j1FGLnTW8wi771+Y270Br6CVH1bJVmXbrND7650f8duo3Lp90OU989gQnM046HZpnOHXUYmcNL1DNOzrawdqkspxOcBHBjpw6wmOfPsbEjRO5MO5CJrefTPNazZ0OSznAqgktlPN0gosS6qwyZzGh/QQ+u+cz/sj8gxZTWvDIJ49wPP2406GpMHNF+66yndbQS4hj6ccYuGggY9aNoW6Vukz8x0SuPf9ap8NSSoVIa+iKCrEVGH3zaJZ1XYbB0Gp6K/p+2Jejfxx1OjSllEU0oZcwLeu0ZHPfzTx6+aO8tv416o+rz8LvFjodVsSI+BlxlKtpQi+BysWU48UbX+SL7l9QLqYcbWa1ofv73fn15K9Oh+ZpOj2ecpom9BLsippXsLH3RgZdNYjpm6aTODaRD77+wOmwPCtck3woFYgm9BKuTKkyPHvds6ztsZZq5arRfnZ7Or/TmUMnDjkdmucEmvkmombEUa6mCV0B0PRvTUnplUJyy2TmbJtDwtgE5qXNczosT9Hp8ZTTgkroxpg2xpivjTHfGWMG5vN8LWPMUmPMRmPMZmPMzdaHqmyR6yxe7AUX8p89/8f6XuupWakmHed2pOPcjuw/tt/pKD3ByXFglIIgEroxJhoYA9wEJACdjDEJeRZ7CpgjIo2Bu4GxVgeqbBDgLF6DRVtY02MNz133HPO/nk/C2ARmbZ6FU9cseIVTF+9ozxqVI5ga+qXAdyLyvYikA7OBW/IsI0Cl7P/PAvZaF2IJEu5vZgFn8UpFlWLgVQNJ7Z3KhXEX0uXdLtwy+xb2/L7H3pg8bNYs/yb98Ud/M8vw4eFJ5tqzRv0p0KhdOTegAzAx1/17gNF5ljkX2ALsBn4FmgZYVy8gBUipVauW/cOSeYkTs00EOQB3ZlamvLjqRSk7rKyc9dxZMmnDJPH5fPbF5UFOTRais06VPIRhtMVOwFQRiQduBmYYY85Yt4i8LiJJIpJUvXp1i4qOEE70eQvyLF50VDSPXvEom/psomGNhtw//37azGrDrt922RebxzjVZVF71tjDq81YwST0PUDNXPfjsx/L7X5gDoCIrAbKANWsCLDEcOKbGeJZvHpx9VjadSljbh7DFz9+Qf1x9Rm3bhw+8dkXo0c4lVi1Z431vNyMFUxCXwfUM8acb4yJxX/Sc36eZX4ErgMwxlyMP6EftDLQiOfEN7MIZ/GiTBT9mvVja7+tXBF/Bf0W9OO66dex4/AO++L0AKcSqxd61nittuvpC8QCtcXkvuFvRvkG2AEMzn5sCNA++/8E4AtgE5AK3FDYOnXGojysboQNw7Q7Pp9PJq6fKJWeqyTlhpeTl1a/JJlZmW4LMyxlOznhtpvnhfXiROROThQeDHSSaI+w6psZ5m/RT0d+kptn3SwkI1dOulK2H9zuxjBtL9vNidUpXjxp6/aYNaG7ndWZwIE90ufzyfTU6VJlRBUpPbS0jFgxQjKyMtwWpivK9rJQd1W313bz4/ajCk3obmbH3uPgt2jf0X1y+1u3C8lI0utJsmX/FjeG6clE47Si7Kpe/eF089GWJnQ3s2OPd/hb5PP5ZM7WOVJ9VHWJGRIjQ5YNkfTMdFeF6dVE46RA2yw6OnDic3tt14s0obuZHVVFl3yLDhw7IJ3mdRKSkYbjGsqGvRtcE6ZLNpGnBNpVC9uGbq7tepEmdDezq6room/Re9vfkxov1JDoZ6Jl8OLBcirjlCvCdNEm8oRAu6oe5YSXJnQ3K6yqGCFZ5/CJw9L13a5CMpIwJkHW7l7rdEgFyr3Z4+L8N49/BMWW366q5yHCTxO62wVK2hHYLrDgmwUS/994iXomSgZ8OkBOpJ9wOqQzFJa4PP4RFEvuXTU6WmvoobKifqYJ3asi9MzdkVNHpPcHvYVkpN4r9WTFrhVOh3SaYJoWPP4RWCIC6xu2smp7FZTQdcYiN4vQkZcqla7E+HbjWXTPIjJ8GVw95Wr6f9yf4+nHnQ4NCG7zevwjsIRT4797VTiGFNCE7mZWDRDi0sE0rqt7HVv6buGhSx9i9JejuWTcJSz5YYnTYQW1eXXwK7/OnWHnTvD5/H81mQcWjvqZJnQ3s2LkJZcPHVchtgIv3/Qyy+9bTqmoUlw3/Tp6f9Cb3//43bGY8tvsublt8CvlDWEZwC1QW4zdN21DD1Jxz6J4qB3+RPoJeWzhYxL1TJTE/zdePv72Y8diKcm9XCKkY5XrhKMNXRN6pPPgNe5rflojCWMShGSk23vd5PCJw06HdBovJrxgY/bqiU6vfCbay0UVj4dq6LlNnZ4ulc4+LJAlUZV/lH+NWud0SCLizYQXSsxe3F28+JkUhyb0ksyDe3u+/cBjjsnl/V+Rg8cPOhqbFxNeKDEXdHm/W2u+XvxMiqOghK4nRSOdB/uW5de9i4zyrJnWnoQxCczZNsdfG3GAF3uShhJzQSfoXHY+/U9u+UwK6kwWto5mgTK93TetoatAAjf7+yTp9SQhGbn9rdtl39F9YY/Ni7XBUGIO5vJ+t71XN3wmBR0IW32QjDa5KC8p6AuakZUhI1eOlNJDS0uVEVVkeup08fl8YYvNgy1YIcecc+IuUEJ32/l0N3wmBe2zVv/gaEJXnhLMF/Srg1/JlZOuFJKRtrPayk9HfgprfF7oUZFbUWJ2Q803WE5/JgV1JrO6o5kmdOU5wXxBM7My5aXVL0nZYWWl0nOVZML6CWGtrUc6N9R8vUJr6JrQvcPp6k8hvjv0nVwz9RohGbl++vXyw68/OB1S0Fy+aV0fn1toG7omdG/wSDUty5cl49aNkwrPVpDyw8vL6LWjJcuX5XRYBfLIplVBKujHz8ofRk3oqui81JAqIjt/3Sk3zLhBSEaunnK1fHvoW6dDCshjm9YzrEqebj06KSihG//z4ZeUlCQpKSmOlK1CEBXlzzN5GeMfYs+FRISpqVP518J/kZ6VzvBWw+l/WX+io6KdDu00Hty0rpczFl3u6xjKlQv90gur1mMHY8x6EUnK7zm9sCiS2HH1QliGiCu+3G/9/PMNsWn3kfZAGtfXvZ5HP32Uq6ZcxfaD250O8zQe2bSeYtWY4+EYu9wWgarudt+0ycVidjXIeqCht6AQfT6fzNo8S6qOrCqxQ2Pl2eXPSkZWhtMhi4gnNq3nWNVF0M1j2qFt6CWAnQ2ybm1MzBbMW//56M/SYU4HIRlp+lpT2fTzJqfCPY3LN63nWPU1cPP5jYISurahR4oS3CAbyluflzaPfh/147dTvzG4xWAGtRhEbHRseAJVttM2dBUZIq1BNoTzAaG89Q4JHUh7II2OiR1J/jyZpNeTWL93vSUhK+dZNRadB8e08wtUdbf7pk0uFoukBtkQ30tR3/r7X70v575wrkQ/Ey2DFg2SkxknbXgzSlkLbUMvISKlQbYIDZhFfeu/nvxV7nvvPiEZuWj0RbLqx1UWvAGl7FNQQtc2dOU+DpwPWPjdQnp+0JPdv+/mX5f/i6GthlIupoCZopVyiLahK29x4HzAjf93I1v7baVPUh/+u+a/NBjXgM93fm5beUrZQRO6cp/hw/1dCnIrV87/uI0qla7E2LZjWXLvEgThmmnX8OCCBzmWfszyssI2g41yhXB93prQlfvkdDGIi/vrsbJlw1b8tedfy+Y+m3n4socZu24s9cfWZ9H3iyxbf06XuF27/C1Lbp3aTVkjnJ+3JnQ30Wrb6U6e/Ov/Q4fCmvXKx5bnpTYvseK+FZQuVZrWM1rTc35Pjpw6Uux1e/ayclUkYf28A50ttfumvVzyiKRuhwUJtjuKiy7VO5F+Qh7/9HGJeiZKznvxPPnw6w+LtT43X1aurBfOGYuCqqEbY9oYY742xnxnjBkYYJk7jTFpxphtxpg3LP3VKQlKQrUtlGNPC6dyL+6BT9mYsoxsPZI196+hcpnKtHuzHfe+ey+HTx4OORaIvGvAVMHC+nkHyvQ5NyAa2AHUBWKBTUBCnmXqARuBKtn3zy5svVpDz6MkVNtCqXVbVEO3+sDnVMYpeXrJ01JqSCk55/lz5J20d0JeR0k5GFN+rpqxCLgCWJjr/iBgUJ5lRgE9CltX7psm9Dxc1MRgm1B+tCz6Fti1WTfu2yiNxzcWkpE7594p+4/tD+n1kXINmAqOa2YsAjoAE3PdvwcYnWeZ97KT+hfAGqBNgHX1AlKAlFq1ahX9HUWiklBtCzW7WvAtsPPAJz0zXYZ9Pkxih8ZKtVHV5M0tb+ok1cp2BSV0q3q5lMpudrkG6ARMMMZUzruQiLwuIkkiklS9enWLio4Qnh0NKASh9i/v3Bl27vRfHbpzZ5G2hZ3tlzHRMQy+ejAbem2gbpW6dHq7E7e9dRv7ju4r/sqVKoJgEvoeoGau+/HZj+W2G5gvIhki8gPwDf4Er0JhQQJzNQd+tMJxjVLi2Yl80f0Lnm/9PAt3LCRhbALTUqflHJWqEGnv3WIIVHWXv5pJSgHfA+fz10nRxDzLtAGmZf9fDfgJiCtovdqGrsIlnO3VX//ytVw1+SohGblp5k3y428/2ldYBCoJLY/FRXGaXEQkE3gQWAhsB+aIyDZjzBBjTPvsxRYCh4wxacBSYICIHLLsV0e5g0erTuE88Lkw7kI+7/Y5r7R5hc93fU7i2EReX/+61tbzkd/uVBJ679pJR1tUwXHzFC4u9f2v39Pzg54s+WEJrc5vxYR/TKBulbpOh+UKgXanvMk8RwmYeCtoBY22qAldBadOHf+FQHnVru2v9qp8iQgTNkzgsU8fI0uyGHHdCB649AGiTMkedSPQ7hQdDVlZZz6uu9lfdPhcVXwWXrlZkhhj6NW0F9v6bePq2lfT/5P+tJzakm8OfeN0aI4KtNtkZTky0GbE0ISugqPXqxdLzbNqsuCfC5h6y1S2HthKw/ENeWHVC2T58qmOlgCBdpucjk+R3HvXTprQVXAcGqM8khhj6NqoK2n90rjxghsZ8NkArpx8JWkH05wOLewK2p0ivfeunTShq+CUhAufwuTciufy7l3v8uYdb7Lj8A4av9aY4cuHk5GV4XRoYaO7kz30pKhSDjpw/AAPffwQc7bNoXGNxky5ZQoNazR0OizlYnpSVCmXOrv82bzV4S3evvNt9h7dS9KEJP6z9D9Mm5HpxS7/ymGlnA5AKQW3X3w7LWu35JGFjzBk9LeYDzOQdP/XM2fYeNAmCVUwraGr8LDjKlMnrly1scy4cnHMuG0G1ddMRNJPn0NVr5ZUwdAaurJf3ssCrahy2rFOl5T5y75y+T6uXf5VYfSkqLKfHVeZOnHlapjKDFRMxbMPs++n0pSPLW9ZWcp79KSocpYdV5k6ceVqmMrMr492qdJ/cPSqB2kwvgHLdi6ztDwVOTShK/vZcZWpE1euVq0aljLz66M9dVJplr3YG4Ph2mnX0u+jfhz946il5Srv04Su7BfossCbby76CcZwX7k6axb8/vuZj8fG2lJmfldLtqzTks19N/Po5Y8yPmU89cfV59Mdn1petvKwQAOl232LuAkudNbfguXdPn37Fn8mg3Bu80DzocbF2VdmAVb9uEouGn2RkIx0f6+7/HryV0fiUOFHARNc6ElRK+hY4aHz2nC8UVH+FJ6XgwN1n8o8xTPLnuH5Vc9zToVzGN92PP/4+z8ciUWFj54UtZtOsxK6QCcS80vybuDC0SbLlCrDc9c/x5oea4grG0f72e3p8k4XDp3QycJKKk3oVtCxwkMXKBEa487r3F082mTS35JI6ZVCcstk3tr2FgljE3g77W2nwwrIozMZeoImdCu4sPbmesOH+5N3XiLuPLJx+fCAsdGx/Oea/7C+13riK8XTYW4HOs7tyIHjB5wO7TQ5rZO7dvk/6pxrszSpWyRQ47rdt4g6KapTlRdNficZwX+SUxVZRlaGPLv8WYkdGitxI+Nk1uZZ4vP5gn69neeaA51brl3bujIiHQWcFNUauhXsqL2VhOPS2rXzfzwqKrLft81KRZViUItBpPZOpV5cPTq/05lb37qVvUf3Fvpau2vQ2jpps0CZ3u5bRNXQrVZSavz5vc+8t0h83/mxqVqcmZUpL656UcoMKyNnPXeWTN4wWWbO9AUsyu4atNbQi48Cauia0N2oJO31uRNZdHTJed+5heEH/JtfvpGrp1wt3N5JomJPBizKGHtbwUpKXcVOmtC9xu5vlRvNnBm4lh7J71skbD/gWb4sqVLjSIFFhSMUr12D57Z4C0ro2obuRiWt10xOw20gkfq+c4SpYTnKRPHb/koFFhWO3pnhmATaqlNQnuuVEyjT233TGnoBStpxaaBqYaS/7xxhbGILVFSVGkckMytTREKvkbqtBmvl18eNrZ9ok4sH5DfWiZu+JXYK1MQEkf2+c4TxBzy/oqJiTwq3d5IrJ10pXx38yq2hB83KJOzG1k9N6OFS1KqKG78V4eTGalC4hbGae2ZRPpmeOl2qjKgipYeWlpErR0pGVkZQ63LjR2dlEnbj+9OEHg7FScpu3GvCqaT/oLnE3t/3yq2zbxWSkWavN5Mt+7cU+horkqfVv2WBvk7R0aGv2427pib0cAg2Kee397rxuC7c3NYQW0L5fD6ZvWW2VBtVTWKGxMjQz4dKemZ6wOWLWxexI2EWdHlDUdbttl1TE3o4BJOUA+29cXElu4buRuH6FrstW2Q7cOyA3DX3LiEZaTS+kWzYuyHf5YJKyAW8R7sOTmfOjNzLGjShh0Mwe2ZBkyS47biuJAvXcbYbj+fzeHf7u1LjhRoS/Uy0DF48WE5lnDpjmQJ/kwp5j3YenEbqga8m9HAI5stZ0B7m0ppaiRSucxoeOXdy6MQh6fpuVyEZSRiTIGt3rw3+xYW8Rzs3gUc2b8g0oYdLYUk5UvewSBOuqp0TVchiVBw++uYjif9vvEQ9EyUDPh0gJ9JPFP6iQt6jnQcpHjgAKhJN6G4RqXtYpLH7hzcnqeZXhp0/8Bbsf7+d/E16zu8pJCMXvnqhrNy1suAXBLEt7Tw4jcQDX03obhKJe1ikCXe1MVw/8Bb+UH224zOp81IdMclG+i/oL8f+OJb/gjNnisTGnl5ebKzu98VQUELXsVzCLRwDWajisXN2ovzmn81h9yxIFo4Zc33d69nSdwsPXvogr3z5CpeMu4QlPyzJf2GRgu8ryxgJYuMaY9oALwPRwEQRGRFguTuAeUAzEUkpaJ1JSUmSklLgIkpFnqio/BOaMf4feTvVqZP/JNy1a/srF0W0YtcKus/vzneHv6N3096Maj2KSqUr2VpmSWaMWS8iSfk9V2gN3RgTDYwBbgISgE7GmIR8lqsIPAysLV64SlnArTM+OTmSpk1DKbao3YJNfTbx/674f0zYMIH6Y+vzyXef+J/UKYrCqlQQy1wKfCci3wMYY2YDtwBpeZYbCowEBhQ1mIyMDHbv3s2pU6eKugoVgjJlyhAfH09MTIzToVgrZ8zTnKaNnDFPwfkmruHDT48NrB+fNpCc9z54sD+h1qrlL9eCbVIuphwv3PACHRI60P397tw06ya6NerGxPjziP5p95kvcNuQyLNm2bJdwi5Q43rODeiAv5kl5/49wOg8yzQB3s7+fxmQFGBdvYAUIKVWrVpnNPZ///33cvDgwZAmtFVF4/P55ODBg/L99987HYr13N49NMJPjJ/KOCVPLnpSop+Jlr6dzpKMMqXd3bMr1JPgDn9+FKeXS2EJHX+zzTKgjhSS0HPf8uvlkpaWpsk8jHw+n6SlpTkdhvUi9RJBj1m/d700GNdAOt2OHKhWTnxu/QELpQLggq7HBSX0YHq57AFq5rofn/1YjopAfWCZMWYncDkw3xiTb6N9YYwxRXmZKoKI3dYlbcYnl2pybhPW9VzHxf2HcF7/DM4ZWY25Hz2P/POfTod2ulDa+fPrpXTihP9xFwgmoa8D6hljzjfGxAJ3A/NznhSRIyJSTUTqiEgdYA3QXgrp5aKUbcIxj5oKSmx0LP9u+W/W91pP7cq1uXPenXSY24Gfj/3sdGh/CaUC4PKTvIUmdBHJBB4EFgLbgTkiss0YM8QY097uAN1s586dvPHGG3/eT01NZcGCBX/enz9/PiNG5NvDM2TdunVj3rx5APTo0YO0tLznpNWf7OxHrorkknMuYfX9qxlx3Qg++uYjEscmMnPzzJxmW2eFUgFw+9FfoLYYu2+B2tC9ZOnSpdK2bds/70+ZMkUeeOABW8rq2rWrzJ071/L1em2bK+/bfnC7XDHxCiEZafdGO9l9ZLfTIQV/otPlbejBdFt0xCOfPELqz6mWrrNRjUa81OalApeZPn06L7zwAsYYGjRowIwZM+jWrRvt2rWjQ4cOAFSoUIFjx44xcOBAtm/fTqNGjejUqRNjxozh5MmTrFy5kkGDBnHy5ElSUlIYPXo03bp1o1KlSqSkpPDzzz8zatQoOnTogM/n48EHH2TJkiXUrFmTmJgYunfv/mdZ+bnmmmt44YUXSEpKokKFCjz88MN8+OGHlC1blvfff59zzjmHgwcP0qdPH37MPhR86aWXaN68uWXbUqmiuqjaRay4bwWvfvkqTy5+koSxCfz3hv/SvXF3587rdO4c3BGcjV0/raCX/ueybds2hg0bxpIlS9i0aRMvv/xygcuPGDGCFi1akJqayhNPPMGQIUO46667SE1N5a677jpj+X379rFy5Uo+/PBDBg4cCMA777zDzp07SUtLY8aMGaxevTqkmI8fP87ll1/Opk2buPrqq5kwYQIADz/8MP/6179Yt24db7/9Nj169AhpvZ7k1ouJ1Bmio6J55PJH2NJ3C41rNKbHBz24ceaN7Potn6tK3cbFw3e4toZeWE3aDkuWLKFjx45Uq1YNgKpVq1q6/ltvvZWoqCgSEhLYv38/ACtXrqRjx45ERUVRo0YNrr322pDWGRsbS7t27QBo2rQpn332GQCLFi06rZ39999/59ixY1SoUMGid+Mybr6YSAV0QdULWNJ1Ca+lvMbjix6n/rj6jLx+JH2S+hBltL4ZKt1iQShVqhS+7HE2fD4f6enpRVpP6dKl//xfLDoZFBMT8+dhanR0NJmZmYA/zjVr1pCamkpqaip79uyJ3GQOru9OpgKLMlH0bdaXrX23ckX8FTyw4AFaTWvFd4e/czo0z9GEnkurVq2YO3cuhw4dAuDw4cMA1KlTh/Xr1wP+nisZGRkAVKxYkaNHj/75+rz3g9G8eXPefvttfD4f+/fvZ9myZRa8E7jhhht49dVX/7yfmppqyXpdy+XdyVThaleuzcIuC5nUfhKpP6fSYFwD/rf6f2T5spwOzTM0oeeSmJjI4MGDadmyJQ0bNuTRRx8FoGfPnnz++ec0bNiQ1atXU758eQAaNGhAdHQ0DRs25H//+x/XXnstaWlpNGrUiLfeeiuoMu+44w7i4+NJSEigS5cuNGnShLPOOqvY7+WVV14hJSWFBg0akJCQwPjx44u9Tldze3cyFRRjDN0bd2dbv220Or8Vj376KC2mtOCrX75yOjRvCNT9xe5bJHRbtMrRo0dFROSXX36RunXryr59+8JWdsRscxd0J1PW8vl8MnPTTKk6sqqUHlpanlvxnGRkZTgdluPQCS7crV27djRq1IgWLVrw73//mxo1ajgdkvfoxUQRxxhD5wadSeuXRrsL2zFo8SAun3g5m/dvdjo01wpqggs75DfBxfbt27n44osdiaek0m2uvGLutrk8sOABfjv1G4NbDGZQi0HERsc6HVbYFWuCC6WUcoOOiR1JeyCNjokdSf48mWYTmrFh3wanw3IVTehKKc+oVq4as26fxft3v8/B4we5dMKlPLn4SU5l6qQ4oAldKeVB7f/enm39tnFvw3t5buVzNHmtCWt2r3E6LMdpQleqpImQIRKqlK3C5Fsm80nnTziWfozmk5vz2KePcSLjROEvjlDeTugRsmMqFTY5QyTs2uXv3JkzRIKHvzs3/t+NbO23lV5NevHi6hdpOL4hy3ctdzosR3g3oTu8Y06bNo169epRr149pk2bFpYylSq2CB0ioVLpSoxrN47F9y4my5dFy6kteXDBgxxLP+Z0aGHl3W6Lder4k3hetWv7R0Cz0eHDh0lKSiIlJQVjDE2bNmX9+vVUqVLF1nLtoN0WS5ioKH8FKC9j/KMHRoDj6cd5cvGTvPrlq9SuXJsJ/5jA9XWvdzosy0Rmt0Ubxu5Yt24dDRo04NSpUxw/fpzExES2bt16xnILFy6kdevWVK1alSpVqtC6dWs++eSTIperVNiUgCESyseW5+WbXmbFfSuIjY6l9YzW9PqgF0dOHXE6NNt5N6HbsGM2a9aM9u3b89RTT/H444/TpUsX6tevf8Zye/bsoWbNv+bNjo+PZ8+ePWcsp5TrlKD5VpvXak5q71QGXDmASRsnUX9cfRZ8u6DwF3qYdxO6TTvm008/zWeffUZKSgqPP/54sdallOuUsCESysaUZVTrUay+fzWVSlei7Rtt6fpeVw6fPOx0aLbwbkK3acc8dOgQx44d4+jRo5w6lf/FCueddx4//fTTn/d3797NeeedV6xylQobF8+4Y5dLz7uUDb028FSLp5i1eRYJYxJ4d/u7TodlOe+eFLVJ+/btufvuu/nhhx/Yt28fo0ePPmOZw4cP07RpUzZs8F923KRJE9avX2/5DEfh4IZtrlQ4bdy3ke7zu5P6cyp3Jt7J6JtGU718dafDClpknhS1wfTp04mJieGf//wnAwcOZN26dSxZsuSM5apWrcq///1vmjVrRrNmzXj66ac9mcyVKokan9uYL3t8ybBrh/Hu9ndJGJvA7K2zLZtFzElaQy/hdJurkmzbgW3c9/59rNu7jlsvupWxN4/l3IrnOh1WgbSGrpRS+Ug8O5FV969i1PWj+Pjbj0kcm8j0TdM9W1vXhF6ALVu20KhRo9Nul112mdNhKaUsVCqqFAOaD2BTn00kVE+g63tdaftGW3468lPhL3aZUk4H4GaXXHJJ5E+urJQC4O/V/s7y+5Yz+svRDFo8iMSxibx4w4v0aNIDY4zT4QVFa+hKKZUtykTR/7L+bOm7haS/JdHrw160ntGaH379wenQgqIJXSml8qhbpS6L7l3E+Lbj+XLPl1wy7hJGfzkan7h7vBtN6EoplY8oE0XvpN5s7beVq2pdxUMfP0TLqS359tC3TocWkKcTug6HrpSyW62zavFx54+ZcssUth7YSoPxDXhh1Qtk+bKcDu0Mnk3oTo/T36ZNGypXrky7du3CU6BSyjHGGLo16sa2ftu44YIbGPDZAK6cfCVpB9OcDu00nk3oTo/TP2DAAGbMmBGewpRSrvC3in/jvbve443b32DH4R00fq0xz654loysDKdDAzyc0G0YDj3o8dABrrvuOipWrFj0wpRSnmSModMlnUh7II1b/n4Lg5cM5rKJl7Hp501Oh+bdhG7HOP3BjoeulFJnlz+bOR3nMK/jPPYc3UPShCT+s/Q/pGelOxaTZxO6XeP063joSqlQ3JFwB2n90uhUvxNDlg+h6etNSdmbUvgLbeDZhG7XOP3BjIeulFK5xZWLY/pt0/mg0wccPnmYyyZexsBFAzmVGd4c4tmEDvaM09+7d2+GDh1K586deeKJJ4q/QqVUidHuwnZs67eN+xrdx8gvRtJofCNW/bQqbOV7OqFbLdjx0AFatGhBx44dWbx4MfHx8SxcuDDM0Sql3KhymcpMbD+RT7t8ysnMk1w1+SqSlyWHpeygxkM3xrQBXgaigYkiMiLP848CPYBM4CDQXUR2FbROHQ/dHXSbK2Wfo38cZeCigVwefzn3NLzHknUWNB56oaMtGmOigTFAa2A3sM4YM19Ecveo3wgkicgJY0xfYBRwV/FDV0op76pYuiJj2o4JW3nBDJ97KfCdiHwPYIyZDdwC/JnQRWRpruXXAF2sDNIpW7Zs4Z57Tv9VLV26NGvXrnUoIqWUCiyYhH4ekHuk991AQbM83A98nN8TxpheQC+AWgE6jIuIa8YejvTx0L06K4tSKn+WnhQ1xnQBkoDn83teRF4XkSQRSape/cxZtsuUKcOhQ4c00YSBiHDo0CHKlCnjdChKKYsEU0PfA9TMdT8++7HTGGOuBwYDLUXkj6IEEx8fz+7duzl48GBRXq5CVKZMGeLj450OQyllkWAS+jqgnjHmfPyJ/G7gn7kXMMY0Bl4D2ojIgaIGExMTw/nnn1/UlyulVIlWaJOLiGQCDwILge3AHBHZZowZYoxpn73Y80AFYK4xJtUYM9+2iJVSSuUrqEmiRWQBsCDPY0/n+v96i+NSSikVIr1SVCmlIkRQV4raUrAxB4ECryYtQDXgFwvDsYrGFRqNK3RujU3jCk1x4qotImd2E8TBhF4cxpiUQJe+OknjCo3GFTq3xqZxhcauuLTJRSmlIoQmdKWUihBeTeivOx1AABpXaDSu0Lk1No0rNLbE5ck2dKWUUmfyag1dKaVUHprQlVIqQrg6oRtj2hhjvjbGfGeMGZjP848aY9KMMZuNMYuNMbVdElcfY8yW7GEQVhpjEtwQV67l7jDGiDEmLN25gthe3YwxB7O3V6oxpocb4spe5s7sfWybMeYNN8RljPlfrm31jTHmN5fEVcsYs9QYszH7O3mzS+KqnZ0fNhtjlhljwjIinTFmsjHmgDFma4DnjTHmley4NxtjmhS7UBFx5Q3/dHc7gLpALLAJSMizzLVAuez/+wJvuSSuSrn+bw984oa4sperCCzHPxFJkhviAroBo124f9XDPxtXlez7Z7shrjzLPwRMdkNc+E/09c3+PwHY6ZK45gJds/9vBcwI0z52NdAE2Brg+Zvxzx1hgMuBtcUt08019D9nShKRdCBnpqQ/ichSETmRfXcN/qF93RDX77nulgfCcea50LiyDQVGAqfCEFMocYVbMHH1BMaIyK8AUoyRRC2OK7dOwJsuiUuAStn/nwXsdUlcCUDObO9L83neFiKyHDhcwCK3ANPFbw1Q2RhzbnHKdHNCz2+mpPMKWD7gTEkWCyouY8wDxpgd+OdX7e+GuLIP6WqKyEdhiCfouLLdkX3YOc8YUzOf552I60LgQmPMF8aYNdmTpbshLsDflACcz1/Jyum4koEuxpjd+Afze8glcW0Cbs/+/zagojEmLgyxFSbUHFcoNyf0oBU2U5ITRGSMiFwAPAE85XQ8xpgo4L/A/3M6lnx8ANQRkQbAZ8A0h+PJUQp/s8s1+GvCE4wxlZ0MKI+7gXkikuV0INk6AVNFJB5/c8KM7P3OaY8BLY0xG4GW+Od1cMs2s5QbNnYgoc6U1F6KOFOSHXHlMhu41c6AshUWV0WgPrDMGLMTf5vd/DCcGC10e4nIoVyf3USgqc0xBRUX/hrTfBHJEJEfgG/wJ3in48pxN+FpboHg4rofmAMgIquBMvgHoXI0LhHZKyK3i0hj/LkCEfnN5riCEWouKVw4Tg4U8YRCKeB7/IeUOSc7EvMs0xj/CZF6LourXq7//wGkuCGuPMsvIzwnRYPZXufm+v82YI1L4moDTMv+vxr+w+M4p+PKXu4iYCfZFwe6ZHt9DHTL/v9i/G3otsYXZFzVgKjs/4cDQ8KxzbLLq0Pgk6JtOf2k6JfFLi9cb6yIG+Nm/LWiHcDg7MeG4K+NAywC9gOp2bf5LonrZWBbdkxLC0qs4Ywrz7JhSehBbq/nsrfXpuztdZFL4jL4m6nSgC3A3W6IK/t+MjAiHPGEsL0SgC+yP8dU4AaXxNUB+DZ7mYlA6TDF9SawD8jAf7R3P9AH6JNr/xqTHfcWK76Peum/UkpFCDe3oSullAqBJnSllIoQmtCVUipCaEJXSqkIoQldKaUihCZ0pZSKEJrQlVIqQvx/vHDJPHFjoEsAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -613,48 +527,40 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 1. 5 PyTorch的Loss函数\n", - "前面我们使用了自己写的 loss，其实 PyTorch 已经为我们写好了一些常见的 loss，比如线性回归里面的 loss 是 `nn.MSE()`，而 Logistic 回归的二分类 loss 在 PyTorch 中是 `nn.BCEWithLogitsLoss()`，关于更多的 loss，可以查看[文档](http://pytorch.org/docs/0.3.0/nn.html#loss-functions)\n", + "## 3. PyTorch的Loss函数\n", "\n", - "PyTorch 为我们实现的 loss 函数有两个好处，第一是方便我们使用，不需要重复造轮子，第二就是其实现是在底层 C++ 语言上的，所以速度上和稳定性上都要比我们自己实现的要好\n", + "前面使用了自己写的 loss函数，其实 PyTorch 已经提供了一些常见的 loss函数，比如线性回归里面的 loss 是 `nn.MSE()`，而 Logistic 回归的二分类 loss 在 PyTorch 中是 `nn.BCEWithLogitsLoss()`，关于更多的 loss，可以查看[文档](https://pytorch.org/docs/stable/nn.html#loss-functions)\n", "\n", - "另外，PyTorch 出于稳定性考虑，将模型的 Sigmoid 操作和最后的 loss 都合在了 `nn.BCEWithLogitsLoss()`，所以我们使用 PyTorch 自带的 loss 就不需要再加上 Sigmoid 操作了" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# 使用自带的loss\n", - "criterion = nn.BCEWithLogitsLoss() # 将 sigmoid 和 loss 写在一层，有更快的速度、更好的稳定性\n", + "PyTorch 实现的 loss函数有两个好处：第一是方便使用，不需要重复造轮子；第二就是其实现是在底层 C++ 语言上的，所以速度上和稳定性上都要比自己实现的要好。\n", "\n", - "w = nn.Parameter(torch.randn(2, 1))\n", - "b = nn.Parameter(torch.zeros(1))\n", - "\n", - "def logistic_reg(x):\n", - " return torch.mm(x, w) + b\n", - "\n", - "optimizer = torch.optim.SGD([w, b], 1.)" + "另外，PyTorch 出于稳定性考虑，将模型的 Sigmoid 操作和最后的 loss 都合在了 `nn.BCEWithLogitsLoss()`，所以我们使用 PyTorch 自带的 loss 就不需要再加上 Sigmoid 操作了" ] }, { "cell_type": "code", - "execution_count": 118, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "tensor(0.6314)\n" + "tensor(0.9880)\n" ] } ], "source": [ + "# 使用自带的loss\n", + "criterion = nn.BCEWithLogitsLoss() # 将 sigmoid 和 loss 写在一层，有更快的速度、更好的稳定性\n", + "\n", + "w = nn.Parameter(torch.randn(2, 1))\n", + "b = nn.Parameter(torch.zeros(1))\n", + "\n", + "def logistic_reg(x):\n", + " return torch.mm(x, w) + b\n", + "\n", + "optimizer = torch.optim.SGD([w, b], 1.)\n", + "\n", "y_pred = logistic_reg(x_data)\n", "loss = criterion(y_pred, y_data)\n", "print(loss.data)" @@ -662,20 +568,20 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "epoch: 200, Loss: 0.22419, Acc: 0.89000\n", - "epoch: 400, Loss: 0.22191, Acc: 0.89000\n", - "epoch: 600, Loss: 0.21997, Acc: 0.89000\n", - "epoch: 800, Loss: 0.21830, Acc: 0.88000\n", - "epoch: 1000, Loss: 0.21685, Acc: 0.88000\n", + "epoch: 200, Loss: 0.40936, Acc: 0.86000\n", + "epoch: 400, Loss: 0.32933, Acc: 0.87000\n", + "epoch: 600, Loss: 0.29321, Acc: 0.87000\n", + "epoch: 800, Loss: 0.27238, Acc: 0.87000\n", + "epoch: 1000, Loss: 0.25875, Acc: 0.87000\n", "\n", - "During Time: 0.215 s\n" + "During Time: 0.313 s\n" ] } ], diff --git a/6_pytorch/5-deep-nn.ipynb b/6_pytorch/5-deep-nn.ipynb deleted file mode 100644 index 8488a8c..0000000 --- a/6_pytorch/5-deep-nn.ipynb +++ /dev/null @@ -1,693 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 深层神经网络\n", - "前面一章我们简要介绍了神经网络的一些基本知识，同时也是示范了如何用神经网络构建一个复杂的非线性二分类器，更多的情况神经网络适合使用在更加复杂的情况，比如图像分类的问题，下面我们用深度学习的入门级数据集 MNIST 手写体分类来说明一下更深层神经网络的优良表现。\n", - "\n", - "## MNIST 数据集\n", - "mnist 数据集是一个非常出名的数据集，基本上很多网络都将其作为一个测试的标准，其来自美国国家标准与技术研究所, National Institute of Standards and Technology (NIST)。 训练集 (training set) 由来自 250 个不同人手写的数字构成, 其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员，一共有 60000 张图片。 测试集(test set) 也是同样比例的手写数字数据，一共有 10000 张图片。\n", - "\n", - "每张图片大小是 28 x 28 的灰度图，如下\n", - "\n", - "![](https://ws3.sinaimg.cn/large/006tKfTcly1fmlx2wl5tqj30ge0au745.jpg)\n", - "\n", - "所以我们的任务就是给出一张图片，我们希望区别出其到底属于 0 到 9 这 10 个数字中的哪一个。\n", - "\n", - "## 多分类问题\n", - "前面我们讲过二分类问题，现在处理的问题更加复杂，是一个 10 分类问题，统称为多分类问题，对于多分类问题而言，我们的 loss 函数使用一个更加复杂的函数，叫交叉熵。\n", - "\n", - "### softmax\n", - "提到交叉熵，我们先讲一下 softmax 函数，前面我们见过了 sigmoid 函数，如下\n", - "\n", - "$$s(x) = \\frac{1}{1 + e^{-x}}$$\n", - "\n", - "可以将任何一个值转换到 0 ~ 1 之间，当然对于一个二分类问题，这样就足够了，因为对于二分类问题，如果不属于第一类，那么必定属于第二类，所以只需要用一个值来表示其属于其中一类概率，但是对于多分类问题，这样并不行，需要知道其属于每一类的概率，这个时候就需要 softmax 函数了。\n", - "\n", - "softmax 函数示例如下\n", - "\n", - "![](https://ws4.sinaimg.cn/large/006tKfTcly1fmlxtnfm4fj30ll0bnq3c.jpg)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "对于网络的输出 $z_1, z_2, \\cdots z_k$，我们首先对他们每个都取指数变成 $e^{z_1}, e^{z_2}, \\cdots, e^{z_k}$，那么每一项都除以他们的求和，也就是\n", - "\n", - "$$\n", - "z_i \\rightarrow \\frac{e^{z_i}}{\\sum_{j=1}^{k} e^{z_j}}\n", - "$$\n", - "\n", - "如果对经过 softmax 函数的所有项求和就等于 1，所以他们每一项都分别表示属于其中某一类的概率。\n", - "\n", - "## 交叉熵\n", - "交叉熵衡量两个分布相似性的一种度量方式，前面讲的二分类问题的 loss 函数就是交叉熵的一种特殊情况，交叉熵的一般公式为\n", - "\n", - "$$\n", - "cross\\_entropy(p, q) = E_{p}[-\\log q] = - \\frac{1}{m} \\sum_{x} p(x) \\log q(x)\n", - "$$\n", - "\n", - "对于二分类问题我们可以写成\n", - "\n", - "$$\n", - "-\\frac{1}{m} \\sum_{i=1}^m (y^{i} \\log sigmoid(x^{i}) + (1 - y^{i}) \\log (1 - sigmoid(x^{i}))\n", - "$$\n", - "\n", - "这就是我们之前讲的二分类问题的 loss，当时我们并没有解释原因，只是给出了公式，然后解释了其合理性，现在我们给出了公式去证明这样取 loss 函数是合理的\n", - "\n", - "交叉熵是信息理论里面的内容，这里不再具体展开，更多的内容，可以看到下面的[链接](http://blog.csdn.net/rtygbwwwerr/article/details/50778098)\n", - "\n", - "下面我们直接用 mnist 举例，讲一讲深度神经网络" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import torch\n", - "from torchvision.datasets import mnist # 导入 pytorch 内置的 mnist 数据\n", - "\n", - "from torch import nn\n", - "from torch.autograd import Variable" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# 使用内置函数下载 mnist 数据集\n", - "train_set = mnist.MNIST('../../data/mnist', train=True, download=True)\n", - "test_set = mnist.MNIST('../../data/mnist', train=False, download=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "我们可以看看其中的一个数据是什么样子的" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "a_data, a_label = train_set[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAABAElEQVR4nGNgGMyAWUhIqK5jvdSy/9/rGRgYGFhgEnJsVjYCwQwMDAxPJgV+vniQgYGBgREqZ7iXH8r6l/SV4dn7m8gmCt3++/fv37/Htn3/iMW+gDnZf/+e5WbQnoXNNXyMs/5GoQoxwVmf/n9kSGFiwAW49/11wynJoPzx4YIcRlyygR/+/i2XxCWru+vv32nSuGQFYv/83Y3b4p9/fzpAmSyoMnohpiwM1w5h06Q+5enfv39/bcMiJVF09+/fv39P+mFKiTtd/fv3799jgZiBJLT69t+/f/8eDuDEkDJf8+jv379/v7Ryo4qzMDAwMAQGMjBc3/y35wM2V1IfAABFF16Aa0wAOwAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a_data" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "5" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "a_label" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "这里的读入的数据是 PIL 库中的格式，我们可以非常方便地将其转换为 numpy array" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(28, 28)\n" - ] - } - ], - "source": [ - "a_data = np.array(a_data, dtype='float32')\n", - "print(a_data.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "这里我们可以看到这种图片的大小是 28 x 28" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", - " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", - " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", - " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", - " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", - " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 3. 18.\n", - " 18. 18. 126. 136. 175. 26. 166. 255. 247. 127. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 30. 36. 94. 154. 170. 253.\n", - " 253. 253. 253. 253. 225. 172. 253. 242. 195. 64. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 49. 238. 253. 253. 253. 253. 253.\n", - " 253. 253. 253. 251. 93. 82. 82. 56. 39. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 18. 219. 253. 253. 253. 253. 253.\n", - " 198. 182. 247. 241. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 80. 156. 107. 253. 253. 205.\n", - " 11. 0. 43. 154. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 14. 1. 154. 253. 90.\n", - " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 139. 253. 190.\n", - " 2. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 11. 190. 253.\n", - " 70. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 35. 241.\n", - " 225. 160. 108. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 81.\n", - " 240. 253. 253. 119. 25. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", - " 45. 186. 253. 253. 150. 27. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", - " 0. 16. 93. 252. 253. 187. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", - " 0. 0. 0. 249. 253. 249. 64. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", - " 46. 130. 183. 253. 253. 207. 2. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 39. 148.\n", - " 229. 253. 253. 253. 250. 182. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 24. 114. 221. 253.\n", - " 253. 253. 253. 201. 78. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 23. 66. 213. 253. 253. 253.\n", - " 253. 198. 81. 2. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 18. 171. 219. 253. 253. 253. 253. 195.\n", - " 80. 9. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 55. 172. 226. 253. 253. 253. 253. 244. 133. 11.\n", - " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 136. 253. 253. 253. 212. 135. 132. 16. 0. 0.\n", - " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", - " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", - " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", - " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", - " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]\n" - ] - } - ], - "source": [ - "print(a_data)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "我们可以将数组展示出来，里面的 0 就表示黑色，255 表示白色\n", - "\n", - "对于神经网络，我们第一层的输入就是 28 x 28 = 784，所以必须将得到的数据我们做一个变换，使用 reshape 将他们拉平成一个一维向量" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "def data_tf(x):\n", - " x = np.array(x, dtype='float32') / 255\n", - " x = (x - 0.5) / 0.5 # 标准化，这个技巧之后会讲到\n", - " x = x.reshape((-1,)) # 拉平\n", - " x = torch.from_numpy(x)\n", - " return x\n", - "\n", - "train_set = mnist.MNIST('../../data/mnist', train=True, transform=data_tf, download=True) # 重新载入数据集，申明定义的数据变换\n", - "test_set = mnist.MNIST('../../data/mnist', train=False, transform=data_tf, download=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "torch.Size([784])\n", - "5\n" - ] - } - ], - "source": [ - "a, a_label = train_set[0]\n", - "print(a.shape)\n", - "print(a_label)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "from torch.utils.data import DataLoader\n", - "# 使用 pytorch 自带的 DataLoader 定义一个数据迭代器\n", - "train_data = DataLoader(train_set, batch_size=64, shuffle=True)\n", - "test_data = DataLoader(test_set, batch_size=128, shuffle=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "使用这样的数据迭代器是非常有必要的，如果数据量太大，就无法一次将他们全部读入内存，所以需要使用 python 迭代器，每次生成一个批次的数据" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "a, a_label = next(iter(train_data))" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "torch.Size([64, 784])\n", - "torch.Size([64])\n" - ] - } - ], - "source": [ - "# 打印出一个批次的数据大小\n", - "print(a.shape)\n", - "print(a_label.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# 使用 Sequential 定义 4 层神经网络\n", - "net = nn.Sequential(\n", - " nn.Linear(784, 400),\n", - " nn.ReLU(),\n", - " nn.Linear(400, 200),\n", - " nn.ReLU(),\n", - " nn.Linear(200, 100),\n", - " nn.ReLU(),\n", - " nn.Linear(100, 10)\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Sequential(\n", - " (0): Linear(in_features=784, out_features=400, bias=True)\n", - " (1): ReLU()\n", - " (2): Linear(in_features=400, out_features=200, bias=True)\n", - " (3): ReLU()\n", - " (4): Linear(in_features=200, out_features=100, bias=True)\n", - " (5): ReLU()\n", - " (6): Linear(in_features=100, out_features=10, bias=True)\n", - ")" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "net" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "交叉熵在 pytorch 中已经内置了，交叉熵的数值稳定性更差，所以内置的函数已经帮我们解决了这个问题" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# 定义 loss 函数\n", - "criterion = nn.CrossEntropyLoss()\n", - "optimizer = torch.optim.SGD(net.parameters(), 1e-1) # 使用随机梯度下降，学习率 0.1" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 0, Train Loss: 0.511304, Train Acc: 0.830540, Eval Loss: 0.232364, Eval Acc: 0.925732\n", - "epoch: 1, Train Loss: 0.167128, Train Acc: 0.948744, Eval Loss: 0.171745, Eval Acc: 0.942148\n", - "epoch: 2, Train Loss: 0.118102, Train Acc: 0.963420, Eval Loss: 0.107683, Eval Acc: 0.965882\n", - "epoch: 3, Train Loss: 0.092869, Train Acc: 0.971565, Eval Loss: 0.090614, Eval Acc: 0.970728\n", - "epoch: 4, Train Loss: 0.073340, Train Acc: 0.977229, Eval Loss: 0.081820, Eval Acc: 0.972805\n", - "epoch: 5, Train Loss: 0.060981, Train Acc: 0.980727, Eval Loss: 0.087822, Eval Acc: 0.972211\n", - "epoch: 6, Train Loss: 0.051884, Train Acc: 0.982809, Eval Loss: 0.127961, Eval Acc: 0.958564\n", - "epoch: 7, Train Loss: 0.044878, Train Acc: 0.985741, Eval Loss: 0.102081, Eval Acc: 0.967366\n", - "epoch: 8, Train Loss: 0.039214, Train Acc: 0.987223, Eval Loss: 0.067912, Eval Acc: 0.977551\n" - ] - } - ], - "source": [ - "# 开始训练\n", - "losses = []\n", - "acces = []\n", - "eval_losses = []\n", - "eval_acces = []\n", - "\n", - "for e in range(20):\n", - " train_loss = 0\n", - " train_acc = 0\n", - " net.train()\n", - " for im, label in train_data:\n", - " im = Variable(im)\n", - " label = Variable(label)\n", - " # 前向传播\n", - " out = net(im)\n", - " loss = criterion(out, label)\n", - " # 反向传播\n", - " optimizer.zero_grad()\n", - " loss.backward()\n", - " optimizer.step()\n", - " # 记录误差\n", - " train_loss += loss.item()\n", - " # 计算分类的准确率\n", - " _, pred = out.max(1)\n", - " num_correct = float((pred == label).sum().item())\n", - " acc = num_correct / im.shape[0]\n", - " train_acc += acc\n", - " \n", - " losses.append(train_loss / len(train_data))\n", - " acces.append(train_acc / len(train_data))\n", - " # 在测试集上检验效果\n", - " eval_loss = 0\n", - " eval_acc = 0\n", - " net.eval() # 将模型改为预测模式\n", - " for im, label in test_data:\n", - " im = Variable(im)\n", - " label = Variable(label)\n", - " out = net(im)\n", - " loss = criterion(out, label)\n", - " # 记录误差\n", - " eval_loss += loss.item()\n", - " # 记录准确率\n", - " _, pred = out.max(1)\n", - " num_correct = float((pred == label).sum().item())\n", - " acc = num_correct / im.shape[0]\n", - " eval_acc += acc\n", - " \n", - " eval_losses.append(eval_loss / len(test_data))\n", - " eval_acces.append(eval_acc / len(test_data))\n", - " print('epoch: {}, Train Loss: {:.6f}, Train Acc: {:.6f}, Eval Loss: {:.6f}, Eval Acc: {:.6f}'\n", - " .format(e, train_loss / len(train_data), train_acc / len(train_data), \n", - " eval_loss / len(test_data), eval_acc / len(test_data)))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "画出 loss 曲线和 准确率曲线" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.title('train loss')\n", - "plt.plot(np.arange(len(losses)), losses)" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'train acc')" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(np.arange(len(acces)), acces)\n", - "plt.title('train acc')" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'test loss')" - ] - }, - "execution_count": 46, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(np.arange(len(eval_losses)), eval_losses)\n", - "plt.title('test loss')" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'test acc')" - ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(np.arange(len(eval_acces)), eval_acces)\n", - "plt.title('test acc')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "可以看到我们的三层网络在训练集上能够达到 99.9% 的准确率，测试集上能够达到 98.20% 的准确率" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**小练习：看一看上面的训练过程，看一下准确率是怎么计算出来的，特别注意 max 这个函数**\n", - "\n", - "**自己重新实现一个新的网络，试试改变隐藏层的数目和激活函数，看看有什么新的结果**" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.5.4" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/6_pytorch/5-nn-sequential-module.ipynb b/6_pytorch/5-nn-sequential-module.ipynb index d37a416..9d3b8c9 100644 --- a/6_pytorch/5-nn-sequential-module.ipynb +++ b/6_pytorch/5-nn-sequential-module.ipynb @@ -6,7 +6,7 @@ "source": [ "# 多层神经网络\n", "\n", - "本节在前面学习线性回归模型的基础上，我们学习如何利用PyTorch实现多层神经网络。" + "本节在前面学习线性回归和逻辑回归模型的基础上，本节学习如何利用PyTorch实现多层神经网络。" ] }, { @@ -14,7 +14,7 @@ "metadata": {}, "source": [ "## 1. 多层神经网络\n", - "在前面的线性回归中，我们的公式是 $y = w x + b$，而在 Logistic 回归中，我们的公式是 $y = Sigmoid(w x + b)$，其实它们都可以看成单层神经网络，其中 Sigmoid 被称为激活函数。" + "线性回归的公式是 $y = w x + b$， Logistic 回归的公式是 $y = Sigmoid(w x + b)$，其实它们都可以看成单层神经网络，其中 Sigmoid 被称为激活函数。" ] }, { @@ -22,48 +22,31 @@ "metadata": {}, "source": [ "### 1.1 神经网络的结构\n", + "\n", "神经网络就是很多个神经元堆在一起形成一层神经网络，那么多个层堆叠在一起就是深层神经网络\n", "\n", "![nn demo](imgs/nn-forward.gif)\n", "\n", - "可以看到，神经网络的结构其实非常简单，主要有输入层，隐藏层，输出层构成，输入层需要根据特征数目来决定，输出层根据解决的问题来决定，那么隐藏层的网路层数以及每层的神经元数就是可以调节的参数，而不同的层数和每层的参数对模型的影响非常大，我们看看这个网站的示例 [demo](http://cs.stanford.edu/people/karpathy/convnetjs/demo/classify2d.html)\n", - "\n", - "神经网络向前传播也非常简单，就是一层一层不断做运算即可。" + "可以看到，神经网络的结构其实非常简单，主要有输入层，隐藏层，输出层构成，输入层需要根据特征数目来决定，输出层根据解决的问题来决定，那么隐藏层的网路层数以及每层的神经元数就是可以调节的参数，而不同的层数和每层的参数对模型的影响非常大，具体的动态示例可以参考 [demo - classify2d](http://cs.stanford.edu/people/karpathy/convnetjs/demo/classify2d.html) 。神经网络向前传播也非常简单，就是一层一层不断做运算即可。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### 1.2 示例程序" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "import torch\n", - "import numpy as np\n", - "from torch import nn\n", - "from torch.autograd import Variable\n", - "import torch.nn.functional as F\n", + "### 1.2 多层神经网络示例程序\n", "\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline" + "首先生成一些训练、测试数据。" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -75,8 +58,14 @@ } ], "source": [ + "import torch\n", + "import numpy as np\n", + "from torch import nn\n", "from sklearn import datasets\n", "\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", "# generate sample data\n", "np.random.seed(0)\n", "data_x, data_y = datasets.make_moons(200, noise=0.20)\n", @@ -88,211 +77,61 @@ }, { "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "def plot_decision_boundary(model, x, y):\n", - " # Set min and max values and give it some padding\n", - " x_min, x_max = x[:, 0].min() - 1, x[:, 0].max() + 1\n", - " y_min, y_max = x[:, 1].min() - 1, x[:, 1].max() + 1\n", - " h = 0.01\n", - " # Generate a grid of points with distance h between them\n", - " xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n", - " # Predict the function value for the whole grid .c_按行连接两个矩阵，左右相加。\n", - " Z = model(np.c_[xx.ravel(), yy.ravel()])\n", - " Z = Z.reshape(xx.shape)\n", - " # Plot the contour and training examples\n", - " plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)\n", - " plt.ylabel('x2')\n", - " plt.xlabel('x1')\n", - " plt.scatter(x[:, 0], x[:, 1], c=y.reshape(-1), s=40, cmap=plt.cm.Spectral)" - ] - }, - { - "cell_type": "markdown", + "execution_count": 2, "metadata": {}, - "source": [ - "这次我们仍然处理一个二分类问题，但是比前面的 logistic 回归更加复杂。我们可以先尝试用 logistic 回归来解决这个问题" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "collapsed": true - }, "outputs": [], "source": [ "# 变量\n", "x = torch.from_numpy(data_x).float()\n", "y = torch.from_numpy(data_y).float().unsqueeze(1)\n", "\n", - "# 定义参数\n", - "w = nn.Parameter(torch.randn(2, 1))\n", - "b = nn.Parameter(torch.zeros(1))\n", - "\n", - "# 优化器\n", - "optimizer = torch.optim.SGD([w, b], 1e-1)\n", "\n", - "def logistic_regression(x):\n", - " return torch.mm(x, w) + b\n", - " \n", - "criterion = nn.BCEWithLogitsLoss()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 20, loss: 0.5933903455734253\n", - "epoch: 40, loss: 0.5228480696678162\n", - "epoch: 60, loss: 0.4789358973503113\n", - "epoch: 80, loss: 0.4493311941623688\n", - "epoch: 100, loss: 0.42803263664245605\n" - ] - } - ], - "source": [ - "for e in range(100):\n", - " #更新并自动计算\n", - " out = logistic_regression(Variable(x))\n", - " loss = criterion(out, Variable(y))\n", - " \n", - " optimizer.zero_grad()\n", - " loss.backward()\n", - " optimizer.step()\n", - " \n", - " if (e + 1) % 20 == 0:\n", - " print('epoch: {}, loss: {}'.format(e+1, loss.item()))" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "def plot_logistic(x):\n", - " x = Variable(torch.from_numpy(x).float())\n", - " out = F.sigmoid(logistic_regression(x))\n", - " out = (out > 0.5) * 1\n", - " return out.data.numpy()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/bushuhui/anaconda3/envs/test2/lib/python3.9/site-packages/torch/nn/functional.py:1805: UserWarning: nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\n", - " warnings.warn(\"nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\")\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'logistic regression')" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plot_decision_boundary(lambda x: plot_logistic(x), x.numpy(), y.numpy())\n", - "plt.title('logistic regression')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 1.3 多层神经网络示例程序\n", - "\n", - "可以看到，logistic 回归并不能很好的区分开这个复杂的数据集，如果你还记得前面的内容，你就知道 logistic 回归是一个线性分类器。接下来我们用两层神经网络来对同样的数据进行处理，看看效果如何。" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ "# 定义两层神经网络的参数\n", - "w1 = nn.Parameter(torch.randn(2, 4) * 0.01) # 隐藏层神经元个数 2\n", + "w1 = nn.Parameter(torch.randn(2, 4) * 0.1) # 隐藏层神经元个数 4\n", "b1 = nn.Parameter(torch.zeros(4))\n", "\n", - "w2 = nn.Parameter(torch.randn(4, 1) * 0.01)\n", + "w2 = nn.Parameter(torch.randn(4, 1) * 0.1)\n", "b2 = nn.Parameter(torch.zeros(1))\n", "\n", "# 定义模型\n", - "def two_network(x):\n", + "def SimpNetwork(x):\n", " x1 = torch.mm(x, w1) + b1\n", - " x1 = torch.tanh(x1) # 使用 PyTorch 自带的 tanh 激活函数\n", + " x1 = torch.sigmoid(x1) # 使用 PyTorch 自带的 sigmoid 激活函数\n", " x2 = torch.mm(x1, w2) + b2\n", - " return x2\n", + " return x2 # BCEWithLogitsLoss 已经带了sigmoid，所以此处不需要\n", "\n", - "optimizer = torch.optim.SGD([w1, w2, b1, b2], 1.)\n", + "optimizer = torch.optim.SGD([w1, b1, w2, b2], 0.1)\n", "\n", "criterion = nn.BCEWithLogitsLoss()" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "epoch: 100, loss: 0.3045365512371063\n", - "epoch: 200, loss: 0.3033600151538849\n", - "epoch: 300, loss: 0.302661269903183\n", - "epoch: 400, loss: 0.30217817425727844\n", - "epoch: 500, loss: 0.30179286003112793\n", - "epoch: 600, loss: 0.30145177245140076\n", - "epoch: 700, loss: 0.301126092672348\n", - "epoch: 800, loss: 0.3007963001728058\n", - "epoch: 900, loss: 0.30044662952423096\n", - "epoch: 1000, loss: 0.30006444454193115\n" + "epoch: 100, loss: 0.6914874315261841\n", + "epoch: 200, loss: 0.6847885251045227\n", + "epoch: 300, loss: 0.658918559551239\n", + "epoch: 400, loss: 0.588269054889679\n", + "epoch: 500, loss: 0.4917648732662201\n", + "epoch: 600, loss: 0.42251646518707275\n", + "epoch: 700, loss: 0.38259515166282654\n", + "epoch: 800, loss: 0.3581520915031433\n", + "epoch: 900, loss: 0.34184250235557556\n", + "epoch: 1000, loss: 0.330547571182251\n" ] } ], "source": [ - "# 我们训练 1000 次\n", + "# 训练 1000 次\n", "for e in range(1000):\n", - " out = two_network(Variable(x))\n", - " loss = criterion(out, Variable(y))\n", + " out = SimpNetwork(x)\n", + " loss = criterion(out, y)\n", " optimizer.zero_grad()\n", " loss.backward()\n", " optimizer.step()\n", @@ -302,48 +141,47 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": true - }, + "execution_count": 4, + "metadata": {}, "outputs": [], "source": [ - "def plot_network(x):\n", - " x = Variable(torch.from_numpy(x).float())\n", - " x1 = torch.mm(x, w1) + b1\n", - " x1 = F.tanh(x1)\n", - " x2 = torch.mm(x1, w2) + b2\n", - " out = F.sigmoid(x2)\n", - " out = (out > 0.5) * 1\n", - " return out.data.numpy()" + "def plot_decision_boundary(model, x, y):\n", + " # Set min and max values and give it some padding\n", + " x_min, x_max = x[:, 0].min() - 1, x[:, 0].max() + 1\n", + " y_min, y_max = x[:, 1].min() - 1, x[:, 1].max() + 1\n", + " h = 0.01\n", + " # Generate a grid of points with distance h between them\n", + " xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n", + " # Predict the function value for the whole grid .c_按行连接两个矩阵，左右相加。\n", + " Z = model(np.c_[xx.ravel(), yy.ravel()])\n", + " Z = Z.reshape(xx.shape)\n", + " # Plot the contour and training examples\n", + " plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)\n", + " plt.ylabel('x2')\n", + " plt.xlabel('x1')\n", + " plt.scatter(x[:, 0], x[:, 1], c=y.reshape(-1), s=40, cmap=plt.cm.Spectral)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 5, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/bushuhui/anaconda3/envs/test2/lib/python3.9/site-packages/torch/nn/functional.py:1794: UserWarning: nn.functional.tanh is deprecated. Use torch.tanh instead.\n", - " warnings.warn(\"nn.functional.tanh is deprecated. Use torch.tanh instead.\")\n" - ] - }, { "data": { + "image/png": "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\n", "text/plain": [ - "Text(0.5, 1.0, '2 layer network')" + "
" ] }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -355,15 +193,18 @@ } ], "source": [ - "plot_decision_boundary(lambda x: plot_network(x), x.numpy(), y.numpy())\n", - "plt.title('2 layer network')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "可以看到神经网络能够非常好地分类这个复杂的数据，和前面的 logistic 回归相比，神经网络因为有了激活函数的存在，成了一个非线性分类器，所以神经网络分类的边界更加复杂。" + "y_res = torch.sigmoid(SimpNetwork(x))\n", + "#y_pred = np.argmax(y_res, axis=1)\n", + "y_pred = (y_res > 0.5)*1\n", + "\n", + "# plot data\n", + "plt.scatter(x[:, 0], x[:, 1], c=y, cmap=plt.cm.Spectral)\n", + "plt.title(\"ground truth\")\n", + "plt.show()\n", + "\n", + "plt.scatter(x[:, 0], x[:, 1], c=y_pred, cmap=plt.cm.Spectral)\n", + "plt.title(\"predicted\")\n", + "plt.show()" ] }, { @@ -373,13 +214,6 @@ "## 2. Sequential 和 Module" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "前面讲了数据处理，模型构建，loss 函数设计等等内容，但是目前为止我们还没有准备好构建一个完整的机器学习系统，一个完整的机器学习系统需要我们不断地读写模型。在现实应用中，一般我们会将模型在本地进行训练，然后保存模型，接着我们会将模型部署到不同的地方进行应用。" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -387,7 +221,7 @@ "\n", "对于前面的线性回归模型、 Logistic回归模型和神经网络，在构建的时候定义了需要的参数。这对于比较小的模型是可行的，但是对于大的模型，比如100 层的神经网络，这个时候再去手动定义参数就显得非常麻烦，所以 PyTorch 提供了两个模块来帮助我们构建模型，一个是Sequential，一个是 Module。\n", "\n", - "Sequential 允许我们构建序列化的模块，而 Module 是一种更加灵活的模型定义方式，我们下面分别用 Sequential 和 Module 来定义上面的神经网络。" + "Sequential 允许我们构建序列化的模块，而 Module 是一种更加灵活的模型定义方式，下面分别用 `Sequential` 和 `Module` 来定义上面的神经网络。" ] }, { @@ -399,10 +233,8 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": { - "collapsed": true - }, + "execution_count": 6, + "metadata": {}, "outputs": [], "source": [ "# Sequential\n", @@ -415,7 +247,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -424,20 +256,19 @@ "Linear(in_features=2, out_features=4, bias=True)" ] }, - "execution_count": 14, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 序列模块可以通过索引访问每一层\n", - "\n", "seq_net[0] # 第一层" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -445,10 +276,10 @@ "output_type": "stream", "text": [ "Parameter containing:\n", - "tensor([[-0.4644, -0.4195],\n", - " [-0.3199, 0.1816],\n", - " [ 0.3588, 0.1743],\n", - " [-0.5447, -0.6158]], requires_grad=True)\n" + "tensor([[ 0.3485, 0.5085],\n", + " [-0.6388, -0.1725],\n", + " [ 0.4717, -0.2461],\n", + " [-0.1726, 0.4927]], requires_grad=True)\n" ] } ], @@ -461,46 +292,45 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# 通过 parameters 可以取得模型的参数\n", - "param = seq_net.parameters()\n", - "\n", - "# 定义优化器\n", - "optim = torch.optim.SGD(param, 1.)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "epoch: 1000, loss: 0.07597314566373825\n", - "epoch: 2000, loss: 0.06681923568248749\n", - "epoch: 3000, loss: 0.06246059015393257\n", - "epoch: 4000, loss: 0.05549143627285957\n", - "epoch: 5000, loss: 0.050142571330070496\n", - "epoch: 6000, loss: 0.04679693281650543\n", - "epoch: 7000, loss: 0.04454003646969795\n", - "epoch: 8000, loss: 0.04290143400430679\n", - "epoch: 9000, loss: 0.041652847081422806\n", - "epoch: 10000, loss: 0.04066724702715874\n" + "epoch: 1000, loss: 0.3075895607471466\n", + "epoch: 2000, loss: 0.3041735887527466\n", + "epoch: 3000, loss: 0.30135470628738403\n", + "epoch: 4000, loss: 0.25870421528816223\n", + "epoch: 5000, loss: 0.14440153539180756\n", + "epoch: 6000, loss: 0.10606899112462997\n", + "epoch: 7000, loss: 0.09030225872993469\n", + "epoch: 8000, loss: 0.08221166580915451\n", + "epoch: 9000, loss: 0.0778866782784462\n", + "epoch: 10000, loss: 0.07527764141559601\n" ] } ], "source": [ + "# generate sample data\n", + "np.random.seed(0)\n", + "data_x, data_y = datasets.make_moons(200, noise=0.20)\n", + "\n", + "# 变量\n", + "x = torch.from_numpy(data_x).float()\n", + "y = torch.from_numpy(data_y).float().unsqueeze(1)\n", + "\n", + "# 通过 parameters 可以取得模型的参数\n", + "param = seq_net.parameters()\n", + "\n", + "# 定义优化器\n", + "optim = torch.optim.SGD(param, 0.1)\n", + "\n", "# 我们训练 10000 次\n", "for e in range(10000):\n", - " out = seq_net(Variable(x))\n", - " loss = criterion(out, Variable(y))\n", + " out = seq_net(x)\n", + " loss = criterion(out, y)\n", " optim.zero_grad()\n", " loss.backward()\n", " optim.step()\n", @@ -517,21 +347,19 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": { - "collapsed": true - }, + "execution_count": 10, + "metadata": {}, "outputs": [], "source": [ "def plot_seq(x):\n", - " out = F.sigmoid(seq_net(Variable(torch.from_numpy(x).float()))).data.numpy()\n", + " out = torch.sigmoid(seq_net(torch.from_numpy(x).float())).data.numpy()\n", " out = (out > 0.5) * 1\n", " return out" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -540,13 +368,13 @@ "Text(0.5, 1.0, 'sequential')" ] }, - "execution_count": 19, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAABVRklEQVR4nO29eZQs+VXf+bkRkXtl1v5evf29XtSyBKIBIaEFLAlh1N0YGQE2aAYDg0973GCZkXxs0RqDrWNjGDTMGIONNFgHwxgQYyHTGIEAu43AbGqw9rWXt9R7r17tS+6x3Pnjl5mVWRmZlbVmLb/POXWqMiMy4heZWb8bv7t8r6gqFovFYrH0whn2ACwWi8VytLGGwmKxWCx9sYbCYrFYLH2xhsJisVgsfbGGwmKxWCx9sYbCYrFYLH2xhsJiOWaIyGURKYqIO8C+rxOR2cMYl+XkYg2FxXLEEZHrIvLG5mNVvamqI6oaDnNcltODNRQWi8Vi6Ys1FJZTiYj8YxG5LSIbIvIFEfkGEXFE5J0i8pyILInIr4nIRNtrvltEbjS2vav9Tl9EfkFE/nnbvh0uHxE5LyIfFJEFEXlBRN7Wtu2fNs71i43xfEZEXt7Y9kvAZeA3G+6mfyQiV0VERcRr7PN9IvK5xmufF5G/e/DvoOU0YQ2F5dQhIg8BPwh8jarmgW8CrgN/H/gbwF8FzgMrwM82XvMS4N8C393YNglcHPB8DvCbwCeAC8A3AD8kIt/Uttu3AL8KjAFPAT8DoKrfDdwE/nrD3fR/xJxiHvhmoAB8H/B/ichXDTI2i2UQrKGwnEZCIAW8REQSqnpdVZ8D/lfgXao6q6o14J8C3964c/924D+r6kcb2/4JEA14vq8BplX13apaV9Xngf8H+M62ff5IVT/ciDv8EvAVg16Mqv6Wqj6nhj8Afhf4ukFfb7FshzfsAVgsh42qPisiP4QxBC8VkY8AbweuAB8SkXYDEAJnMauIW23HKInI0oCnvAKcF5HVtudc4A/bHs+1/V0G0iLiqWqw3cFF5BHgR4EXYW7+ssCnBhybxbItdkVhOZWo6i+r6msxk7gCP4ExBI+o6ljbT1pVbwN3gUvN14tIFuN+alLCTNBNZtr+vgW8sOW4eVV9dNDh9togIingg8B7gLOqOgZ8GJABj22xbIs1FJZTh4g8JCJvaEyyVaCCcSP9HPAvRORKY79pEXlz42X/EfhmEXmtiCSBd9P5//Nx4FERmRCRGeCH2rb9ObDRCKBnRMQVkS8Tka8ZcMj3gPt6bEti3GgLQNBYXfy1AY9rsQyENRSW00gK+HFgEePyOQP8MPCvMIHk3xWRDeBPgVcCqOpngB8AfhmzulgB2gvZfgkTrL6OiRF8oLmhEXf4ZuBh4IXGeX8eGB1wvP8S+N9FZFVE/mH7BlXdAN4G/FpjTG9tXIPFsm+IbVxksewOEbkO/B1V/f1hj8ViOUjsisJisVgsfbGGwmKxWCx9sa4ni8VisfTFrigsFovF0pcTWXA35iV1JpHdfkeLxWIBsqPKl+TMsIcxVIpzzy6q6nTcthNpKGYSWd7/wGuHPQyLxXJMePKxJ/jqYQ9iyPzBTzx2o9c263qyWCynmvTTbxn2EI481lBYLJZTzdvfM7P9TqccaygsFsup5cnHnhj2EI4F1lBYLJZTycOPbCvMa2lgDYXFYjl1vPpT7+BR523b72gBrKGwWCynkNe9szLsIRwrrKGwWCynig+8963DHsKxwxoKi8VyqvjEU2PDHsKxwxoKi8VyarBZTrvDGgqLxXIqeNX7XzbsIRxbrKGwWCyngtd/0Mr67BZrKCwWy4nn1Z96x7CHcKwZmqEQkUsi8rSIfFZEPiMi/yBmHxGRnxaRZ0XkkyLyVcMYq8ViOd7YdNi9MUz12AB4h6r+pYjkgb8Qkd9T1c+27fMI8GDj55XAv238tlgsloGwAey9M7QVhareVdW/bPy9AXwOuLBltzcDv6iGPwXGROTcIQ/VYrEcU6zLaX84EjEKEbkKfCXwZ1s2XQButT2epduYWCwWSyzW5bQ/DN1QiMgI8EHgh1R1fQ/HeVxEnhGRZ1bD+v4N0GKxHEusy2n/GKqhEJEExkj8B1X99ZhdbgOX2h5fbDzXhaq+T1VfrqovH3OT+z9Yi8VybLDKsPvLMLOeBPh3wOdU9ad67PYU8Lcb2U9fC6yp6t1DG6TFYjmWWGXY/WWYWU+vAb4b+JSIfLzx3JPAZQBV/Tngw8CjwLNAGfi+wx+mxWI5Trz6U+8AG5vYV4ZmKFT1jwDZZh8FfuBwRmSxWE4CNoC9/ww9mG2xWCz7hZUQPxisobBYLCeChx8JrIT4AWENhcViORFkvsMq/BwU1lBYLJYTgVWHPTisobBYLMee9NNvGfYQTjTWUFgslmPP298zM+whnGisobBYLMcaK9Vx8FhDYbFYji1WquNwsIbCYrEcW6xUx+FgDYXFYjmW2F4Th4c1FBaL5VhipToOD2soLBbLscNKdRwu1lBYLJZjhZXqOHysobBYLMcKG8A+fKyhsFgsxwYbwB4O1lBYLJZjgw1gDwdrKCwWy7HABrCHx1ANhYi8X0TmReTTPba/TkTWROTjjZ8fOewxWiyW4WMD2MNlmD2zAX4B+BngF/vs84eq+s2HMxyLxXIUsQHs4TLUFYWqfhRYHuYYLBbL0cYGsIfPcYhRvEpEPiEivy0iL+21k4g8LiLPiMgzq2H9MMdnsVgOEBvAHj5H3VD8JXBFVb8C+NfAf+q1o6q+T1VfrqovH3OThzU+i8VygLzq/S8b9hAsHHFDoarrqlps/P1hICEiU0MelsViOSRse9OjwZE2FCIyIyLS+PsVmPEuDXdUFovlMLCxiaPDULOeRORXgNcBUyIyC/wokABQ1Z8Dvh34eyISABXgO1VVhzRcyxFCVSmXIoobIa4rFEZdkqkjfd9j2SE2NnF0GKqhUNXv2mb7z2DSZy2WFhopt27UqVYimrcNy4sB0zMe4xOJAzlnGBjDJA5kcw6OIwdyHovhA+99Kzw17FFYmgy7jsJi2TEry0GHkQBQhYW5gJG8RyKxv5P48qLP4nyANA6rwPmLSUby7r6ex7KJLa47Wti1uuXYsbYaEueAVIU7t2psrIfsl4eyXApZnA9QhSgyPxrBnVt1fN96QQ+CJx97YthDsGzBGgrLsUOj3tuqFeXu7To3X6hRKYXcuVXnxnNV7t2pU6/3eWEPVpaCeKMErK8GOz6epT82HfZoYg2F5diRLzjQx7ukkTEYN6/X2VgPqVaV1ZWQ68/VqFZ2ZiyCXqsGxa4oDgCbDns0sYbCcuyYmErgebRiBoOiEczd2VnVfjYX/y8i0nubZXekn37LsIdg6YH9pluOHa4nXL0/zeS0h7vDdIxaVYnCwVcC45MJnJiYtZcQ8jaYva+8/T0zwx6CpQfWUFiOJa4rTE4nuHQlteOVRT+31Va8hHDlvhQjeQcRcBwYHXe5cl8KsSmy+4btNXG0semxlqEQRUq9pnie4O0hnTWVdhgdd1lb2cyEEiE2AA27q4FIJh0uXE713K6Rsr4esrEe4jrC6LhLNmdXGzvBpsMebayhsACm0nl1JWBlKSQMlHTGYepMgkx2fxedqsrSQsDyYtCa0DNZh/OXkrju7gzGmZkEuRGXtZWAMISRgkMq5XDnVh1Vcw4RcFyYOb+/BXlRpNx8oUa9pi3jtLEeMj7hMj2zd3HKcilkaSGgXlOSKWFy2jtxRsimwx59rKGwADA/53fclZdLEbeu17h0NUkmu38T0+qyMRLNCbx5rtkbNa7cl97VMUWEkbzbVQB37cE066sB9bqSyTjkR919r6heXQ46jASY61pZDimMRaTSuze062sBc7f91rGDQKmU68xcSFAYPRn/uq96/8vgg8MehWU7bIzCQuBrh5FoomoMyH6ytBhfl1CrKrXqzusc+uF5wsRUgpnzSUbHvQOR3VjvU/y3sR5ueU6JosEC6arK/F0//jO56+9bQeGwsemwx4OTcVti2ROVStTTr1+t7N+EpKqEPWrURMCvK6kdLipq1YilhYBKOQQBQXA9GBv3KIy5yI4j3WaCX5z3CXwlkRSmziR2JddRKoYURl28hDA/57eMSiIpnJnpf0zfV6IedjOKzHuVTB3vYHr66bfAe4Y9Cssg2BWFBbfPHOjs4zdEpHfgWpUdT3yVcsiN541kRxBA4JsJtlpR7t31uX2zvuM775Uln7uzdeo1M1HXqsqdW3XWelRhG2MUf6xqRbn+XI3rz1U7Vh5+3RyzVAzjXwjbrn5OgiihTYc9PlhDYSGTdWINggiMje9v4HRq2uuaWJvFazuVCb93p9s100TVxD7KpcHdWVGkLV2nrcdamOt290SRkko7eH3i46rg17tXa6qwON/bred5QjodbwxS6b1lih0FbAD7eGENhQUR4eKVFK5rVhAi5ieTdZg8s/MsoX6++NFxj+kZD8fdPE++4HL+0s4yhKJIqdX6rxZUobje+659K/W60uuIUQRB26JiZdnn2c9XuXOrTuD3X5X1olbtP/5zl5J4CZDGf6k44HlGufY48/AjViPruGFjFBbA1CPc/1CaUjEi8JV01iG9w4ydKNKBfPHjEwnGxj2CgIZx2vnd8aChB9nBJbiu0NNSsOmGKxVDFuY6M7fCwe1RC8/rfxGJhMN9D6YpbkTUaxHJlNMo/Dveq4lHnbcNewiWHTLUFYWIvF9E5kXk0z22i4j8tIg8KyKfFJGvOuwxniaaaaZjE96OjQTA7I36wL54ESGRkA4jEUXK2krA/JyJCfTLEBIR8oXtb+MLo4Pf6icSQioTPwmnM9Kq81jukbm1U8Ynt3+Pm9c5OZ0gX9hdcP4oYdubHk+G7Xr6BeBNfbY/AjzY+Hkc+LeHMCbLLqhWoq5mQrC9L75JrRbx3Ber3Lvrs7IUcu+uz/NfrPaVBj97zogD9sNL7OwrfuFiKlbbqVrRlvKsX9+fTLBeWU2qSqkYsrIUUNzYv94aRwHb3vR4MlRDoaofBZb77PJm4BfV8KfAmIicO5zRWXZCvxqI7XzxYBoBReGmK0cj4865O9tb7dX1hEvXektrNLWZdoLrEet+Ut1Unk1neivK7oSVpe6VVhiYTKnbt+rMz/ncuVXn2c9XKZd24ds6Ylg9p+PLsFcU23EBuNX2eLbxXBci8riIPCMiz6yGO5OStuwdLyE9xfa2y9Dx61HPu/RqRan16SGRTDpkst3HF4GRws4rsavV3gHtWlUJQ2UyJnMLzHXuxFiEIV2rhbk7JjW32Zyp2Vnv1vX6QCuzo4zVczq+HHVDMTCq+j5VfbmqvnzMPd5ZIceRbM6J1WoSgYnJ/nGC7Twr15+vcftmrWfM4vylFKmUtFYQIuauf+bczjO2ROgb0BYxgf+Ll5MdmU6JBFy4lGRiKt6IxJFISEfMIYqUYrG3UVxaCI7tysJ2rjveHPWsp9vApbbHFxvPWY4YIsLlq0lmb9bx69qq9B6f9Bgd7/yahaERIKyUIhJJYWzcxXH6Zw4VNyJuvVAlk3OJQsjl3VYGkOcJV+5PUa0ovh+RSjm71lhK9rnHaCrPqipLi0FHjMH3aehVpQgCZX01bL0Hzd/tBlEEps52vi9RZBZl/ezm6nJ4LEUBrVTH8eaoG4qngB8UkV8FXgmsqerdIY/p1FGtRize86mUI1xPGJ9wGSm4lDZM8Do3YorlEkmHaw+kqVUjwtAUo21dZfj1iBvP14iizYlzbSVkbMJldTleN2lzHFCtGmuyvhaSTAmXr6VwHHNnnskKmT0uklcWe4/h7Dnz71IuRVRiAvdBADdeqJEvuFy6lkIjI6OeSAjz9zZFF10Xps96XcJ+rmviLj3br2KM7HHDSnUcf4ZqKETkV4DXAVMiMgv8KJAAUNWfAz4MPAo8C5SB7xvOSE8v1UrEzRdqrUkxqivzcwHzc0HLxbJwzzTzOTOTQERad/NhqCwt+JRLEYmEMDbhsTjvd60cVGF1JeTSlSRLiwGlPu6X9tfUa8ryYsDULooCe7Gy3EuMyhiCZArKxbAVQ9hK4Jsg9epyyKWryVa1eb7gmtRhzMph4V6A6zkdNSYiwtlzCW7fqscuK0QglRHu3TWrtkzWYWzcw92mHmPYWKmO489QDYWqftc22xX4gUMajiWGhXv9ZTKarK0Yl0iztsH3I248t2XlsNrbtyRApHDhcpJnP1/tmTq69fzLi5uy5dmcw9lziR1LgbTTy/0lQkvQ0Bmgb4Yq3J31ufagQxCYGpNWRlfjPHdu1bl6f6pjvCN5l0uXjQuv430XUzy4utQpBb+8FHDlvhTJ5NEMN1qpjpPB0fx2WY4MlfJgWkmqpjdDk/k5v5HVs7PziQgTU4Pfv2zta3Hj+Rp+H9fNdqR66CuhpugOTBHfIAHrIFACX1ldDmLjDqqwstS9gsmOuDzwUJqJKQ8vIXgejOQFjTrfT1WIQqN5dRSxAeyTgzUUpxhV3baYK674rBft/vPSxs56Syi0uulNTHlMTu8uYBtFRgF2txj3WedzzVTbROOuPZF0OHNucGNWr0c9I9T1HmnBjitMn01w34Mp0lmH4rr2NLrlUsTSot8qCDwq2AD2ycEailOIqrJwr86XPl/li5+t8vwXq2ysxfvmx8YHS/cUgdyImdzrte5A79Z9248pYlqUNmseRISpM0nOnh881bSdyg4UY7eSzblcuJxsrSxc1xiucxc24yCmB8b2aapeQkgkHTIZJ/46ZHOVEketFnH92SrF9e2vZ/FewM0XaszeqKEDNkc6SNJPv2XYQ7DsI0c968lyANyd9RvSEOax7yt3b/tG62mLftLktEe1GlFuBpiF2ECu48LEpEelbFqo9qN5XhHjxpmY8mLjCmPjJji+eM8nCMz+nmcygxwHyqX4CdFL7i24mxtxW0ZvK1Gk3LxeIxqgnKGp8jo67pnOflte44gRSIzDr0fcbGSHDUpTWn15KWByen97g+8UG8A+WVhDccrw61GHkWiiCvP3/A5DEYZGpM8RoTDmkkgIyZSphF5bCRvpnspIQ7TO9YS567WB4xImcynqG3weHfMojLqteoRmgVrgK89/qdp1LhFTu3FQFDd6Zzy14yU2pT5cV7hyLcXcHb8V80lnhJnzyZ5V61vrNAalGSsapqGwAeyThzUUp4xqdbMYbit+3cQsRIR6LeLGC7VWAFUEELh0JYnnOUxOO12TURgq9W16RMSNx/eVRB+ZD5FuaQwvIVy4nOTOrTpKo1BNYXrGI5s9uII03+8dK2hn64ojmXK4fC1lqst1+8ypQZMIYs89xFDFq97/Mvjg8M5vORisoThlJBLSc6Jz3c079ru36x2TnSqgcGe2zn0PpmPlrncTT1AR/sfIg2TSwgMbN8lE/d1W7eQa2UHlsomJZLPOQKmrg+LXI1ZXwkZ/DmF0zMivixPvfmvHpAVr1/s0qPaU58mOjW6TZlLAMHj9B1+L64dki6YWpDKSJEgev0pySyfWUJwyUmkhkeyehERgrOGyCUPTdzqOMDCFbnFppI4jZEeczXjGAASOx8fPPYwjyp9PvIxvmvtDLlbmB369ONIznrAXNtYC7sxuZk+tr8HyQsDlaykSie0n8Xajuxsmpjwq5frO04sdmJ4ZnttpZKXC+HzZPFAYWyizMZZm9Ux2d3cS+0l7cMyyI2zW0ymj2fZ0q4heYdRlcpD6hf5N4Izf3RvsfzF0XZ7/K1+Nui6h4xE4Hr939jWEQ/5a+vWow0g0CQK4c7vO2fMJ8qNuT7VcEZMEsBNUTc1FGJh3NzfitlRqHWfzc+qF65rq76v3pUjtoeBwL/zyj30X4/NlHMX8YH7nV6ukS8Or9UhUA2aur3H5C8tc/sIyU7PrOMHRSiU+6tgVxSkkkRCuNjSZgsBoMrW35XQcSKbi75odgVSqe8aqVky2jV+PGMkb3SffV0rFeAnxUn6MF178lSyeu9LxvCLczp7hcnluH650MFSVcqnRAjbjsHCv96RWLSuz1+skU8J9D6QQgXt3fSM70lD0m5jyGJsY/F+rVAy5d8cnCIzEeSbjcO5Cgslp0zK2XI5wHMhkhXt3AzbWQlOpjfmsLl6NNw6q2mq45CWEkREH2UXb2UGZ/VCSgla7nncU8itVqiMHq+oskZIu1XEiqGY9woSLVw+ZubGG0/YVzBZ9kjfWuHNtzHyhLdtiDcUpJpV2aG/7U1wPmb/nm4k95v9HBM5dSHa5VNZXA+bubEp9VCuK40RcupbizIywvhqyumJkNgqjptXq++//64Sx1XxKIIf3tazXTDpvu9TIdu4eVdOb4vbNOlfuT3HhcoowUIJQu9q7bketGnF7i1xHpWwSCe57MI3rdbZ8PXchydR0RLWiuJ6JR8S5uKJImb1RbxXhNWtXLl5N7arN7XY8+dgTTNwt9lpk4RxwbUe6VGd6dqNlrAVYH0/jhBGyNTMOcIOIbLFOudC78ZVlE+t6sgAm7fPObH3z7r/xK5Ewk9HouMvV+1Pk8p2TexQp9+5260FFEdy7U0dEGB33uHJfmqv3p5mYMoV15yv3YiPCkbic30GMYi+omsk0CGgZip3EBOp1bXXvcz0hlXJ23ChpaSG+/3YUwsZ6fLFGIumQH3XJ5nr30F6857cUbpvNj8IQbt+o7Xtr1aZUR2UkSRQznEigPHJwcRMnjJie3TDursisYKSxikmXgljj5SikKj0EIC1dWENhAXqL//k+5PIO02fixfb6yUZUK9qz2dCrlz5OMgpw2qrQvCjgq1c+TTo6uA6FFSfFF/JX+Xz+Git+imAPst0iRs9pL9Rq8e+fKtT7tJfdjtXVMDaYFEZ7S72NoynVURlJUE+5HcYiEgg9h+JYel/P2U52Pf77YgxHfMfCSCDYYT/104x1PZ1S6rWI+TkjAS7SP/d+aT5gaT5gesbrqiQWkb7BbVpVDp2M+Rt8++xH+MToQ9xzR5lamOVyeY7LyQ3YxxTXdj6Tv58/mfpKBHOx0dRXc1/0F1x87rOxow49Dy8IelyBUbuNi9fshGRMBhoYIzSoCm4UKRtrIaVihJcwsiu90neF7hqPvdDRa0KEe5dHKaxUGFmrgUI5n2R9MoO6BzcpuzHupSbqNOqAtm4XKI1at9OgWENxCmlvHgSD+eQBFuYCMlm3w8edzgiOQK+557kv1jg7k6Aw1v1VywdlXvKFP+fMvHEB+ALPKZw9n2A0Zv+9sPGLb+Gj7040gpqb7rPnH/oqCkv3KKwudey/MjXJp7/2lTz48c/j+T4TC7dx26xp6Lp4oxkSyb3NuhPTCUrF7mp2cTCZVW2EoVJcDwlD04sinXGIQrjxfI0g3Oyzvboc4iVMb4ytqEJ6H+ssuqQ6HGF9Msv6ZHbfzrEdtUwClUqXMVCMO6yW9pi4V2pZexVh/mKe6ACN10nDGopjjjb6LAe+kspIQ4Cu/13uXuUhZs5vZq+ICOcvNfonxBwzCmHujo+XlK6K6Uo5ZHG+zUff+H3vjk8m47TuqMNACQIlkdxZoLhdSmL8XxXJa3cxX+S6zF77K7zkf/xR67nA8/jYN7yBuSuX8b2zuJEydec693/2L0iXNwi9BLPXXsyff8PXUSlk+HD003z8t3f3r5TJOMxcSDB/1ydqFDUmksL5i8mOay2XQmZvGBdLs1I+k3XwEnTJqqtu9s5oRwTGJ1w8TwgDZXU1oFKOSCaFsfF4va1+HBWpjmrWo57ySNaCVnaTAuoIa5MZwoRLuZAiWfbxghAVsUZih1hDcYypVU3GTnsQNpUWLl1J9a1Q3ouPOs4nn8253Pdgmnt367FKp6qmWC17pdNQrCzFtx01He+MXtHc7Xpn6um0x+SU12UMS26a50YuU3FTfOTLX0k11+kic8MoPiNHhIXzF9h4fpR0uczymWn+8uu/jvlLFwEojqXIr1RZPH+VxfNXkShCRQg9h0re+N0fdd4Gj8GP/da/6f2++cryokmjNe1kPUYKxqgXRj3yBZd6TRGHriZEUaRdmVGq5nPstRps1nKUy5FJj/VMn4/CqEu9TXBQFUqYVcj5S8mOjnv9OFJSHSLMXy4wulhmZK2GREoll2BtKouoSZt1wojJ+RKuv/n9rOYSLJzP2xTZARh2K9Q3Af8K4wv4eVX98S3bvxf4SeB246mfUdWfP9RBHlFUldmb9a6ObLWqMn/P77jr30oveYjm5OL7Eeur3ZOQkRKPvxPzGlk/ReKNUK0aEQba0bazXyA4DODOzTrlSqOXQ2PX5YUA14HxyU1D8EL2PP/l7KvwXQ9HYfr2BvWUy/zlUbQxCVRzSTJFvyOfHkxQc+XcJL/+d/9O7DjWprKkKgHJamDG4DoN10WhqwKueYe91WD49Yjrz7cpztaVaqXOaNnl7DnzOZkWsvETVqkY9Wx81AvFrEwuTXf74e/d7f7emI58dR54cbw8y1aOWq8JdYTVMzlWz+RAlbH5MjM31ja3i+BE2nGzkC75jC2UWD07cvgDPmYMbf0lIi7ws8AjwEuA7xKRl8Ts+gFVfbjxY41Eg2pFOxoFNVHF9GbuM4tMTPbu8zA67nHmbBI35hbC82TXsYMggOe+WGX2Rq017txIfJ8GE8gVKk0j0YaqcZ01qYvHfz37KkLHaxkBRyFZCyksVVr7lQopQs/pMGMmYO1Q6pORo45w73KBe5cLrJ7JsnRuhNsPjFPP9H4ftrpkFueDrgCyqmkfW69vv7qLQu1fDh87cMjlulcHqtpTYiWK4IufrfLFz1W4d7feM2PtqHeuG5svk1+tblaIN7Kftn7VTNV4bedtGE8hw3TUvQJ4VlWfV9U68KvAm4c4nmNFFPPFb7Ld9z6X75aHcBzTr9rzBMcVrtyXpjBmBPBETIrs5WvJvjGCWqV/YFfV3B3P3jSxgrFxL7aDnuNCItlbsiIMaBnCG7nz1GOsmqMwsrZZJayOMHd1lOJ4mtAVQlfYGEszd3Vz1dETEeqZBBsTGcqF1Pb702ksSsXe78sguliZXO9/U8cBd4tkiohR0W1fve0EjYwRM27N7i/TUVtNtCORtoxEx/O99m9brVp6M0xDcQG41fZ4tvHcVr5NRD4pIv9RRC71OpiIPC4iz4jIM6vhweXhHxXSGaenQTA6Tv0nicnpBPe/KM3M+STnLia570UpHKfp9zZy45W2xkDlYtRwdcWfNPCVYo9GQlupVZRa1fjqr96XJpfv/BqGocmw6hVwNxOjub4/+Z5X9zyPbHl95DqsnM0x++AEsw9OsDKTO9Cg5pOPPcGr3v+y3p+FmOym7UgmTdA6jiiC8xeSTE57ZHMOhVGXS9dSPRsihaEpotwOVajVdN9rLg4a14+vH+lFkHBsjGIAjnow+zeBX1HVmoj8XeDfA2+I21FV3we8D+DFmbETf4/guiY4ubzYWdkrAmfOdc4EqqYB0fJSSBgYPaOpswkyGVPhW1wPef6L5i5fMf83jitd2TS1qnLvjs/5S93xj8UFf/B/UDFVzam0mfT9rfESNa4qx4mv75hqE9z70pdGucBq1z4mNXK4Xd7A3H3/o7eXmf/JT3UbdmXg4PHWmEI71ZoyOZ1gcrr/MZpp0f2O1TG8yBRUZttcWEcl06kDVUZWq4wuVnD7FFBurYeJBFbOHF4a73FmmCuK20D7CuEim0FrAFR1SbWV0/jzwFcf0tiOBZPTHjMXEqRSgutCdsQ0x8lu8U3Pz/nMzwX4dSWKTLvMWy/UqJRDarWIO7N1oqghY9GQeogT8gMj9RHnuy72kJuIRU2hGRiDsdUgNYkzEiK0uvC96v0vI0y4rI+lO6qBFYgcYXX6aEwC7wneQDqz2Xypqbt07mICd8DiQq+HG0nEKMcOwvycP7CRALPaae/Ad1RjEyMrVcbny3ihccc2EuQ6iIBa2iXwTIFoPemycCFPJW+L7gZhmCuKjwEPisg1jIH4TuCt7TuIyDlVvdt4+C3A5w53iEebZmplYbT3xxj42mhZ2vm8KszerO+qSjeKzN1+51gGfLGYIr1Uo2gviujZca8X62shE5NOy1e+eiZLLZsgv1LBDUxq5MZkhtA7Grnykefxcz/wv/GuX/sZyqUQ13MoFNyebVDjGJ9wmZ/r1oVSTC1GFGlH/EhV2VgPWVoICAMllXEol+LdSM3PrivLjc4Vz5GMTagytliJjUm0wg+NKuzlsznbi2KXDM1QqGogIj8IfASTHvt+Vf2MiLwbeEZVnwLeJiLfAgTAMvC9wxrvcaVSiXpOxLsxEq4bfwdbGHNZXor3D7f/b+ZGHGYubLqudiqBoWpiHFtPUMknqeQPVsZ6T4jwL/7W3+9ba9GP0XGPSsVIdZjjmdWf68D158yieyTvcva8WaUsLQQdbsntgua5vENpI9pc9Thw8XJqxyKHh40bREiPuwwVWDiXp5ZLoAckC3NaGGqMQlU/DHx4y3M/0vb3DwM/fNjjOkkM6pYYBJNNk4gNzk5OJygVI+q1zZ7SIkaOo1Bw8X1TQ7HV1eI4wvSMx/zdeBXVuDEk96ivdFC49ZDCcoV02Sf0XNYn0l09GF79qXfwx1/+f+742CLCuQtJJqciyqUI31dWloIOV9LGRoh/PeLC5WRX7Kr/wY18eRRBtRzhuN3y5R2aTkeIfskIAtSznjUS+8DRWJtbDoxM1ulyEw2C65pJPpkSHMe4iy5cTvZ0czmOcOW+FOcuJMhkBcc17qlyMcIPlGTKaRmJKFIqlYhazWRYjY0nuHA5SSbnmAY7eYdzFxPxXgKB0TGPhx/Zm0S064eMzZeYeWGVqdl1UuW9dWBL1ALOX18jv1ojWY/IlH2mb2+QXyp37Pe6d1Z6HGEwkimHsQmPcimmqr2RqbS+Hu7Iw3Lugkl79jxhpNBfvvyooY5QKqS65M0joJJNEB0R9+Nx56hnPVl6UC6FLC8G+L4RiJuY8rqkH2Cz9emt67WWltB2d5rZnGOMRNJhbHzwr4iIUCqapjrNc6yvhRQ3Qq7clyKZclhbCZifM5OyqgmWXriUJDfidvW+dhzh7u26GTPG8Jy/lMRLCD/8N/42PDXw0ECVdNknVWk0UFo2fm3BFOdlSj4rZ7IUxzM7OOgm4/fKyJbaFkdhfLFCaSzdcef78CPBrrWhmvTq2a1qUosHJTfidDRG6kWX+N8h4wQRI6tVUpWAIOGyMZEmSJpxr5zN4YYR6ZKPiiCq1DIei+dtxfV+YQ3FMWRl2WehLbBZr4Wsr4VcvhbfvSyVdrj/oTSlhnhgFCqLPRrm3PdgikSMwRmEei1ifa37TjeKYGHeZ3zC62py5NeVm9dr3P+idJc/fCTv8sBDadMcSAarD2kikZKsBKgj+EmHszfXSdTDDoVRafstCuPzZUqF9K5cFemyHy9FLpAqBz3jJxopGxthS49pdGywQjnXgz237RBaSQVHGa8eMnN9DVHFUVB8RtaqLF7IUxlJosDqdBaZMJpOyVpIuuQzfbtIcSxFOd+netMyENZQHDOiUDuMRBONYP6uz+Vr8el+ItLKYFFV/MBkQ5mNgJq79d0aCaBnVg0YF1QUxhsnVdPNLU4eRERIZ7r/yT/x1FjPc42sVBifL3fmSeoAflYR0hWfyi56O6vE9DygMYQtJ37UeRs/xr8hCJSbL9QIfG0pwi4uBFy8nOxKcd6K6wr+HkuKBXbU23tYTMwVOyQ4moZ98k6R1akM44sN917MZ50q+0y2fTb1lMPSzAh+Zvg1NseJo387YemgmcUUu61RVb0dIsLZc0muPZDizLkEM+cTPPBQeuDir144Lj21EhxHetZmaNS7biOOfvn86ZLP+Hy5oy2mM4iRMCNBd3njWSqkYuUQFaGajZ+U5u+a/uTtvbo1gju36tt+js0WrLvFceHilSSJHaToDgVV0uX4dqaiyvhC2XzObS1Q2z9rB1ouRuNmjDh3Y5108eSrN+wn1lAcM0T6FEDv8H8+0YhBFEa9vrLkg9LL0IjA2ITbUx1VnJ25QPrl8xeWunPqByai56TeRMKIRDVAwk6zsHImS5DcbAMaiflZuJCPdXuoGpdT7DB0ACn4PXxcngf3v6i7MPO4IY2bgI7ntntN42fyzoYVA9wBfdedIlIAplX1uS3Pv0xVP3mgI7PEksk6PTvK5QvDzVZxHBOYvn2zs8FONmeC7bWqxnZz81yT6TQIHWmaqmQ36uSXq7hhRCWXwKsPHsjdKukgAslqQD3OLaHKxFyJkfVaK2BaLKRYnjFFXOo63L02Sqbok6r4hAnHrDL6aUn1mKeE7eewfMFlfXVnhTDNivDzl5I4jVS45srlyGY5iVDNej1XFbvFiUzsI0gdfdfbUaDnuyQifxP4v4F5EUkA36uqH2ts/gXgqw58dJYu2jvKNTOYREz20JmZ4ftdcyMu9z+UbmvZ6ZJptN5MZ4SLV5LM3fFbrqbciMPM+eTAE1V79s3YfIn8aq11V+mtbupVxR2t/fnYfdSsSBYvdr+PE/dK5NZrphFOY3LNrddAYHmmkV2zg8K/zH/7NjJXfyV25aBqqq37MX02QaUUEQS6rVFJJk2cp1yKCAK4+UK9FfepNooX8wWXM+cSPaVChsnyzMiWYLaJCYWeQ8LfZuXVj6NqHI8g/czpk8BXq+pdEXkF8Esi8sOq+iH2tPC17JVszuX+B9OsrQYEDZG/fN5FjkgVresKoz3SarM5l2sPmF7P4rDr1qZuPewwEhCv8bOVwBVUIBHTNKmZKtv1fKTk1mpdbg5HIbdWY2U6ZzKlVEmXfNzQpGc20zd7cfZcghsv1DpayDYlwrdzBXqecPWBFBvrIeViRBiZPhNxzaZG8g4rK2HHeapbqts31k3m1bUHUrHfo5/6h3P7nyKrSqIW4gYR9bTXs+YhSLrcuX+M3GqVdCXAT7oUx9Ik6iFTtzc6Ppe4z3/r1SgQJJ1tPx/LJv0MhdvUWVLVPxeR1wP/uSH1bZ17Q8b1hImp4a8gdoOIxDZG6sdW1dJMjwK5do2f+AAorE5mmFgod038CtTT3QNzgz53rdKQkfCVs7fWkTbBxHI+ydK5kdg717e/Z4YfSztcvT/F8mJAtRzhJYwi8KCxA8cx6bSjYybN9vrztY7gOJjCyTDU2H7mWwkCEzfppx02KKmyT37ZqLlWcgmK4521JG495MzsOp5vWss6qmyMpVg5E6/HFLkOG5NZNtrHm3RZnskxPr9Zw1LJJiiOpkmXjfszVQlaxr/53YgEFs/n93yNp4l+34gNEbm/GZ9orCxeB/wn4KUHPzTLTvDrESvLAbWqkkqbnsxbU13LpZDF+YBa1UxKk1Me+dGjX4X76k+9A7ZUNEeO9FxChK7gNOSmO2IQGLeRF0REjiBhZ4GcCqxNdhfc9RUXjEBRZm6td0lcZzfq1FMVNiZ7q9gmk07ftrWDIo5w5VqKpUXfdDjEuJMmpxPM3qht+3owLq9qOaIw2r2t+vpfhwElxvNLFcYWy8ZNh4n7jC5VUGlM+GMp8qs1PL/Rx7xh2UZWa41iusGLHkujaUqFFG7jM9WGMaoUNt/TRDUgv1pFgohaNkFpNIUbKlOz62QaRXqlQorV6Uzr9ZZO+r0rfw9w2tuTquoG8CYgvsGwZSiUSyEvPFtjZSmkXIpYWQp54blah/+7VAyZvVGnUo6IIlPZO3fHZ2lhb1IYB80H3vvWWNmLykgy1khEAsWxNOWRROyKwlGzGimNplqS05FA4DksXMwTeQ5j90qce36VszfXyGzUUYGNLVLmTQQ4f2OtYyXRfq7CSu9Jer97OziuMH02yf0PZXjgoQxnz5mOhXEV+3E0Y117GkMQMb5YbqWkwmbaqhtBwo8YW6hsGon21yoUlqtbDznQwMOE23OS99MeyzMjLF0sUJzI4ETKzPU1so0e6m6kjKxVmbm5bjOhetDzG6Sqn1DVLwG/JiL/WAwZ4KeAI9i95HSiqty97Xd9vzWCu7c38/G3VkSb18LyYtCza92wefKxJ3oW1qkjLFzIt9JQmxN+Pe2xNpkhSHk96hogWQ0pLFfxAkWBUj7J7ftG8ZMu515YpbBSJVkPSZcDpu5sMDZfZvVMlo1Cqss2CaaTXlyxHYAT9vf5HEaPh4mp3j3SOxAo7LInepNMKb4MsEPapM/r3W3er/2gsFzt6qHtqMmCyhT3pvl1UhnkVuOVmAZDf4zpIXEHeM1BDsoyOL6vhDGBWTC9KILAiPD1KmgTgVq1+58zDI3Ux36hqlSrEbXqYEWBg9xtV0eS3L5/nNUzWdamMsxfLHDvcgEcoTiW6plyIW0/DpDbqJMuB4wtlHHC7gkkv1o1AddcoqvKunm8OBSoZfpPvIfR4yGdMdpdzd7ozT7ozZ7p4phYxsVGz/RePP1tf7TtubT5xu6S+iEEmHvJrTjKnsUhTyqD3D74QAXIAGngBdVBQmOWo4CwOSn0ks9oz7CpViPu3a5TbVT+ZrIOM+cTJFO7992WiiF3Z+stUULXhXOXkmSz8ZPCTlwykeewESPkFyZcFi7mmbpdRBr3uFt7aDdxFEYaGTW95rhMySfcxn8dSWcBmAqsTue2vYYnH3ti130qusYQKWEInktH9tLomEe+4FKtRjgipNKCRpuV/ltlxXdbX1HJJQZOddmacBCJaUK1H0gYkVuv4/kh9bRHeSTZ6o0deg7EZLdFAmHDUKZLPiMrFZxIqYwkKY6l0SOSVTgMBjEUHwN+A/gaYAr4ORH5NlX9jgMdmWUgEgnBS8TLYySS0vI550ddNmIE+xIJaTUPCnzl1gu1jhaklXLEjRdq3PdAeiCxuq3UaxG3b9Y7zhsEMHujzn0PpLtabe7nHXY1l2T2wXFSlcD0p16tMLIRf8foRP3lO1SEao9JsJnXX814JGsBTmRWEqvTOerbrCia7NVYqCrzc36HftfEpMfktNea7B1HOoyzuHQp9tbrEfN3fUqNRkcjeYcz5waX+lDXYWkmx+RcqRXMjstAU4HiaJqRtSqiECQcls/mqOb2HthPVgPONuINjhoDMO46zF0pNL4L2jMrrjSaNvU5K9XW+FOVgPxKlbtXR09tsHuQq/5+Vf0RVfVV9a6qvpmdCTz3RETeJCJfEJFnReSdMdtTIvKBxvY/E5Gr+3Hek4SIcP5i0rgQpPmccSmca+skd3YmQSotrdWFOEbK4cLlzWK3lWWfmJgsGsHa6u6C3ivLPRroKKyubB7z1Z96x8G4YUSoZRPUcgnKMX0LwEwk5XyS4mh8wBqgPJJAHWHx3EgrJtK4DOPCUkhXAoKEx51rYyxcLAxsJJrsNritqszdqbO6bG4EmppRy4vBjpIVgkC58XytZSQAihsRN56v7sgNWR5Nc/faGGsTaTYKSWppl4iGrIljfuYvFViZyXHrRRPcfGiCO/ePdzV52hWqTM9u4ETaWt05alKYz72wyuTdIpmyeU8U07cicjblVpxIya9Uu4LxbhBRWNpbL5HjzLbfZFV9Jua5X9rriUXEBX4W+EZgFviYiDylqp9t2+37gRVVfUBEvhP4CeBv7fXcJ410xuHaA2lWV0zqazrjMDrudfibHVe4fC1FtaKt9NjcSKe7oVrR+DtmNS6K3dCvb0Jz2wfe+1ae3GNDn4HGkvK60mIjgSDhUhpNA8blkKwFiNJaYVSyHjM31lBHKI6lWZnKMLFgxrs1npGqBpx/fhUEynkj8dHXZaFKqhyQLdaJHPjRNz7OP/v99w10Paqmy93SQtCxCmw7NMtLAZNT3kDFmKvLQWy9RRTu/EYhSLqsndl0uyVqAalyQOSKkQZ32u5qdkBnXwqHjYlMR+FcohbGJhAIRrZD2h6D+bovn8lRLqRQR8gvV2L/Bxw1saz2azpNDFPo5BXAs6r6PICI/CrwZqDdULwZ+KeNv/8j8DMiIjpINPSU4SWEqTPbCNqJkMlKS1JjK8mkUC7FvZCBUyy3kk7HH1PESHo8+dgT+7Q+7U+zp0Ez26X5BapmPBYvFloT170rBdIln3TZRx1hZKVKphy07k4TcyWzIutxnlYsVyG7UcMJIxYuFeJ3VmX69gbpkt/KmiosV/nxV34v7/yzX9j2mporhr7/DQpBCIkBPr5yubuyuzFMKmXd04rPT3n4e9RV8mohMzc6pTxG1mqtvhTQkFfpUV8T+5lJw+3Ybkh7vP40M0yH2wXgVtvj2cZzsfuoagCsAZNxBxORx0XkGRF5ZjW0EsK7YXwyPo1S2H3fgrHJRGwrVhH46b/5+K6OuRvG50vdPQ0w7iJRxauF5Fcq5NZqJr5wJmf6GrS5MKDxDzPgJOKoybDx6vHifbn1OumS3yGD7SiMLlX40Tc+3jd1ViMduC/2oH3Tk33iEFe/9exgBzlAJht9KZqfR/P9mrxTbGVq1HdojEQ7U5vLPXS6IoHiaHyvl9PAiYnMqOr7VPXlqvryMXcffJ2nkGTK4cKlJK7bSKF0TCe1vfQtSCSES1dTRmK8cYh0Rvjg930v9czu2o7uhnQpPiUSganbG5y7vsrYfJmJeyUuPrtCZr1GdqO+e8nyBiqQ6GEoRlarsccXhex6jdd/8LVGLRdjm+ZTE9zMnqPipAYSA2zKuw+ip6WqZHLx04EI/NPUo9se40CJlFSPrDTBbAPAEZbP5LriSM14xFZUMBlRDcKEy+p0tuP1kYCf2lnF+EljmK6n25j6jCYXG8/F7TMrIh4wCiwdzvBOJ7m8UX9tNsYxAfC9pQWmMw5X708TBsrX/OxLedPvvm4fRrpDerkT1LQq3TpFTt0t4vfJ6d+aNdMri6aZ0RM7pD4zfTOV9+3vmcF74+M8/BefpS4e5fwokZPgpcufZ/LZj/V8PUBhzGX67PZ6YGGg3LpRo17TjjTqZuLDlV/8qxQ/OWpE/OohEkE97R6a+mp2vcboYv8YVnvGWmnMxJsKSxXcSKlmTBHm9J0iBFGHAu3GWJog1fk5b0xkqGYTjKwZ12FlJHnq26kO01B8DHhQRK5hDMJ3Am/dss9TwPcAfwJ8O/BfbXzi4OnVfnSv/JM3/wD87r4fdiBKhRS51VqXQWimQMbhpzwS9TBWPDBIOnh+tGl8GhOss2W/erq3b76UT5KodTdaUqElVT49e5s3fOg38epGCiRyXT7/lV/HZ6cf4jVTX8JZXO1YWYhAOttcGQ72Gd69XY/tmJdMCT//xNuIPumRqAZM394wAokCirB8Nku5kQTQl0bfkMKyKVysZj3WprIDqbcWFsuMbtOMSkVaYo7pYo2JuRJeWxFqpuTjpz3uXjMKtNmNOpErFMfTPdNx/bTHSoxA5GllaO+EqgYi8oPARwAXeL+qfkZE3g08o6pPAf8OI2/+LLCMMSaWY8bDjwQ86rxtqGNYnc6SKvt4ftTKrQcjLujFpH6Kgp90qIwkyRTrJgsKQEw3u+JYmlQlIFEP8RMutYzL6FKVwnKltXqpZRIsXhjpOabieIaRNVMU1pwIIzE6VrWMR7pY4hv/vw+S8NtqP8KAlz7zNH/x9X+djz/8Or7+z36T4kbYWglkc06jMdFgRiIMtWev87LvkKzVqYnDzM31lkKreSOUybkSQdKNbfTkBBFuEBEkXQpLFQrLm5N9br1OdqPO3JVR/D6TsYRRXyPRXBUsnjcKvWPzJfLL1c2EguZx1KwuKiNJihMZiqfYhbRbhmoyVfXDwIe3PPcjbX9XAVvYd4x59afeESvqd9hErsPda2NkN+qkKgGhJ5RG0xQWy+RXa7GritBzWJzKkqz4ZIomC6pUSBImzJ1wLZug1tY6dW06y/pkBq8eEnlOf9VZjF7V3NVRRlar5Bqd8zbG0y03x4Of/BQSk/cqYcTF5z/LC1/+NZy/lCTwlXo9IpF0BoolhTj4jkcqqvfV+Yoch1S1gld3QLXrPRI1d/xL5/Mma0gECSOm7xRN1pgAEd0TN4DC+HyZ+cs9MsIwmly9XIYKrI+n2BjPECZdvHpo6h96HEvU9A6Jk5G3bI991ywHxmHVRwyMCOVCinJhM3tlfTJDbr3eJRIHMDFXwk+ZO+bY9qgxqCN975Lj9t+YyMQGSkeXl/HC7kC4g5ItrrGRy5B++i1UX//reInt3Ti+ePzR1Ffx3MhlVCAT1vjahb9E5Nn4tFgRNsbGKCz2CLoD2VJA9ksrBJ7DytkcheUKyUbQuZlNFGeKTMZZf12lyJX4FzcOsNrWuyJTrPfNRhOIVfi1DMaJyXqyHC36Kb8eJcKEy1zMXa1g/jkm7sUVluwBVVJln8xGHadfQyRg8dwMvtdtdCJxWBubYnU6y9vfM8OTjz3Bk4890cqQ6sVvn3stz45cJnRcInEpeVn+4PJr+Og3fTPBlvP4nsdffv1riVwXP+3FVqw3A/gCJIKIqTsbJCvdiQG91jjRNsFhP+USek7X/B8JlPKp7uByn8M1XXqW3WFXFJZ9Z7/7LBw0zUZGbswdZ7Ia0mpMvkcS1YAzt9ZxmoJ7CuvjaVans7HHf+6lL+Er/vuf4Aadk2/kOnzyNa/ocHtBo59423v/U/9wrvX3wi1Y+JceUb3zPIEv1EbO8off/CgP/9F/J7+6RnG0wMdf82puvPghwATdxxYECbTbhdRGM5toEAaqSxBh/lKBszfWzHvWOLifclk+21khXc4nGVsoxx5GgXrGozJyPDtCHgWsobDsG8fNQDSJXGkpzHaxX8lfkXL25nqXMcqvVKmnPMoxk6afTvPh//mtvOa3f4epu2bSX52a5I/f9E0sz0yY4LJqo9tf90Dbe1zn1mpM+MVYF0KiHnLzoQe5+aIH48fuCHNXRpm8WyLdJsO9k7emGXhuSqP4KZe16e2VYoOky+37xyisVHF8pZJvxIW2XG+YcFmdynZ01muec3Uqy8ZE+lSnt+4Vaygs+8JxNRJgUlgjx0Gizq5rillMXP7CMvW0y8qZXNddvOuHjM+XjY8cKBeSrEzniLYEsrPFemzdhKMwtlimkk/GakJtTIzzO//Td5Go1RBV6uk0ThAxNbtOttFkJ0g4LM/0V17tVcsB27R6be6TcJm/XEAiJV2sMzVXjJVtj5uKFSiNJKiOJHFDpZb2qGW9gSbudKnekIo3R8qvV1k6m4tNy92YzFDN2fqHg8DGKCx75jgbCcC4OC7miRxpVeQ2p3SHhtR0NeTMrXWSbQFYJ4w4d32tVcHtKOTW6kaPaMvKwQ2inn4Zz4+4+KVlRlZ6twH1Uynq6TSoWZlki/5mfMCPmJ7d6BgbNFJUfeM6q2U8gkS8vz+uT3gv1BEq+SSh032sfm4nP5OgNJZmfTJDLde2IlAlWQ1IVoOuhimuHzI9u4EbqZHuiIyw3+RciUQ1XqTQT3usnM2xdD5vkhaskdgX7IrCsmuOQn3EfuGnPW4/ME6mWCdZ9sn3KM6bvFvk7rUxECMYKFG3394NIrLrtVaFMJhVSz+xOlGjR+Wn3NaqRSIlVfFREdMpT4R0ycfzw9hU1TOzG9STLtWsR6YckKoGRrrCEZbP5pi/NMr07XUStZBm4cX6ZIbSTjWMRLh3ucCZ2xtGx6pxrHrKJVXtHpsKppfHFtKlOlN3imalpcYILZ7Pt/YdWa3Fv18KheUKS+fzOxu3ZddYQ2HZFUelPmI/UUeIXGFkvd5DUwgS9YgLz60wd2W0Jei3laYYYLuhqGU86mmPZDXoWUDWLAxbyCYYWakwPl9u+XJUTI/wZC2M7c8tgBsqmUpAuqF71BIaDJWpu0XmLxWYuzqGVzdS3H7SQwes3t5KmHS5e20MrxbihhH1tIdEyrkXVnFCbRnZqKGltLV+waub1ULHexEq07Pr3LlvjDDhmkLEuPcJ05zIcnhY15NlRzz8SMAH3vvWE2ckwGQlNV0dvaZPs2JQJu8UCWNcOdCQ+Njq929k8BRHU/1KA/D8kFTZZ3y+bNxZDXeLGypnbq0TuhLbt3vrceJWHE29pGY19W6NRDtBYwWkjhB5pqhxYyKNn3CopU120tJMrsutNNLoINc1djUBfjDGtVcjqUQ9YrRHlpNl/7ErCsvAtFYRh9A/YhiMLlViJ6+tmGKxgPmpPNmNetdrVOhYTbSed4SVmRFq2QSTd4uxGlK1TILCUrnnOJwwQkVQehuzXmNO1A/+LjzyHFbP5Fg9kyNZCZiYKzI5Z2pR6kmHZhN3J4j6rNpMkaFpS1qOFVwUYHS5wsZ4uitxwLL/2Hf4FKOqDKqxeFJXEe0kavEy1nGogJ/0WDljJKlbbT4FFs+N9BW8K+eTsYVkKlAcS5EpxY/DtORUo5GUdFrnHbR2YasarlcNmLq9zvTsOumN/e3h4tVCzt5cI1ULWyucZD0iVYtIVUO8QGPHHQG1pptKtZVMEIcKpLap7rbsD3ZFcQqJImV+zmd91fRYTiaFM+cS5EbiJ7fD6kI3bIxabHx8Yiuh5xB6QnE8Q6mQatQXCNVcon/rUwAxdQkT90pkGxN0Le2xMpMjs17r+bJITOFYkHS5e984Xi0kUfOZulvadiUUCaxNbdYtTNxeZ2Rjc5LNFH0CT7hz//i+ZArFrc76Feu1P19srMZS1aBVexFLIwBuOXisoTiFzN6oU61str2s15XbN+tcvJIkm+s0Fsc+9XUHrE9mWkqxTdrnqPYiruWZTZ0hdR0q+QEzhxo9HZxQWTo3wuL55sHNsSbvFGMn0WbKbnsHtiDlEqRc1uoRY4vdPbzbX7s0s1kDki7VGdnobuTkBcrk7Q2WLvYW6huUZLVHo6gBaLqSItfpu1xSoJq11daHgTUUp4xqJeowEk1UYXE+4PK1TUNxmowEmBTWxQt5Ju6alptgAr9rExly6zUS9ZB6ymVtKrsj4b8mXj3kzOw6rh+1UkpXp7MdgoDaZ3b1U/HNgtansqDK2FJ8HUY95XYUqBUW4l2IAuSK/r50BgsSLol6fByiH+3XX29oPYnfXQgJGOVZWydxKFhDccqoVnoL0dWqZttpMxDtVEaS3H5gHM+PUKElKR4nsbEjVDl7Yw03bPZ0MNPd2EKZIOG2GhVVs55Jgd3ycuPjj2+pCibIHXtaYG2qs6DODftP4BJGqLu38OX6ZIZ02R8oOaCJCea3rWgbhZCtXhiNYwWew9yVUaI+1ebtJCsBhaWyMfRpj/WJzK4M/WnGvlunjERCehZ+uZ6caiPRQmSg7ms7IVOMlzJ3FEaXyi1DUc8kYKVHnKJPJlR+LT62onSrplZzCRI9enAAA92lu35IYblKuuwTeg7r42mqbeepZRMsn80xca8U20WwrTFgx3Or052NnoKUx2yjENLzTb1Gs/hwEDLrNabuFltjSNRN06T5iwVTIW4ZCGsoThnZEQfXga0K164HT3/DXxvOoE4BHW1T47Y1qGYTsYZcia9uBkjUQuOy6VGIl6oEHRpVK2ey5FdrsX2/Kxm3I0AsYUR+tUpmo07YaB8aJD1mrq9tGr6aqf1Ym8wYN1iD0liaRC2g0MPwRY17llZr1Zkc9UzMlCQyeAyoHVUm75U60pCbVfCTc0Xu3DdmXVcDMhRDISITwAeAq8B14G+q6krMfiHwqcbDm6r6LYc1xpOKiHDpaorZm3UCXxEBSbj8j4e/mue+7KXDHt6JpZ6Kl/DQ5rYGkeewMZoywnZtjX/UEVamO6W1m4Se07en9OhimfnLo5tPOA5zl/KcvbXRsV/gwvKFzUC2E0Scu76KE5g0VQWypSKRmJVQ+xRrVkYVimOddQ2e37teopZJsHo2i6iJR+z3pJ2ohT2bFXlBhBsqoWcNxSAMa0XxTuC/qOqPi8g7G4//ccx+FVV9+FBHdgpIphyuPZCiVlXcH38N/+IPX0w9Y/sIHyS1rElr9WqdshQqsDpt3nuJjIRFqiHB0cx0Ko2mWJvKtOIlWwmSLoHnxE7KAiRr3bGNei7J7IsmyK7X8PwQP+V1Ka2OLpZx23pQNH9vNRLtJ0uX/Y4OgrVsgkyM1Ekk5j3xUwc3BfVNndX+iQOWToZlKN4MvK7x978H/hvxhsJyQIgI7/72H4BnAGsjDh4R5i4XmJgrkWu07WzKgzfbrI7fK5GqdGtBpco+YWIk5qCbrE6mmZqLl7QIXccIDJZ9EKhmEuCI6QEeU0HeJLvRW/Oqx0WiW1YFxdEUo0sVNNw0OCbFWFr1EgdFkHQJEk5X9pUJmnsm/dYyEMMyFGdV9W7j7zngbI/90iLyDBAAP66q/6nXAUXkceBxgLMJO/P1I/30Wzqa2lgOB3Udli7kWVJFIjq1llTJrde6jIRgZMRHlsoUJ3s3+imPpokWKjhhZ8A8EjMpXvzScscMv3g+v31rUOkR+OiJUtkSR1HX4e7VUSbmSmRKpsCvmk2wPNPds+MgWLyQ5+yNdUQVR5sV9MLi+f6G19LJgRkKEfl9IG42elf7A1VVkZ5JdFdU9baI3Af8VxH5lKo+F7ejqr4PeB/AizNjO/l2nyqefOwJeM+wR3FEUCW/XGVkzTQFKueTrE9kDn4CE0G3eJGctvTPrt1p+P8nMr39+E3p71sbJlVWBFGllE9uGqC240/d3uDOtTHCPtldzdXAIB4aBRbO5yHG3RMmXBYuFTaFAQ8xgOynjHx8br2GVzcutlI+GTtOS28OzFCo6ht7bROReyJyTlXvisg5YL7HMW43fj8vIv8N+Eog1lBYtsemvrahRo213dWTX66SW69z99roobsloobEuRvGWws3MnLhUZ/gq5/yuH3/mLmmyHSSG5+Pl/cQhZHVKmtn4gPkYGohcms1vB4Cfu0ECacjPTaW7QxEc6XlDLDvDlDn4N1cJ51hOemeAr6n8ff3AL+xdQcRGReRVOPvKeA1wGcPbYQnDGskOkmX/a54gIOpSejXae7AEGF1Mt3b0dNwmQxynFo2QWUkSeQ5uH2yjrytOdJbUEe4c/8YxXyiFVjfsjABjDtnpY/B2RZVRhfKXPrSCpe+tMzFZ1cYWa50SZNbhsewDMWPA98oIl8C3th4jIi8XER+vrHPXwGeEZFPAE9jYhTWUOwCayS6SRfjq4YdpSXUd9gUJ7L4yZh2pbBrd0ktm4jt6dCMXfRFlcJShVzRRxsqtb5nXFJN1Vo/4bB4bqRVMLgbxuZLFJYrrboMN1TGF8qtvhSW4TOUYLaqLgHfEPP8M8Dfafz9x8CXH/LQThTWQPSmX9OeaB8a+uyWe5dHOXtrHa8eoo04Qy3jsTyzu+Drxnia/EoV1c6so8gVSqP93THZjTqjS5WOVVciAKfkc+vBhsrsHl1EpqCvO4jvKIwulNkYT9uiuCOAzQ87oVgj0Z9SIRWbRx8Jh+7PllBJVAOcIMLzQ0LXlCyrI6xNZZi/VNi1nHbkOcxdHaWa8ToUaOeujm17zNHFSmwWlhNFpMvBvkzgiXrUM9/WUSgs2i52RwEr4XHCeNX7X8brP/jaYQ/jyBMk3ZYWEZjgroopbivvwY2yI1QZmy+TX62CgDRCBq3CtihidNH0dWjvJbETJFIm5oqmt0OjvNrzw4GKzXrGMHT7+MagBAmndd1bEWB0uUqQ8jqK+CyHjzUUJ4j002/h9bY+YmBKY2mquSTZYg2JoDKSONBK4a0UlirkV6tdqavtOGr2Wx9P70rRdWKuuBm0b5wjWQ2Zul00Mt19qKdc0pX49qn11P6IJkaeQ9jI9oqzXc3rt4ZiuFhDcUKw9RG7I0w4bIwPoUBTlcJyta9GUwuBVDWkmtuZoZBIycX09BYgXfFxg4iwT83I6nSWM7fWO8YYiemLUd8nmW6JtKeRaLJfqxfL7rGG4pjz6k+948T3sj6JiNJqjrQtiolb7BAnjLoUYluHFMHZxlDUsgkWLuSZuFcyCrdi4hvLZ0f2LcAskfaUvW+yX6sXy+6xhuIY84H3vpUnrZE4lqjQt8CutR9GHdbfxWQZeo7RXoqrR1AdqOdGdSTJnZEkEqmJa+xzBlLkCqHr9Fw1bO31bRkONuvpmPLkY0/wiafGhj0My24RYXUy01Xj0AwlGE0is5KYv7TLlp8irE7HnyPwHNwduHTU2XsqbCwiLJ/Jxo4xdIWFC/mOXhqW4WBXFMcQm/p6MiiOp5FGHwdp3PWXCkmKoymStYgw4RiRvT1M0MXxDIow2czuYlNocOb6GnfuGzsUcb5+VAopFlyH0cUyiVpI4Anrk5mOPt+W4WINxTHDGokThAgbkxk2JtK4QUTkOq3ahvo+eltEjduou9ObMrJa7ehKNyyquQTV3Oj2O1qGgjUUxwRbH3GCEenZlGg/SMf0uABjONJln/UDO7PlpGANxTHgyceegA8OexSW40qQcGKznxQIDtBAWU4O1lAcYR5+JOBR523DHoblmFMcM3pPW+spVIwWlMWyHdZQHFFsfYRlvwiSLovn80zd3dh8UmFpJoe/T4VzAOlincJyFTeIqGYTrE+mD9SlZjk8rKE4gtj6CMt+U8knuZWbIF0x7UhrmcSuhQbjKCyWO5RmE/WQkfUad6+ODlSvYTnaWENxxHjysSdMWyeLZb9xhGpu/wUPnSBibKnS4doSgEgZny+xcLG/ppTl6GMNxRHBxiMsx5V02TQ2itWUKvlDGZNlfxlKpY2IfIeIfEZEIhF5eZ/93iQiXxCRZ0XknYc5xsPkyceesEbCcmzp58JS23ToRDCsksxPA28BPtprBxFxgZ8FHgFeAnyXiLzkcIZ3eNgCOstxp9JDYiMSU2luOf4MxVCo6udU9Qvb7PYK4FlVfV5V68CvAm8++NEdHtZIWE4EjtFkioSWZlMkJttqdXr4Vd+WvXOUYxQXgFttj2eBV/baWUQeBx4HOJsYQn+BHWDjEZaTRjWX5Pb94+TWa7hBRC2ToDKyN50qy9HhwAyFiPw+ENdu7V2q+hv7fT5VfR/wPoAXZ8YGFPo/fGx9hOWkEnkOGxNH+ybNsjsOzFCo6hv3eIjbwKW2xxcbzx1bnnzsCbBGwmKxHDOOsuvpY8CDInINYyC+E3jrcIe0O6ygn8ViOc4MKz32W0VkFngV8Fsi8pHG8+dF5MMAqhoAPwh8BPgc8Guq+plhjHcvpJ9+izUSFovlWDOUFYWqfgj4UMzzd4BH2x5/GPjwIQ5tX3nysSfgPcMehcVisewN2wr1gLCprxaL5aRgDcUBYI2ExWI5SRzlYPaxwxoIi8VyErErin3CGgmLxXJSsYZiH7BGwmKxnGSs62kP2PoIi8VyGrCGYpekn34Lr39PnEKJxWKxnCysodghrVWErY+wWCynBGsodoBdRVgsltOINRQDYqusLRbLacVmPQ2AzWqyWCynGWsotsEaCYvFctqxrqce2NRXi8ViMVhDEcOTjz0BHxz2KCwWi+VoYF1PW7CuJovFYunErigaWFeTxWKxxGMNBfDqT72D19le1haLxRLLsFqhfoeIfEZEIhF5eZ/9rovIp0Tk4yLyzEGM5QPvfas1EhaLxdKHYa0oPg28BXjvAPu+XlUX93sArVXEU/t9ZIvFYjlZDGVFoaqfU9UvDOPcYFcRFovFshOOeoxCgd8VEQXeq6rv67WjiDwOPA5wNpHpecAnH3vCriIsFotlBxyYoRCR3wfiFPTepaq/MeBhXquqt0XkDPB7IvJ5Vf1o3I4NI/I+gBdnxjRuH5v6arFYLDvnwAyFqr5xH45xu/F7XkQ+BLwCiDUU22GNhMViseyOI+t6EpEc4KjqRuPvvwa8e6fHefiRgEedt+37+CwWi+W0MBRDISLfCvxrYBr4LRH5uKp+k4icB35eVR8FzgIfEpHmOH9ZVX9nJ+exqwiLxWLZO6Ia684/1nzVzKgWvvdXhj0Mi8ViOTb8wU889heqGlvXdiK1nr4kZ4Y9BIvFYjkxnEhDYbFYLJb9wxoKi8VisfTFGgqLxWKx9MUaCovFYrH0xRoKi8VisfTFGgqLxWKx9MUaCovFYrH0xRoKi8VisfTFGgqLxWKx9MUaCovFYrH0xRoKi8VisfTFGgqLxWKx9MUaCovFYrH0xRoKi8VisfTFGgqLxWKx9OVENi4SkQXgxj4fdgpY3OdjHmVO0/WepmsFe70nnd1e7xVVnY7bcCINxUEgIs/06v50EjlN13uarhXs9Z50DuJ6revJYrFYLH2xhsJisVgsfbGGYnDeN+wBHDKn6XpP07WCvd6Tzr5fr41RWCwWi6UvdkVhsVgslr5YQ2GxWCyWvlhDsQNE5CdF5PMi8kkR+ZCIjA17TAeFiHyHiHxGRCIRObGphSLyJhH5gog8KyLvHPZ4DhIReb+IzIvIp4c9loNGRC6JyNMi8tnG9/gfDHtMB4mIpEXkz0XkE43r/Wf7eXxrKHbG7wFfpqovA74I/PCQx3OQfBp4C/DRYQ/koBARF/hZ4BHgJcB3ichLhjuqA+UXgDcNexCHRAC8Q1VfAnwt8AMn/LOtAW9Q1a8AHgbeJCJfu18Ht4ZiB6jq76pq0Hj4p8DFYY7nIFHVz6nqF4Y9jgPmFcCzqvq8qtaBXwXePOQxHRiq+lFgedjjOAxU9a6q/mXj7w3gc8CF4Y7q4FBDsfEw0fjZt0wlayh2z/8C/PawB2HZExeAW22PZznBk8lpRUSuAl8J/NmQh3KgiIgrIh8H5oHfU9V9u15vvw50UhCR3wdmYja9S1V/o7HPuzBL2/9wmGPbbwa5VovlOCMiI8AHgR9S1fVhj+cgUdUQeLgRO/2QiHyZqu5LPMoaii2o6hv7bReR7wW+GfgGPeZFKNtd6yngNnCp7fHFxnOWE4CIJDBG4j+o6q8PezyHhaquisjTmHjUvhgK63raASLyJuAfAd+iquVhj8eyZz4GPCgi10QkCXwn8NSQx2TZB0REgH8HfE5Vf2rY4zloRGS6mYUpIhngG4HP79fxraHYGT8D5IHfE5GPi8jPDXtAB4WIfKuIzAKvAn5LRD4y7DHtN43EhB8EPoIJdv6aqn5muKM6OETkV4A/AR4SkVkR+f5hj+kAeQ3w3cAbGv+rHxeRR4c9qAPkHPC0iHwScwP0e6r6n/fr4FbCw2KxWCx9sSsKi8VisfTFGgqLxWKx9MUaCovFYrH0xRoKi8VisfTFGgqLxWKx9MUaCovlEBGR3xGRVRHZt9RFi+WgsYbCYjlcfhKT32+xHBusobBYDgAR+ZpG35K0iOQaPQK+TFX/C7Ax7PFZLDvBaj1ZLAeAqn5MRJ4C/jmQAf7f/RJos1gOG2soLJaD490YOYUq8LYhj8Vi2TXW9WSxHByTwAhGHyw95LFYLLvGGgqL5eB4L/BPMH1LfmLIY7FYdo11PVksB4CI/G3AV9VfbvTm/mMReQPwz4AXAyMNdd7vV9UTp8xrOVlY9ViLxWKx9MW6niwWi8XSF2soLBaLxdIXaygsFovF0hdrKCwWi8XSF2soLBaLxdIXaygsFovF0hdrKCwWi8XSl/8f6IJxOFmr9SAAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -765,7 +593,8 @@ "metadata": {}, "source": [ "### 2.3 Module\n", - "下面我们再用 Module 定义这个模型，下面是使用 Module 的模板\n", + "\n", + "下面再用 Module 定义这个模型，下面是使用 Module 的模板\n", "\n", "```\n", "class 网络名字(nn.Module):\n", @@ -792,15 +621,13 @@ }, { "cell_type": "code", - "execution_count": 27, - "metadata": { - "collapsed": true - }, + "execution_count": 12, + "metadata": {}, "outputs": [], "source": [ - "class module_net(nn.Module):\n", + "class SimpNet(nn.Module):\n", " def __init__(self, num_input, num_hidden, num_output):\n", - " super(module_net, self).__init__()\n", + " super(SimpNet, self).__init__()\n", " self.layer1 = nn.Linear(num_input, num_hidden)\n", " \n", " self.layer2 = nn.Tanh()\n", @@ -816,18 +643,16 @@ }, { "cell_type": "code", - "execution_count": 28, - "metadata": { - "collapsed": true - }, + "execution_count": 13, + "metadata": {}, "outputs": [], "source": [ - "mo_net = module_net(2, 4, 1)" + "mo_net = SimpNet(2, 4, 1)" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -848,7 +673,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -856,10 +681,10 @@ "output_type": "stream", "text": [ "Parameter containing:\n", - "tensor([[-0.0458, -0.6043],\n", - " [ 0.0567, -0.6961],\n", - " [ 0.5034, 0.2557],\n", - " [ 0.2466, -0.5245]], requires_grad=True)\n" + "tensor([[ 0.6988, 0.2605],\n", + " [-0.4452, 0.1708],\n", + " [-0.3578, 0.6637],\n", + " [ 0.2984, -0.1281]], requires_grad=True)\n" ] } ], @@ -870,10 +695,8 @@ }, { "cell_type": "code", - "execution_count": 31, - "metadata": { - "collapsed": true - }, + "execution_count": 16, + "metadata": {}, "outputs": [], "source": [ "# 定义优化器\n", @@ -882,31 +705,31 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "epoch: 1000, loss: 0.07277397811412811\n", - "epoch: 2000, loss: 0.06705372780561447\n", - "epoch: 3000, loss: 0.06257135421037674\n", - "epoch: 4000, loss: 0.056195128709077835\n", - "epoch: 5000, loss: 0.050691165030002594\n", - "epoch: 6000, loss: 0.04715902358293533\n", - "epoch: 7000, loss: 0.0447952002286911\n", - "epoch: 8000, loss: 0.04309132695198059\n", - "epoch: 9000, loss: 0.04179977998137474\n", - "epoch: 10000, loss: 0.040784407407045364\n" + "epoch: 1000, loss: 0.0754304826259613\n", + "epoch: 2000, loss: 0.06512685120105743\n", + "epoch: 3000, loss: 0.061497319489717484\n", + "epoch: 4000, loss: 0.055132776498794556\n", + "epoch: 5000, loss: 0.04916892945766449\n", + "epoch: 6000, loss: 0.04603230580687523\n", + "epoch: 7000, loss: 0.04394793137907982\n", + "epoch: 8000, loss: 0.04242979362607002\n", + "epoch: 9000, loss: 0.041267599910497665\n", + "epoch: 10000, loss: 0.04034609720110893\n" ] } ], "source": [ "# 我们训练 10000 次\n", "for e in range(10000):\n", - " out = mo_net(Variable(x))\n", - " loss = criterion(out, Variable(y))\n", + " out = mo_net(x)\n", + " loss = criterion(out, y)\n", " optim.zero_grad()\n", " loss.backward()\n", " optim.step()\n", @@ -939,123 +762,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "**小练习：改变网络的隐藏层神经元数目，或者试试定义一个 5 层甚至更深的模型，增加训练次数，改变学习率，看看结果会怎么样**" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "下面举个例子" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "net = nn.Sequential(\n", - " nn.Linear(2, 10),\n", - " nn.Tanh(),\n", - " nn.Linear(10, 10),\n", - " nn.Tanh(),\n", - " nn.Linear(10, 10),\n", - " nn.Tanh(),\n", - " nn.Linear(10, 1)\n", - ")\n", - "\n", - "optim = torch.optim.SGD(net.parameters(), 0.1)" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 1000, loss: 0.07510872185230255\n", - "epoch: 2000, loss: 0.0662045031785965\n", - "epoch: 3000, loss: 0.062202777713537216\n", - "epoch: 4000, loss: 0.053606368601322174\n", - "epoch: 5000, loss: 0.047997504472732544\n", - "epoch: 6000, loss: 0.045905228704214096\n", - "epoch: 7000, loss: 0.044531650841236115\n", - "epoch: 8000, loss: 0.04245807230472565\n", - "epoch: 9000, loss: 0.0403163880109787\n", - "epoch: 10000, loss: 0.03822056204080582\n", - "epoch: 11000, loss: 0.03605899214744568\n", - "epoch: 12000, loss: 0.033822499215602875\n", - "epoch: 13000, loss: 0.031671419739723206\n", - "epoch: 14000, loss: 0.029688959941267967\n", - "epoch: 15000, loss: 0.02786232717335224\n", - "epoch: 16000, loss: 0.026174388825893402\n", - "epoch: 17000, loss: 0.024574236944317818\n", - "epoch: 18000, loss: 0.022980017587542534\n", - "epoch: 19000, loss: 0.021339748054742813\n", - "epoch: 20000, loss: 0.019654229283332825\n" - ] - } - ], - "source": [ - "# 我们训练 20000 次\n", - "for e in range(20000):\n", - " out = net(Variable(x))\n", - " loss = criterion(out, Variable(y))\n", - " optim.zero_grad()\n", - " loss.backward()\n", - " optim.step()\n", - " if (e + 1) % 1000 == 0:\n", - " print('epoch: {}, loss: {}'.format(e+1, loss.item()))" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'sequential')" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "def plot_net(x):\n", - " out = F.sigmoid(net(Variable(torch.from_numpy(x).float()))).data.numpy()\n", - " out = (out > 0.5) * 1\n", - " return out\n", + "## 练习题\n", "\n", - "plot_decision_boundary(lambda x: plot_net(x), x.numpy(), y.numpy())\n", - "plt.title('sequential')" + "* 改变网络的隐藏层神经元数目，或者试试定义一个 5 层甚至更深的模型，增加训练次数，改变学习率，看看结果会怎么样" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1069,7 +784,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.4" + "version": "3.9.7" } }, "nbformat": 4, diff --git a/6_pytorch/6-deep-nn.ipynb b/6_pytorch/6-deep-nn.ipynb new file mode 100644 index 0000000..7e05137 --- /dev/null +++ b/6_pytorch/6-deep-nn.ipynb @@ -0,0 +1,671 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 深层神经网络\n", + "\n", + "前一节简要介绍了PyTorch的神经网络实现，同时示范了如何用神经网络构建一个复杂的非线性二分类器。针对图像分类的问题，下面用深度学习的入门级数据集 MNIST 手写体分类来说明深层神经网络的优良表现。\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. MNIST 数据集\n", + "\n", + "MNIS数据集是一个非常出名的数据集，基本上很多网络都将其作为一个测试的标准，其来自美国国家标准与技术研究所, National Institute of Standards and Technology (NIST)。 训练集 (training set) 由来自 250 个不同人手写的数字构成, 其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员，一共有 60000 张图片。 测试集(test set) 也是同样比例的手写数字数据，一共有 10000 张图片。\n", + "\n", + "每张图片大小是 28 x 28 的灰度图，如下\n", + "\n", + "![MNIS](imgs/MNIST.jpeg)\n", + "\n", + "任务就是给出一张图片，希望区别出其到底属于 0 到 9 这 10 个数字中的哪一个。\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. 多分类问题\n", + "\n", + "前面讲过二分类问题，现在处理的问题更加复杂，是一个 10 分类问题，统称为多分类问题，对于多分类问题， loss 函数使用一个更加复杂的函数，叫交叉熵。\n", + "\n", + "### 2.1 softmax\n", + "提到交叉熵，先讲一下 softmax 函数，前面我们见过了 sigmoid 函数，如下\n", + "\n", + "$$s(x) = \\frac{1}{1 + e^{-x}}$$\n", + "\n", + "可以将任何一个值转换到 0 ~ 1 之间，当然对于一个二分类问题，这样就足够了，因为对于二分类问题，如果不属于第一类，那么必定属于第二类，所以只需要用一个值来表示其属于其中一类概率，但是对于多分类问题，这样并不行，需要知道其属于每一类的概率，这个时候就需要 softmax 函数了。\n", + "\n", + "softmax 函数示例如下\n", + "\n", + "![softmax](imgs/softmax.jpeg)\n", + "\n", + "对于网络的输出 $z_1, z_2, \\cdots z_k$，我们首先对他们每个都取指数变成 $e^{z_1}, e^{z_2}, \\cdots, e^{z_k}$，那么每一项都除以他们的求和，也就是\n", + "\n", + "$$\n", + "z_i \\rightarrow \\frac{e^{z_i}}{\\sum_{j=1}^{k} e^{z_j}}\n", + "$$\n", + "\n", + "如果对经过 softmax 函数的所有项求和就等于 1，所以他们每一项都分别表示属于其中某一类的概率。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.2 交叉熵\n", + "\n", + "交叉熵衡量两个分布相似性的一种度量方式，前面讲的二分类问题的 loss 函数就是交叉熵的一种特殊情况，交叉熵的一般公式为\n", + "\n", + "$$\n", + "cross\\_entropy(p, q) = E_{p}[-\\log q] = - \\frac{1}{m} \\sum_{x} p(x) \\log q(x)\n", + "$$\n", + "\n", + "对于二分类问题我们可以写成\n", + "\n", + "$$\n", + "-\\frac{1}{m} \\sum_{i=1}^m (y^{i} \\log sigmoid(x^{i}) + (1 - y^{i}) \\log (1 - sigmoid(x^{i}))\n", + "$$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.3 示例程序" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import torch\n", + "from torchvision.datasets import mnist # 导入 pytorch 内置的 mnist 数据\n", + "\n", + "from torch import nn\n", + "from torch.autograd import Variable" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# 使用内置函数下载 mnist 数据集\n", + "train_set = mnist.MNIST('../data/mnist', train=True, download=True)\n", + "test_set = mnist.MNIST('../data/mnist', train=False, download=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们可以看看其中的一个数据是什么样子的" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "a_data, a_label = train_set[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAAAAABXZoBIAAABAElEQVR4nGNgGMyAWUhIqK5jvdSy/9/rGRgYGFhgEnJsVjYCwQwMDAxPJgV+vniQgYGBgREqZ7iXH8r6l/SV4dn7m8gmCt3++/fv37/Htn3/iMW+gDnZf/+e5WbQnoXNNXyMs/5GoQoxwVmf/n9kSGFiwAW49/11wynJoPzx4YIcRlyygR/+/i2XxCWru+vv32nSuGQFYv/83Y3b4p9/fzpAmSyoMnohpiwM1w5h06Q+5enfv39/bcMiJVF09+/fv39P+mFKiTtd/fv3799jgZiBJLT69t+/f/8eDuDEkDJf8+jv379/v7Ryo4qzMDAwMAQGMjBc3/y35wM2V1IfAABFF16Aa0wAOwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_data" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a_label" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "这里的读入的数据是 PIL 库中的格式，我们可以非常方便地将其转换为 numpy array" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(28, 28)\n" + ] + } + ], + "source": [ + "a_data = np.array(a_data, dtype='float32')\n", + "print(a_data.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "这里我们可以看到这种图片的大小是 28 x 28" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 3. 18.\n", + " 18. 18. 126. 136. 175. 26. 166. 255. 247. 127. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 30. 36. 94. 154. 170. 253.\n", + " 253. 253. 253. 253. 225. 172. 253. 242. 195. 64. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 49. 238. 253. 253. 253. 253. 253.\n", + " 253. 253. 253. 251. 93. 82. 82. 56. 39. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 18. 219. 253. 253. 253. 253. 253.\n", + " 198. 182. 247. 241. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 80. 156. 107. 253. 253. 205.\n", + " 11. 0. 43. 154. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 14. 1. 154. 253. 90.\n", + " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 139. 253. 190.\n", + " 2. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 11. 190. 253.\n", + " 70. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 35. 241.\n", + " 225. 160. 108. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 81.\n", + " 240. 253. 253. 119. 25. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 45. 186. 253. 253. 150. 27. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 16. 93. 252. 253. 187. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 249. 253. 249. 64. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 46. 130. 183. 253. 253. 207. 2. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 39. 148.\n", + " 229. 253. 253. 253. 250. 182. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 24. 114. 221. 253.\n", + " 253. 253. 253. 201. 78. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 23. 66. 213. 253. 253. 253.\n", + " 253. 198. 81. 2. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 18. 171. 219. 253. 253. 253. 253. 195.\n", + " 80. 9. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 55. 172. 226. 253. 253. 253. 253. 244. 133. 11.\n", + " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 136. 253. 253. 253. 212. 135. 132. 16. 0. 0.\n", + " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n", + " [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]\n" + ] + } + ], + "source": [ + "print(a_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们可以将数组展示出来，里面的 0 就表示黑色，255 表示白色\n", + "\n", + "对于神经网络，我们第一层的输入就是 28 x 28 = 784，所以必须将得到的数据我们做一个变换，使用 reshape 将他们拉平成一个一维向量" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def data_tf(x):\n", + " x = np.array(x, dtype='float32') / 255\n", + " x = (x - 0.5) / 0.5 # 标准化，这个技巧之后会讲到\n", + " x = x.reshape((-1,)) # 拉平成一维向量\n", + " x = torch.from_numpy(x)\n", + " return x\n", + "\n", + "train_set = mnist.MNIST('../data/mnist', train=True, transform=data_tf, download=True) # 重新载入数据集，申明定义的数据变换\n", + "test_set = mnist.MNIST('../data/mnist', train=False, transform=data_tf, download=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([784])\n", + "5\n" + ] + } + ], + "source": [ + "a, a_label = train_set[0]\n", + "print(a.shape)\n", + "print(a_label)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from torch.utils.data import DataLoader\n", + "\n", + "# 使用 pytorch 自带的 DataLoader 定义一个数据迭代器\n", + "train_data = DataLoader(train_set, batch_size=64, shuffle=True)\n", + "test_data = DataLoader(test_set, batch_size=128, shuffle=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "使用这样的数据迭代器是非常有必要的，如果数据量太大，就无法一次将它们全部读入内存，所以需要使用 Python 迭代器，每次生成一个批次的数据" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "a, a_label = next(iter(train_data))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([64, 784])\n", + "torch.Size([64])\n" + ] + } + ], + "source": [ + "# 打印出一个批次的数据大小\n", + "print(a.shape)\n", + "print(a_label.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# 使用 Sequential 定义 4 层神经网络\n", + "net = nn.Sequential(\n", + " nn.Linear(784, 400),\n", + " nn.ReLU(),\n", + " nn.Linear(400, 200),\n", + " nn.ReLU(),\n", + " nn.Linear(200, 100),\n", + " nn.ReLU(),\n", + " nn.Linear(100, 10)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Sequential(\n", + " (0): Linear(in_features=784, out_features=400, bias=True)\n", + " (1): ReLU()\n", + " (2): Linear(in_features=400, out_features=200, bias=True)\n", + " (3): ReLU()\n", + " (4): Linear(in_features=200, out_features=100, bias=True)\n", + " (5): ReLU()\n", + " (6): Linear(in_features=100, out_features=10, bias=True)\n", + ")" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "net" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "交叉熵在 pytorch 中已经内置了，交叉熵的数值稳定性更差，所以内置的函数已经帮我们解决了这个问题" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# 定义 loss 函数\n", + "criterion = nn.CrossEntropyLoss()\n", + "optimizer = torch.optim.SGD(net.parameters(), 1e-1) # 使用随机梯度下降，学习率 0.1" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch: 0, Train Loss: 0.515279, Train Acc: 0.833889, Eval Loss: 0.162182, Eval Acc: 0.949367\n", + "epoch: 1, Train Loss: 0.164546, Train Acc: 0.948244, Eval Loss: 0.121298, Eval Acc: 0.962025\n", + "epoch: 2, Train Loss: 0.116251, Train Acc: 0.963669, Eval Loss: 0.160981, Eval Acc: 0.951543\n", + "epoch: 3, Train Loss: 0.091204, Train Acc: 0.971149, Eval Loss: 0.098640, Eval Acc: 0.970036\n", + "epoch: 4, Train Loss: 0.075570, Train Acc: 0.975796, Eval Loss: 0.125001, Eval Acc: 0.960839\n", + "epoch: 5, Train Loss: 0.058536, Train Acc: 0.981710, Eval Loss: 0.072245, Eval Acc: 0.975475\n", + "epoch: 6, Train Loss: 0.052349, Train Acc: 0.982743, Eval Loss: 0.082497, Eval Acc: 0.974782\n", + "epoch: 7, Train Loss: 0.051543, Train Acc: 0.984125, Eval Loss: 0.065229, Eval Acc: 0.979727\n", + "epoch: 8, Train Loss: 0.039741, Train Acc: 0.987257, Eval Loss: 0.116367, Eval Acc: 0.964893\n", + "epoch: 9, Train Loss: 0.033266, Train Acc: 0.989489, Eval Loss: 0.071046, Eval Acc: 0.978441\n", + "epoch: 10, Train Loss: 0.029305, Train Acc: 0.990039, Eval Loss: 0.087192, Eval Acc: 0.975771\n", + "epoch: 11, Train Loss: 0.026703, Train Acc: 0.991388, Eval Loss: 0.067075, Eval Acc: 0.980617\n", + "epoch: 12, Train Loss: 0.021403, Train Acc: 0.992970, Eval Loss: 0.063208, Eval Acc: 0.982002\n", + "epoch: 13, Train Loss: 0.238340, Train Acc: 0.962787, Eval Loss: 0.122586, Eval Acc: 0.962124\n", + "epoch: 14, Train Loss: 0.070087, Train Acc: 0.977046, Eval Loss: 0.134682, Eval Acc: 0.961432\n", + "epoch: 15, Train Loss: 0.049751, Train Acc: 0.983575, Eval Loss: 0.078269, Eval Acc: 0.977650\n", + "epoch: 16, Train Loss: 0.040535, Train Acc: 0.986657, Eval Loss: 0.069318, Eval Acc: 0.980914\n", + "epoch: 17, Train Loss: 0.033759, Train Acc: 0.988739, Eval Loss: 0.075110, Eval Acc: 0.979035\n", + "epoch: 18, Train Loss: 0.028471, Train Acc: 0.990672, Eval Loss: 0.079602, Eval Acc: 0.977551\n", + "epoch: 19, Train Loss: 0.027123, Train Acc: 0.991021, Eval Loss: 0.078461, Eval Acc: 0.979233\n" + ] + } + ], + "source": [ + "# 开始训练\n", + "losses = []\n", + "acces = []\n", + "eval_losses = []\n", + "eval_acces = []\n", + "\n", + "for e in range(20):\n", + " train_loss = 0\n", + " train_acc = 0\n", + " net.train()\n", + " for im, label in train_data:\n", + " im = Variable(im)\n", + " label = Variable(label)\n", + " # 前向传播\n", + " out = net(im)\n", + " loss = criterion(out, label)\n", + " # 反向传播\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + " # 记录误差\n", + " train_loss += loss.item()\n", + " # 计算分类的准确率\n", + " _, pred = out.max(1)\n", + " num_correct = float((pred == label).sum().item())\n", + " acc = num_correct / im.shape[0]\n", + " train_acc += acc\n", + " \n", + " losses.append(train_loss / len(train_data))\n", + " acces.append(train_acc / len(train_data))\n", + " # 在测试集上检验效果\n", + " eval_loss = 0\n", + " eval_acc = 0\n", + " net.eval() # 将模型改为预测模式\n", + " for im, label in test_data:\n", + " im = Variable(im)\n", + " label = Variable(label)\n", + " out = net(im)\n", + " loss = criterion(out, label)\n", + " # 记录误差\n", + " eval_loss += loss.item()\n", + " # 记录准确率\n", + " _, pred = out.max(1)\n", + " num_correct = float((pred == label).sum().item())\n", + " acc = num_correct / im.shape[0]\n", + " eval_acc += acc\n", + " \n", + " eval_losses.append(eval_loss / len(test_data))\n", + " eval_acces.append(eval_acc / len(test_data))\n", + " print('epoch: {}, Train Loss: {:.6f}, Train Acc: {:.6f}, Eval Loss: {:.6f}, Eval Acc: {:.6f}'\n", + " .format(e, train_loss / len(train_data), train_acc / len(train_data), \n", + " eval_loss / len(test_data), eval_acc / len(test_data)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "画出 loss 曲线和 准确率曲线" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "plt.title('train loss')\n", + "plt.plot(np.arange(len(losses)), losses)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'train acc')" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAEICAYAAABRSj9aAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAAqYElEQVR4nO3de3xU9Z3/8dcnCSGQBEhICJAA4SaCtipGVGzV1m69taXam7ZVSvVH/a3adq+1t1/9bfe3vWzb3e5qy7qVotZqb9rFlla3F9ftokIQVK41cg0JEAiZBJKQ2+f3x5zgdJiQgUwy4cz7+XjMIzPn+z0z3zkM73zznfM9X3N3REQkvLLS3QARERlcCnoRkZBT0IuIhJyCXkQk5BT0IiIhp6AXEQk5Bb1IDDNbZmZfTHc7RFLJdB69hIWZ7QRud/ffpLstIsOJevSSMcwsJ91tEEkHBb2Egpk9AkwFnjKzI2b2t2ZWaWZuZreZ2W7gd0Hdn5jZPjOLmNlzZnZOzPOsMLO/D+5faWa1ZvZXZnbAzOrNbMlJ2rDEzLaYWYuZbTezT8SVLzKzDWbWbGavm9k1wfZiM/u+mdWZ2WEz+3nqj5BkMgW9hIK73wLsBt7t7gXu/vWY4iuAucDVweNfAbOBCcBLwKMneeqJwFigHLgNuN/MivqoewB4FzAGWAL8k5nNBzCzBcDDwN8A44DLgZ3Bfo8Ao4Fzgjb9UzLvWSRZ+lNWMsG97n6094G7L++9b2b3AofNbKy7RxLs2wn8nbt3AavM7AgwB3ghvqK7/zLm4X+Z2TPAW4n+MrkNWO7u/xmU7w1efxJwLTDe3Q/37nt6b1MkMfXoJRPs6b1jZtlm9tVg6KSZN3rVJX3seygI+V6tQEGiimZ2rZm9YGaNZtYEXBfzvFOA1xPsNgVojAl5kZRT0EuY9HUKWez2DwOLgHcQHZKpDLbbQF7YzEYCPwO+AZS5+zhgVczz7gFmJth1D1BsZuMG8voiJ6OglzDZD8zop04hcAw4RHRc/B9S9Nq5wEigAegys2uBd8aUPwgsMbOrzCzLzMrN7Gx3ryf6ncF3zKzIzEaY2eUpapMIoKCXcPkK8AUzazKzv+6jzsPALqJj5JtJMNZ+Oty9Bfgk8GPgMNG/HFbGlK8h+IIWiBAdh58WFN9C9LuArUS/0P10Ktok0ksTpkREQk49ehGRkFPQi4iEXL9Bb2bLg1mBG/soNzP7FzOrMbNXeieIBGXXmNm2oOyeVDZcRESSk0yPfgVwzUnKryU6y3A2sBT4LkTPVwbuD8rnATeb2byBNFZERE5dvzNj3f05M6s8SZVFwMMe/Vb3BTMbF8z2qwRq3H07gJk9HtTd3N9rlpSUeGXlyV5SRERirVu37qC7lyYqS8UlEMqJmXkI1AbbEm2/OJknrKyspLq6OgVNExHJDGa2q6+yVHwZm2hGoZ9ke+InMVtqZtVmVt3Q0JCCZomICKQm6GuJXq+jVwVQd5LtCbn7A+5e5e5VpaUJ//oQEZHTkIqgXwncGpx9cwkQCaZ1rwVmm9l0M8sFbiJmpqCIiAyNfsfozewx4EqgxMxqgS8BIwDcfRnRCzddB9QQvbLfkqCsy8zuAp4GsoleonXTILwHERE5iWTOurm5n3IH7uyjbBXRXwQiIpImmhkrIhJyCnoRkZDTUoIiZyh3p/FoB7WH29jb1Mbew22cUz6GhTP7WixLMpWCXmSY6ulxGo4co/ZwG7WHW4+HeWywt3V2/8k+xfm5rL7n7eSNyE5Tq2U4UtCLpIG7c7i1k/3N7exrbmd/JPqzvqmd2qZW9h5uo66pnY7unj/Zr2j0CMqLRjGzNJ8rziqlfNwoKopGUV40itrDbXzikXX84pV63n9hRZremZyqru4eOrp76OjqoavHKSkYmfLXUNCLpFh7Z3c0wCPt7G85djzE9zW3c6A32JuP0dHVc8K+JQUjqSgaxTnlY7n6nInHQ7yiaDTl40aRP7Lv/7LzJo1h9oQCVqzewfvml2M2oGVwpR89Pc6+5na2Nxxlx8EjbD94lAMtxzjW2Rvc3XR0vRHiHV09dHY7x7qCsmB7T8z1AkoLR7L28+9IeVsV9CJEe9j1kXYaWo7R2tFNW2cXrR3d0fvHfwbbOnu3ddHW2XN8e1tHN42tHTS1dp7w/Hkjspg4Jo+yMXnMn1pEWXB/4pg8Jo4dSdmYPEoLRzIy5/SHXMyMxQsr+cLPN/LS7sNcOK14IIdEApHWTrYfPMKOg0eDUD/K6w1H2HnoKO2db/yyzs/NpmxsHiNzssnNyWJkdhajc3MYl5NFbnYWuTkxt+y4n8H9wrzBiWQFvWScw0c72La/hW37Wti2v4U/Bj9b2rv63XfUiGxG52YzKrf3Zw6jRmRRNiaPUbnZjBs1IhroY3tDPI+ywjzGjMoZkh72DReU87Vfb2XF6l0K+lPQ2d3DrkNHqTlwNAj0aLDvOHiUQ0c7jtfLzjKmFo9mekk+b5lVwvTSfGaUFDCjNJ8JhSOH7V9RCnoJrdaOLl7bf+SNQN/fwtZ9LTS0HDteZ+yoEcwpK+S955dz1sRCJo/NC0I8JxrkI94I9bycbLKyhud/5F75I3P4UNUUVqzeyf7r51I2Ji/dTRpW2jq6eb3hCDUH3ri9dqCFXYda6YoZQyktHMmMknzeeU4ZM0oKmF6Sz/TSfKYWj2ZE9pl3VrqCXkLh0JFjrN3ZyMa9zcd763sOt+LB/928EVmcVVbIFWeVMqeskDkTo7fh3As7XbdeWsmD/7ODR1/YxV++c066m5MWkbbOIMhbYgL9CHub2o5/JrKzjGnjRzOrtICrz5nI7LICZpZGQ70wb0R630CKKejljFQfaWPNjkZe3NHImh2N1Bw4AkT/884oyedNFWN5/4UV0UAvK2RK8Wiyh3lvPFWmjh/N2+dM4IdrdnPn22cNaNz/TNDU2sHanYeDX/QRXjtw5E/+asvNyWJmaQEXTC3ig1VTmDWhgFkTCqgcn09uzpnXOz8dCnoZ9tyd3Y2tx0N9zY5Gdje2AlA4MoeqyiLeN7+CBdOLObd8TOiDLRkfu6ySWx5cwy9fqefG+eE61bL3l/yaHY2s3dnIH/dHf8nnZmcxd/IYrjirlFkTCpgdBHpFUeb8ku+Lgl6GHXen5sCRPwn2fc3tQPQ88gXTi1m8sJKLpxczd9KYjP9PnMhbZpUwszSfh1bvPKOD3t3ZfvBoNNR3NLJmZyO1h9sAKBiZw/xpRbznvMlcVFnMeVPGaaJYHxT0kjZHj3VFzy+PBLfmdl6tjbBmZyONwZkOEwpHcvGM8SyYXswl04uZWVow7L8QHQ7MjI8trOSL/7GJ9bsPc8HUonQ3KSld3T1sqW9hzc5osFfvauTgkehnYXx+LhdVFvPxy6azYHoxZ08sJOcM/GI0HRT0knK912A5HuJxYd77M9HpjBVFo3jbnAlcPL2Yi2cUM7V4dOi+LB0qN86v4Ou/3saK1TuHfdDvPHiUf/1dDU9v2seRY9HPxZTiUVx+VikLKou5aHoxM0ry9Vk4TQp66Ze709rRTePRjhNvrR00Hgl+Hu3gQEviWZ9ZBhMKo+eXzywt4LJZJUwMzjUvG5PHpLF5x89Fl9TIH5nD+6sq+MELu/j89XOZUDj8TrXcfaiVf/3dazyxfi8jso0bLijnkuAvuEljR6W7eaGRVNCb2TXAt4muFPU9d/9qXHkRsByYCbQDH3f3jUHZXwC3E10Y/FVgibu3p+wdSEq0dXTz8w172bavhcajHRxu7eDQkeDn0Y6E0/UBRmQbxfm5FI3OpTg/lwunFlE2No9JvZOFxuQxaewoSgpy9Wd2Giy+tJIVq3fywxd38+l3nJXu5hy3p7GV+39fw0/X1ZKdFR1m+sQVM4blL6MwSGYpwWzgfuDPiC74vdbMVrr75phqnwM2uPsNZnZ2UP8qMysHPgnMc/c2M/sx0bVjV6T4fchpajzawcPP7+Th53fReLSDwpE5FBdEQ3vS2DzOmTyG4vzo46L8XMbH/SwcOTQzPuX0VJbkc+VZpTz64m7+/MpZaT+dsK6pjft+X8NPqvdgZnz0kmn8+ZUzmaCJXYMqmR79AqDG3bcDmNnjwCIgNujnAV8BcPetZlZpZmUxrzHKzDqB0UBdqhovp2/3oVa+94ft/Lh6D+2dPbxj7gSWXj6TiyqLFNwhs3hhJR/7/lp+tbGeReeXp6UN+yLtfOfZGh5fswfHuemiqfz522ZqeGaIJBP05cCemMe1wMVxdV4GbgT+YGYLgGlAhbuvM7NvALuBNuAZd38m0YuY2VJgKcDUqVNP6U1I8l6pbeLfntvOr16tJzsrOib6v946g9llhelumgySy2eXMqMknxWrdw550B9obuc7z77OD9fspqfH+eBFU7jzbbMoH6eAH0rJBH2i7p3HPf4q8G0z20B0HH490BWM3S8CpgNNwE/M7KPu/oMTntD9AeABgKqqqvjnlwFwd579YwMP/Nd2nt9+iMK8HJZePpMll1XqWigZICvLuPXSadz71GZe3tPEeVPGDfprNrQcY9l/vc4PXthFV4/zgQsruPNts5hSPHrQX1tOlEzQ1wJTYh5XEDf84u7NwBIAi/7dvyO4XQ3scPeGoOwJYCFwQtBL6nV09fDUy3X8+39vZ+u+FiaNzeML18/lQxdNCd21POTk3ndhBf/49DYeWr2Tb33o/EF7nUNHjvHAc9t56PmddHT1cOP8Cu5++yymjc8ftNeU/iUT9GuB2WY2HdhL9MvUD8dWMLNxQKu7dxA9w+Y5d282s93AJWY2mujQzVVAdQrbLwm0tHfy+Jo9LP+fHdRH2plTVsi3Pnge73rz5LR/GSfpUZg3gg9UTeGHL+7ms9fNpbQw9asYPbR6J1/79VbaO7t57/nl3H3VbKaXKOCHg36D3t27zOwu4Gmip1cud/dNZnZHUL4MmAs8bGbdRL+kvS0oe9HMfgq8BHQRHdJ5YFDeibAv0s6K1Tt59MVdtLR3cemM8XzlxjdxxVml+oJVuPXSaaxYvZPH1uzmk1fNTulz/3jtHr60chNXzinlC9fPY9aEgpQ+vwyMuQ+/4fCqqiqvrlbHPxlHj3XxzOZ9PPHSXv6n5iAA171pEksvn8GbK8alt3Ey7Ny6fA3b9jXzh8+8PWXXVf/N5v184gfrWDhzPA8uvkh/NaaJma1z96pEZZoZewbq6u7hDzUH+fn6vTy9aT9tnd1UFI3izrfN4gMXTmHqeH3hJYktWVjJkhVr+fXGfbz7vMkDfr51uxq584cvcc7kMSz76IUK+WFKQX+GcHc27m3myfV7WflyHQePHGPsqBHcML+cGy4op2qazn+X/l1xVimV40ezYvXOAQf9a/tb+PiKaiaPG8Xyj1100oXLJb30LzPM7WlsZeXLdTy5fi81B46Qm53F28+ewA3zy7lyTqmuvS6nJCvLuOXSSr78i81s3Bvh3PKxp/U8dU1t3Lp8Dbk5WTz88QWUFKT+y11JHQX9MBRp7eSXr9bz8/V7WbOzEYAFlcV85cY3cd25kxg7WqdGyun7QFUF33wmelXLb3zgvFPev6m1g8XL13CkvYvHP3GJzo0/Ayjoh4neSU0/WrOH3209QEd3DzNL8/mbq+fwnvMm6z+TpMyYvBG8b34FP6rew2evPZvxp9Abb+vo5vaHqtl1qJWHPr6Acyaf3l8EMrQU9MPAa/tb+LtfbOa/XztISUEuH7lkKjdeUMG55WM07i6DYvHCaTzywi4eX7uHO982K6l9urp7uPuxl1i3+zD3f3g+l84cP8itlFRR0KdRpLWTf/rNH3nkhV3k52bzpXfP46OXTEvZaW8ifZk1oZC3zi7hBy/sYunlM/r9zLk7n39yI7/ZcoAvLzqH6940aYhaKqmgoE+D7h7nsTW7+eYz24i0dXLzgqn81TvnUJyfm+6mSQZZfGkltz9czTOb9nP9m08e3N985o/8qHoPd799FrdcWjk0DZSUUdAPsedfP8T/fWoTW/e1cPH0Yr707nOYN3lMupslGehtZ09gSvEoHlq986RB/9Dqndz3+xpuumgKf/lnw2fxEkmegn6I1B5u5R9WbWHVq/soHzeK73xkPteeO1Fj8JI22VnG4ksr+ftfbmFTXSThF6u/eKWOe5/axDvmlvH37z1Xn9czlAaDB1lrRxffemYbV33zv/jd1gP85Z+dxW//6gque9Mk/aeRtPtA1RRGjcjmodU7TyhbXXOQv/zRy1RNK+K+D1+gpSDPYOrRDxJ356lX6vnKqi3UR9p5z3mTuefas5msBRdkGOmdXf2zdbV89tq5FAXfE23cG2HpI+uoLBnN9269iLwRmph3JtOv6EGwcW+EDyx7nk8+tp7xBbn85I5L+ZebL1DIy7D0sYWVHOvq4fG10YXkdh9q5WPfX8uYvBwe+vgCTdALAfXoU+jgkWN84+lt/Kh6D+Pzc/na+97E+y+cQnaWhmhk+DqrrJCFM8fzyPM7uXF+Obcuf5Gunh4eX3qp1nQNCQV9iuxtauO99/8Ph492cPtbpnP3VbMZo1Wc5AyxeGEln3hkHdf/yx84cqyTR2+/hFkTtI5wWCjoU+DosS5uf6ia9o5uVt71Fp0uKWecd8wto3zcKPY1t/PALRdy4bSidDdJUiipMXozu8bMtplZjZndk6C8yMyeNLNXzGyNmZ0bUzbOzH5qZlvNbIuZXZrKN5BuPT3Op3+0gW37mrnvI/MV8nJGys4y/u2WC/nh7Rdz1dyydDdHUqzfHr2ZZQP3A39GdKHwtWa20t03x1T7HLDB3W8ws7OD+lcFZd8Gfu3u7zezXCBUV+f6x2e28Z+b93Pvu+dxxVml6W6OyGk73UsWy/CXTI9+AVDj7tuDxb8fBxbF1ZkH/BbA3bcClWZWZmZjgMuBB4OyDndvSlXj0+1n62r57rOv85GLp7J4YWW6myMiklAyQV8O7Il5XBtsi/UycCOAmS0ApgEVwAygAfi+ma03s++ZWcJl4c1sqZlVm1l1Q0PDKb6NobduVyOffeJVFs4cz73vOUeTn0Rk2Eom6BMlWPyK4l8FisxsA3A3sB7oIjo0NB/4rrtfABwFThjjB3D3B9y9yt2rSkuH9xBI7eFWlj68jvKi6KUMdLVJERnOkjnrphaYEvO4AqiLreDuzcASAIt2bXcEt9FArbu/GFT9KX0E/ZniSHCGTWd3D99bXMW40bripIgMb8l0RdcCs81sevBl6k3AytgKwZk1vYl3O/Ccuze7+z5gj5nNCcquAmK/xD2jdPc4n3psPa8dOMJ3PnIhM0sL0t0kEZF+9dujd/cuM7sLeBrIBpa7+yYzuyMoXwbMBR42s26iQX5bzFPcDTwa/CLYTtDzPxN9/ddb+e3WA3z5vefyltkl6W6OiEhSkpow5e6rgFVx25bF3H8emN3HvhuAqtNv4vDw4+o9/Ntz21l86TRuuWRaupsjIpI0fYuYhDU7Gvn8k6/y1tklfPFd89LdHBGRU6Kg78fuQ6184pFqphSP5r4Pz9c1uUXkjKPUOomW9k5ue2gtPQ4PLr6IsaN0kTIROfMo6PvQ3ePc/dh6dhw8ync/Op/pJQnneYmIDHu6emUf/mHVFp7d1sD/u+FcFs7UGTYicuZSjz6Bx9bs5sE/7GDJZZV85GKdYSMiZzYFfZznXz/EF3++kSvOKuXz181Nd3NERAZMQR9j58Gj/O9H11FZks+/atV7EQkJJVmMux57CQMeXFylZQBFJDQU9IFjXd1s3NvM4oWVTBuvM2xEJDwU9IF9kXYAysdp1XsRCRcFfaCuKRr0kxX0IhIyCvpAfaQNgIlj89LcEhGR1FLQB+qDoZvJY9WjF5FwUdAH6iNtjBs9glG52eluiohISinoA/VN7UxSb15EQiipoDeza8xsm5nVmNkJa76aWZGZPWlmr5jZGjM7N64828zWm9kvUtXwVKuLtDNZ4/MiEkL9Br2ZZQP3A9cC84CbzSx+9Y3PARvc/c3ArcC348o/BWwZeHMHT32kjUnjFPQiEj7J9OgXADXuvt3dO4DHgUVxdeYBvwVw961ApZmVAZhZBXA98L2UtTrF2jq6aWrt1NCNiIRSMkFfDuyJeVwbbIv1MnAjgJktAKYBFUHZPwN/C/Sc7EXMbKmZVZtZdUNDQxLNSp264NTKSRq6EZEQSiboLcE2j3v8VaDIzDYAdwPrgS4zexdwwN3X9fci7v6Au1e5e1VpaWkSzUqd3lmx6tGLSBgls/BILTAl5nEFUBdbwd2bgSUAZmbAjuB2E/AeM7sOyAPGmNkP3P2jKWh7ytQ1RXv0kzVGLyIhlEyPfi0w28ymm1ku0fBeGVvBzMYFZQC3A8+5e7O7f9bdK9y9Mtjvd8Mt5OGNyVKaFSsiYdRvj97du8zsLuBpIBtY7u6bzOyOoHwZMBd42My6gc3AbYPY5pSrj7RRUpDLyBxNlhKR8ElqzVh3XwWsitu2LOb+88Dsfp7jWeDZU27hEKjTZCkRCTHNjCU4h17DNiISUgp6ei9/oKAXkXDK+KBvae+k5VgXk3QdehEJqYwP+jfOoVePXkTCKeODvi6ilaVEJNwyPujrm3T5AxEJt4wP+rpIO2ZQNkZBLyLhlPFBX9/UxoTCkYzIzvhDISIhlfHpVh9pZ6ImS4lIiCnoI21aWUpEQi2jg97dqY/o8gciEm4ZHfTNbV20dnTr8sQiEmoZHfRvrCylHr2IhFdGB319b9CrRy8iIZbRQV/XFMyKVY9eREIso4O+PtJGdpZRWjgy3U0RERk0SQW9mV1jZtvMrMbM7klQXmRmT5rZK2a2xszODbZPMbPfm9kWM9tkZp9K9RsYiPpIO2WFI8nOSrT+uYhIOPQb9GaWDdwPXAvMA242s3lx1T4HbHD3NwO3At8OtncBf+Xuc4FLgDsT7Js29U3tujyxiIReMj36BUCNu2939w7gcWBRXJ15wG8B3H0rUGlmZe5e7+4vBdtbgC1AecpaP0BaWUpEMkEyQV8O7Il5XMuJYf0ycCOAmS0ApgEVsRXMrBK4AHgx0YuY2VIzqzaz6oaGhqQaPxC9k6V0eWIRCbtkgj7RALbHPf4qUGRmG4C7gfVEh22iT2BWAPwM+LS7Nyd6EXd/wN2r3L2qtLQ0mbYPSOPRDo519ahHLyKhl5NEnVpgSszjCqAutkIQ3ksAzMyAHcENMxtBNOQfdfcnUtDmlKg/vrKUevQiEm7J9OjXArPNbLqZ5QI3AStjK5jZuKAM4HbgOXdvDkL/QWCLu38rlQ0fqDotOCIiGaLfHr27d5nZXcDTQDaw3N03mdkdQfkyYC7wsJl1A5uB24LdLwNuAV4NhnUAPufuq1L7Nk7dvuagR69ZsSIScskM3RAE86q4bcti7j8PzE6w3x9IPMafdnVN7YzINkryNVlKRMItY2fG1kfamDg2jyxNlhKRkMvcoG/SdehFJDNkbNDXaWUpEckQGRn0PT3O/mZd/kBEMkNGBv3BI8fo7Hb16EUkI2Rk0PdOlpqoMXoRyQAZGvSaLCUimSMjg/74ylIaoxeRDJCRQV8faWNkThZFo0ekuykiIoMuI4O+Lrg8cfRSPCIi4ZaRQV/fpAVHRCRzZGbQRzQrVkQyR8YFfVd3DwdajqlHLyIZI+OCvuHIMbp7XJcnFpGMkXFBf/zUSg3diEiGyLigPz5ZSj16EckQSQW9mV1jZtvMrMbM7klQXmRmT5rZK2a2xszOTXbfoVbfpLViRSSz9Bv0ZpYN3A9cC8wDbjazeXHVPgdscPc3A7cC3z6FfYdUXaSN/NxsxuQltbiWiMgZL5ke/QKgxt23u3sH8DiwKK7OPOC3AO6+Fag0s7Ik9x1S9U3RyxNrspSIZIpkgr4c2BPzuDbYFutl4EYAM1sATAMqktyXYL+lZlZtZtUNDQ3Jtf401De369RKEckoyQR9oq6vxz3+KlBkZhuAu4H1QFeS+0Y3uj/g7lXuXlVaWppEs06PZsWKSKZJZqC6FpgS87gCqIut4O7NwBIAi46J7Ahuo/vbdyh1dPXQcOSYvogVkYySTI9+LTDbzKabWS5wE7AytoKZjQvKAG4HngvCv999h9L+5nbcYbJOrRSRDNJvj97du8zsLuBpIBtY7u6bzOyOoHwZMBd42My6gc3AbSfbd3DeSv96V5ZSj15EMklS5xi6+ypgVdy2ZTH3nwdmJ7tvuvROllKPXkQySUbNjO29/IHWihWRTJJRQb8v0kZhXg4FIzVZSkQyR0YFfV2kXRczE5GMk1FBXx9p08XMRCTjZFbQN2llKRHJPBkT9O2d3Rw62sFkzYoVkQyTMUG/r/cc+nHq0YtIZsmYoK/rPYdePXoRyTAZE/S9PfqJCnoRyTAZE/S6/IGIZKqMCfq6pjaKRo9gVG52upsiIjKkMibo6yM6tVJEMlPGBH1dU5suZiYiGSljgl49ehHJVBkR9K0dXUTaOnX5AxHJSEkFvZldY2bbzKzGzO5JUD7WzJ4ys5fNbJOZLYkp+4tg20Yze8zMhjxt3zjjRkEvIpmn36A3s2zgfuBaYB5ws5nNi6t2J7DZ3c8DrgS+aWa5ZlYOfBKocvdzia4ydVMK25+U+iadWikimSuZHv0CoMbdt7t7B/A4sCiujgOFwcLgBUAj0BWU5QCjzCyH6GLhQ744+BuzYhX0IpJ5kgn6cmBPzOPaYFus+4iuG1sHvAp8yt173H0v8A1gN1APRNz9mQG3+hT19ujLxo4c6pcWEUm7ZILeEmzzuMdXAxuAycD5wH1mNsbMioj2/qcHZflm9tGEL2K21Myqzay6oaEhyeYnpz7SRknBSEbmaLKUiGSeZIK+FpgS87iCE4dflgBPeFQNsAM4G3gHsMPdG9y9E3gCWJjoRdz9AXevcveq0tLSU30fJ1UXadc59CKSsZIJ+rXAbDObbma5RL9MXRlXZzdwFYCZlQFzgO3B9kvMbHQwfn8VsCVVjU9WfVObzrgRkYzV7yrZ7t5lZncBTxM9a2a5u28yszuC8mXAl4EVZvYq0aGez7j7QeCgmf0UeInol7PrgQcG5630bV+knctmlQz1y4qIDAv9Bj2Au68CVsVtWxZzvw54Zx/7fgn40gDaOCAt7Z20HOtSj15EMlboZ8bWa2UpEclwoQ/6uiatLCUimS30Qa8evYhkuvAHfVMbWQZlhZosJSKZKfRBXxdpZ0JhHjnZoX+rIiIJhT799kXadXliEclooQ/6uogmS4lIZgt10Ls79U1aWUpEMluogz7S1klbZ7d69CKS0UId9HXB5Ykn69RKEclgoQ76+mDBEfXoRSSThTro6yLq0YuIhDro90XayMkySgo0WUpEMleog76+qZ2yMXlkZyVaJEtEJDOEOuh1Dr2ISMiDvj7SrouZiUjGSyrozewaM9tmZjVmdk+C8rFm9pSZvWxmm8xsSUzZODP7qZltNbMtZnZpKt9AX9yd+ki7Lk8sIhmv36A3s2zgfuBaYB5ws5nNi6t2J7DZ3c8DrgS+GawvC/Bt4NfufjZwHkO0Zuyhox10dPVo6EZEMl4yPfoFQI27b3f3DuBxYFFcHQcKgwXAC4BGoMvMxgCXAw8CuHuHuzelqvEnU9+k69CLiEByQV8O7Il5XBtsi3UfMBeoA14FPuXuPcAMoAH4vpmtN7PvmVl+ohcxs6VmVm1m1Q0NDaf6Pk7QO1lqsq5zIyIZLpmgT3Ruosc9vhrYAEwGzgfuC3rzOcB84LvufgFwFDhhjB/A3R9w9yp3ryotLU2u9SfRu7LURA3diEiGSyboa4EpMY8riPbcYy0BnvCoGmAHcHawb627vxjU+ynR4B90dZE2crOzGJ+f239lEZEQSybo1wKzzWx68AXrTcDKuDq7gasAzKwMmANsd/d9wB4zmxPUuwrYnJKW96O+qZ2JY/PI0mQpEclwOf1VcPcuM7sLeBrIBpa7+yYzuyMoXwZ8GVhhZq8SHer5jLsfDJ7ibuDR4JfEdqK9/0FXr8lSIiJAEkEP4O6rgFVx25bF3K8D3tnHvhuAqtNv4umpa2pnwfTioX5ZEZFhJ5QzY7t7nP3N7erRi4gQ0qA/dOQYXT2uc+hFRAhp0Pdeh37SGPXoRURCGfT1TcHKUuMU9CIioQz64ytLaVasiEg4g76+qY28EVmMGz0i3U0REUm7cAZ9pJ3JY0cRvcaaiEhmC2XQ10XaND4vIhIIZdDvi7QzSePzIiJACIO+q7tHk6VERGKELugPtByjx1GPXkQkELqg711wRGP0IiJRoQv6uiadQy8iEit0Qa8evYjInwpd0Nc1tVMwMocxeZosJSICIQz66KmV6s2LiPRKKujN7Boz22ZmNWZ2wuLeZjbWzJ4ys5fNbJOZLYkrzzaz9Wb2i1Q1vC/1kTZdnlhEJEa/QW9m2cD9wLXAPOBmM5sXV+1OYLO7nwdcCXwzWDqw16eALSlpcT/qIu26PLGISIxkevQLgBp33+7uHcDjwKK4Og4UWvTiMgVAI9AFYGYVwPXA91LW6j50dPVw8MgxfRErIhIjmaAvB/bEPK4NtsW6D5gL1AGvAp9y956g7J+BvwV6OAkzW2pm1WZW3dDQkESzTrS/uR13nVopIhIrmaBPdAlIj3t8NbABmAycD9xnZmPM7F3AAXdf19+LuPsD7l7l7lWlpaVJNOtEdVpwRETkBMkEfS0wJeZxBdGee6wlwBMeVQPsAM4GLgPeY2Y7iQ75vN3MfjDgVvehvncJQfXoRUSOSybo1wKzzWx68AXrTcDKuDq7gasAzKwMmANsd/fPunuFu1cG+/3O3T+astbH6Q36yerRi4gcl9NfBXfvMrO7gKeBbGC5u28yszuC8mXAl4EVZvYq0aGez7j7wUFsd0L1kTbGjhrB6Nx+35aISMZIKhHdfRWwKm7bspj7dcA7+3mOZ4FnT7mFp6CuSZOlRETihWpmbH2kTUEvIhInZEHfrlmxIiJxQhP0PT3OFWeVclFlUbqbIiIyrITmW8usLOOfPnR+upshIjLshKZHLyIiiSnoRURCTkEvIhJyCnoRkZBT0IuIhJyCXkQk5BT0IiIhp6AXEQk5c49fQyT9zKwB2HWau5cAQ37lzFOg9g2M2jcwat/ADOf2TXP3hKs2DcugHwgzq3b3qnS3oy9q38CofQOj9g3McG9fXzR0IyIScgp6EZGQC2PQP5DuBvRD7RsYtW9g1L6BGe7tSyh0Y/QiIvKnwtijFxGRGAp6EZGQOyOD3syuMbNtZlZjZvckKDcz+5eg/BUzmz/E7ZtiZr83sy1mtsnMPpWgzpVmFjGzDcHt/wxxG3ea2avBa1cnKE/bMTSzOTHHZYOZNZvZp+PqDOnxM7PlZnbAzDbGbCs2s/80s9eCnwmXN+vv8zqI7ftHM9sa/Ps9aWbj+tj3pJ+FQWzfvWa2N+bf8Lo+9k3X8ftRTNt2mtmGPvYd9OM3YO5+Rt2AbOB1YAaQC7wMzIurcx3wK8CAS4AXh7iNk4D5wf1C4I8J2ngl8Is0HsedQMlJytN6DOP+vfcRnQyStuMHXA7MBzbGbPs6cE9w/x7ga320/6Sf10Fs3zuBnOD+1xK1L5nPwiC2717gr5P490/L8Ysr/ybwf9J1/AZ6OxN79AuAGnff7u4dwOPAorg6i4CHPeoFYJyZTRqqBrp7vbu/FNxvAbYA5UP1+imS1mMY4yrgdXc/3ZnSKeHuzwGNcZsXAQ8F9x8C3ptg12Q+r4PSPnd/xt27gocvABWpft1k9XH8kpG249fLzAz4IPBYql93qJyJQV8O7Il5XMuJIZpMnSFhZpXABcCLCYovNbOXzexXZnbO0LYMB54xs3VmtjRB+XA5hjfR93+wdB4/gDJ3r4foL3dgQoI6w+U4fpzoX2iJ9PdZGEx3BUNLy/sY+hoOx++twH53f62P8nQev6SciUFvCbbFnyOaTJ1BZ2YFwM+AT7t7c1zxS0SHI84D/hX4+RA37zJ3nw9cC9xpZpfHlaf9GJpZLvAe4CcJitN9/JI1HI7j54Eu4NE+qvT3WRgs3wVmAucD9USHR+Kl/fgBN3Py3ny6jl/SzsSgrwWmxDyuAOpOo86gMrMRREP+UXd/Ir7c3Zvd/UhwfxUwwsxKhqp97l4X/DwAPEn0T+RYaT+GRP/jvOTu++ML0n38Avt7h7OCnwcS1EnrcTSzxcC7gI94MKAcL4nPwqBw9/3u3u3uPcC/9/G66T5+OcCNwI/6qpOu43cqzsSgXwvMNrPpQY/vJmBlXJ2VwK3BmSOXAJHeP7GHQjCm9yCwxd2/1UediUE9zGwB0X+LQ0PUvnwzK+y9T/RLu41x1dJ6DAN99qTSefxirAQWB/cXA/+RoE4yn9dBYWbXAJ8B3uPurX3USeazMFjti/3O54Y+Xjdtxy/wDmCru9cmKkzn8Tsl6f42+HRuRM8I+SPRb+M/H2y7A7gjuG/A/UH5q0DVELfvLUT/vHwF2BDcrotr413AJqJnEbwALBzC9s0IXvfloA3D8RiOJhrcY2O2pe34Ef2FUw90Eu1l3gaMB34LvBb8LA7qTgZWnezzOkTtqyE6vt37GVwW376+PgtD1L5Hgs/WK0TDe9JwOn7B9hW9n7mYukN+/AZ60yUQRERC7kwcuhERkVOgoBcRCTkFvYhIyCnoRURCTkEvIhJyCnoRkZBT0IuIhNz/B5Ivxl9MhyL+AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(np.arange(len(acces)), acces)\n", + "plt.title('train acc')" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEICAYAAABWJCMKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAA/bUlEQVR4nO3deXic1Xn4/e+tfd9XW5IteZFsDHbAGINZTAjEkKZkbaFJoARCnAayNWkI7a/pe/VtS0gIJW9piElJIZCQpSHwSxw2ly3EBhuwjYQkS5Zla99sabRvc94/5hl5PB5JI2mWR5r7c126NPMsM2fG8tzznHOf+4gxBqWUUpEnKtwNUEopFR4aAJRSKkJpAFBKqQilAUAppSKUBgCllIpQGgCUUipCaQBQSqkIpQFARRQRaRSRDwTgcf5aRP4YiDYpFS4aAJRSKkJpAFARQ0R+CpQA/1dEBkTk76ztW0XkTyLSKyKHRGS7xzl/LSINItIvIsdE5FMisg54CLjYepzeaZ7vFhGpts5tEJHPe+2/XkQOiohDRI6KyA5re5aI/EREWkXklIj8Nhjvh1KipSBUJBGRRuA2Y8yL1v3lwGHgM8CzwFXAk0AFMAS0ARcaY2pFpBDIMsZUichfW49z6QzP9SGgBmgALgf+AFxqjHlbRLYALwCfAPYAhUCqMaZGRH4PDAA7rd+XGGNeCew7oRTEhLsBSoXZp4Hdxpjd1v0XROQAcB3wa8AJbBCRE8aYNlwBwS/GmN973H1FRJ4HLgPeBm4FHjHGvGDtbwGwgsy1QLYx5pT73Pm9NKVmpl1AKtKtAD5pdf/0Wt05lwKFxphB4C9xfRNvE5Hfi0iFvw8sIteKyD4ROWk97nVAjrW7GDjq47Ri4KTHh79SQaMBQEUa7z7PJuCnxpgMj59kY8w9AMaY54wxV+PqoqkBHp7mcc4gIvHA/wDfA/KNMRnAbkA8nneVj1ObgCwRyZjzK1NqjjQAqEjTAZR53H8c+LCIfFBEokUkQUS2i0iRiOSLyJ+LSDIwiqs/ftLjcYpEJG6a54kD4oEuYEJErgWu8dj/X8AtInKViESJyHIRqbC6mf4A/KeIZIpIrIhcHrBXr5QHDQAq0vwb8A9Wd8/XjTFNwPXA3bg+rJuAb+D6vxEF/C3QCpwErgD+xnqc/wWqgHYR6fZ+EmNMP/Al4JfAKeCvgGc89r8J3ALcD/Th6udfYe3+DDCO64qjE/hKYF66UmfSLCCllIpQegWglFIRSgOAUkpFKA0ASikVoTQAKKVUhFpUM4FzcnLMypUrw90MpZRaVN56661uY0yu9/ZFFQBWrlzJgQMHwt0MpZRaVETkuK/t2gWklFIRSgOAUkpFKA0ASikVoTQAKKVUhNIAoJRSEUoDgFJKRSgNAEopFaE0ACi1xB3tGuBXB5rQyr/K26KaCKaU8l/zqSF+sKeOX7/VjNPAOcvSWb8sLdzNUjaiAUCpJaarf5QHX6rnZ2+cAOCD5xTwh8p2Tpwc1ACgzqABQKklom9onF2vHeWRPzYyNunkkxcUcedVa0hNiLECwFC4m6hsRgOAUovc0NgEP3m9kR+9chTHyAQf3riMr35gDWW5KVPHZCTFagBQZ9EAoNQiNToxyc/fOMF/vHSU7oFRrqrI42vXrOWcZelnHVuSlcSJk8NhaKWyMw0ASi0yE5NOfvNOCw+8WEdL7zAXlWbxo8+czwUrsqY9pzgrifdaHSFspVoMNAAotUg4nYY/VLZz3wu1NHQNcl5ROvd8/FwuXZ2DiMx4bklWEs9XtTPpNERHzXzsUvNGQw//+HQVO7eX8ZFNy2d9ryKJBgClbM4Yw8tHuvjec7VUtTpYk5fCQ5++gA+ek+/3h1lJVhLjk4Z2xwjLMxKD3GL7aD41xBeeeJv+kXG++otDvFTTxT9/ZAPpibHhbpotaABQyuae3N/Et37zLsVZiXz/LzZy/ablc/4WX5KVBMCJnqGICQDDY5Pc/thbjE862f2ly3iuqp37X6zjreOnuP8vN7GldPous0jh10xgEdkhIrUiUi8id/nYnykiT4nIYRF5U0Q2eOz7qohUiUiliPxcRBKs7Vki8oKI1Fm/MwP3spRaGgZGJ7jv+VouXJnJnq9t52PnF82rC8cdAJoiJBPIGMM3fn2I6nYHP7jhfazJT+WO96/h1zsvJiZauGHXXr77XA3jk85wNzWsZg0AIhINPAhcC6wHbhSR9V6H3Q0cNMacB9wEPGCduxz4ErDZGLMBiAZusM65C9hjjFkD7LHuK6U8PPxqA90DY9x93TriYuZfuaUwPYHoKImYVNAfvnKU3x1u4+8+WMGVFXlT299XksnuL13GJy4o4sGXjvKJH/6JY92DYWxpePnzF7UFqDfGNBhjxoAngeu9jlmP60McY0wNsFJE8q19MUCiiMQASUCrtf164FHr9qPAR+b7IpRaijodIzz8WgPXnVvA+0oWdoEcEx3F8ozEiAgAL9V08t3navnwxmXsvKLsrP3J8THc+4mN/OenzqexZ4gP/eA1frH/RETWSvInACwHmjzuN1vbPB0CPgYgIluAFUCRMaYF+B5wAmgD+owxz1vn5Btj2gCs33n4ICK3i8gBETnQ1dXl36tSagn49z11jE04+cYHKwLyeK65AEs7ABztGuBLP3+HdQVp3Pvx82YcJL/u3EKe/cplbCrO4Jv/8y5fePxtTg2OhbC14edPAPD1DnqHynuATBE5CNwJvANMWP361wOlwDIgWUQ+PZcGGmN2GWM2G2M25+bmzuVUtUQcbu7l//y2Eqczcr6h1XcO8Iv9TXzqohJKc5ID8pjFWUlLegzAMTLO5x47QGxMFLtuuoDEuOhZzylMT+TxWy/i7usq2FPTwY4HXuX1+u4QtNYe/AkAzUCxx/0iTnfjAGCMcRhjbjHGbMI1BpALHAM+ABwzxnQZY8aB3wCXWKd1iEghgPW7cyEvRC1NTqfhW795l5/uO87xJfzh5e3eZ2tIjI3mzqvWBOwxS7KS6BkcY2B0ImCPaReTTsNXnjzIiZ4h/vNT51OUmeT3uVFRwu2Xr+Kpv9lGSnwMn/rxG/zr7mpGJyaD2GJ78CcA7AfWiEipiMThGsR9xvMAEcmw9gHcBrxqjHHg6vrZKiJJ4roWuwqoto57BrjZun0z8PTCXopain73bhtV1gzWmrbImMl6oPEkz7/XwecvLyMnJT5gj+uZCrrUfP+FWv63ppNvf3g9W8uy5/UYG5an87s7L+PTW0vY9WoDH33wT9R39ge4pfMTrPGJWQOAMWYCuAN4DteH9y+NMVUislNEdlqHrQOqRKQGV7bQl61z3wB+DbwNvGs93y7rnHuAq0WkDrjauq/UlLEJJ/c9X8uavBSiBKrb7fGfMZiMMfzr7mryUuO59bLSgD72VABYYldSvzvcyoMvHeWGC4v59NYVC3qsxLho/t+PnMuPb9pMu2OED/3gj/x0b2NYB4gPNJ7k+gdfD0rg9msimDFmN7Dba9tDHrf3Aj6vVY0x3wa+7WN7D64rAqV8+sX+ExzvGeKRv97Mv/y+mtr2pX8F8FxVO2+f6OWej51LUlxg52mWZC+9uQDvtTr4xq8Oc8GKTP6f688JWJmHD6zP59niy/j6rw7zf56u4qVa1wziUE6ic4yMc++zNTy+7wTLMxLpGhid+jcMFF0SUtnS0NgED+ypZ8vKLK4sz6OiMI2aJX4FMD7p5DvP1rI6L4VPXFAU8MdPT4wlPXHplIU+OTjG5x47QHpiLD/89PnEx8w+6DsXeakJ/PdfX8i3P7ye1+u7ef/3XubeZ2voHxkP6PP48mxlO1d//xV+9sYJPrutlOe/ejkXrAj8XFkNAMqWHvnjMboHRvnmtRWICBX5qRzvGWJwCQ5guj355gmOdQ9y144KYqKD819zqaSCjk86+Zsn3qJrYJQffeYC8lITgvI8UVHCLdtK+d+vb+e6cwv5z5ePcuX3XuaJN44zEYRZxB2OET7/0wPsfPwtspLjeepvtvGPH15PcnxwqvZoAFC2c2pwjB+90sDV6/OnvvVUFLqWMjzSsTSvAgZGJ3hgTx1bSrO4ap3PKTEBUbJEUkH/5ffV7Gs4yb999Fw2FmcE/fmWZyRy/19u4ukvbqMsJ4W/f6qS637wGq8cCczcJKfT8Pi+43zgvld4ubaLb+6o4Jk7tgX9tWkAULbz4Ev1DI5N8HcfLJ/aVlGQChCWbqDX67u5+vuvUBPEMYhdHiUfglmuuDgrieZTw0wu4jkVv9zfxH//qZFbLy3l40HoKpvJxuIMfvH5rTz06fMZnXBy8yNvctMjb1K7gL/Luo5+/uJHe/mH31ZyXnE6z33lcr6wfRWxQboK9KQBQNlKS+8wj+09zsfPL2JNfurU9uUZiaTEx4QlFXRPdSd1nQN86uE3gnIF0ukY4eFXG/jQuYVsCvI3vpKsJMYmnXQ4RoL6PMHy9olT/MNvK7l0dQ7fujYwM6TnSkTYsaGQF756Bf/woXUcPHGKax94lW/95l26+kf9fpzRiUnuf+EI1/3gNeq7BvjeJzfy+K0XsTJAE//8oQFA2cr9LxwBga9cvfaM7VFRQnlBaliuACpb+yjNSSY6Svirh/dRF+Ag8O976hifdPINjyueYFnMqaAdjhF2/vQtCtIT+I+/el/Qxkn8FRcTxW2XlfHKN67k5ktW8qsDTWz/7ks8+FI9I+MzTyLb33iS6x54jQf21HHduYW8+LUr+MQFRSFfrEYDgLKNIx39/ObtZm7ausJnup07AIQyJ9vpNLzX6uCyNTn8/PatiAg3PvwG9Z0DAXn8+s5+frG/iU9vXRGSb36LNQCMjE9y+0/fYmB0godv2kxGUtzsJ4VIZnIc3/7wOTz/1cu5ZHUO332ulvd/72WePthyVvmSvuFx7n7qXT750F5Gxp385JYLeeCG9wV0wt9caABQtnHvs7Ukx8XwxStX+9y/riCVvuFx2kPYfXH85BADoxNsWJbOqtwUfv65rQDc+PA+jnYtPAh859laV8mH9/t+zYFWmOEqC72YBoKNMfz9U5Ucaurl+3+xifKC1NlPCoOy3BQevmkzP//cVjKT4/jykwf56H++zv7Gkxhj+MO7bVz9/Vd48s0T3HZpKS987XKuLA/egL8/NAAoWzjQeJIXqzv4/BVlZCb7/nbnzgQKZTdQZUsfAOcsdz336rwUfv65izDGcOOufTQsIAjsbzzJC+91sPOKMrJD9A0wNjqKZRkJi+oKYG9DD//zdjNfev9qdmwoCHdzZnXxqmz+7x2Xct8nN9LhGOWTD+3lg//+Kl944m1yUuL57Re38Q9/tj7gE/3mQwOACjtjDN95tobc1Hg+e+n05Q/WWoPCNW0hDACtfcRFR7Em7/S3zjX5qfzsc1uZdBpufHjfvBYUcZd8yE+L59ZLz65ZH0yLbS6AOwjP9LdhN1FRwscvKOKlr2/na1evxWngrmsrePqObZxXlBHu5k3RAKDC7qXaTvY3nuJLV62Z8VtRemIsyzMSg5qO6a2qxUF5QepZq3GtzU/lic9dxPik60qgcY5B4NnKdt450cvXrl7rV9niQFpscwHqOgbISYm3Vb+/vxLjovnSVWt48WtXsPOK0KR2zoW9WqMizqTTcO+ztazMTuKGC4tnPb6iIHVBOddzYYyhsrWPDVb3z9ltSeOJ2y5idGKSGx/e53exrvFJJ/c+5ypy9/HzQ5vHDq65AN0DY4tmVnVd5wBr8lLC3YwlSQOACqunD7ZQ097P315T7te3o/KCVOo7BxibCP5i3i29w/QOjXPOsvRpj1lXmMYTt21leNwVBPz5Zj1V8uHa4JV8mMnUAvGn7H8VYIzhaOcAa/I1AASDBgAVNqMTk9z3/BE2LE/jQ+cW+nVORWEaE04TkAyc2VS2uLqaNiyfPgAArF+WxuO3XsTA6AQ37Jo5CAyMTvDvL9ZxUWkW768ITwaIOwAcXwTrAnQ4RukfndArgCDRAKDC5ol9J2jpHeabOyqIivJvAoy7JEQouoGqWvuIjpKp55zJhuXpPHHbRfSPjHPjw/to6R32edyuV47SMzjGt4Jc8mEmU1cAi2AcoM5akGWVBoCg0ACgwqJ/ZJz/eKmebauzuWyN/2s9l+YkExcdRXUIBoIrW/pYk5dCQqx/g7SuILCVvuFxbti1l1avINDpGOHh147xofOCX/JhJumJsaQmxCyKTKC6DteVnmcWlgocDQAqLB5+7RgnB8f45o651XOJjY5idV5KSK4AKlsdM/b/+3JuUTqP33oRvYOuK4G2vtNB4P4X65hwOs8ochcOIrJoUkHruwbISIolJ2XxZQAtBhoAVMh19Y/y49dcxc/mkxNdUZAa9LkAnY4RuvpHp80AmsnG4gweu3ULJwfGuHHXPtr7RqySDyf41EUrWJEdumJf01mRvUgCQIcrAyhc3WVLnQYAFXL/8b91jE44+dtr1s5+sA8Vham0O0boHRoLcMtOq2x1TT6abQB4Ou8ryeS/P7uF7oExbnx4H99+poqkuJiQlXyYTXFWEs0nh8+qVWMnxhiOdPazWvv/g0YDgAqpEz1D/OzNE/zlhcWU5c7vP3ZFQfBLQlS2OBBxpXnO1wUrMnn0sxfS6Rjh9foevrB9VchKPsxmqix0v33LQvcMjtE7NM5q7f8PGg0AKqTue6GW6Cjhy1etmfdjTC0OE8S1ASpbXCWgUxa4FN8FK7J47NaL+NRFJXx2m31KGUxVBbVxKqi74qqmgAaPXwFARHaISK2I1IvIXT72Z4rIUyJyWETeFJEN1vZyETno8eMQka9Y+/5JRFo89l0X0FemAuZ3h1vZ8i8v8vmfHuCxvY0c7RqYV0nmqtY+nj7Yyi3bSslPm/8arrmp8WQlxwX1CqCq1cGGOQ4AT+eCFZn8y0fPDXnJh5kshrLQde4AoJPAgmbWrzciEg08CFwNNAP7ReQZY8x7HofdDRw0xnxURCqs468yxtQCmzwepwV4yuO8+40x3wvIK1FB8781nfSPTFDZ4uC5qg4ACtISuGR1NttW5bBtdQ4F6bN/oH/3uVrSE2PZecWqBbVHRCjPD97iMCcHx2jpHebmS1YE5fHtYFlGIlFi77kA9R39pMTHULCALwtqZv5c324B6o0xDQAi8iRwPeAZANYD/wZgjKkRkZUikm+M6fA45irgqDHmeGCarkKlpq2fLaVZ/PctF3Li5BCv1/fw+tFuXq7t4jdvtwBQlptsBYNstpZln1W4a19DDy/XdvGtaytIT4xdcJsqClN58s0mnE7j9yQyf1W5B4ADdAVgR66y0Im2vwJYpRlAQeVPAFgONHncbwYu8jrmEPAx4I8isgVYARQBngHgBuDnXufdISI3AQeAvzXGnJpD21UIjE86qe8c4LK1OYgIK7KTWZGdzF9dVILTaahp7+dPR7t5vb6b/3m7mZ/uO46I68PTfYWweWUm9/yhhsL0BG6+ZGVA2rWuII3h8UlOnBwK+Epa7hIQc50DsNjYfS5AfecAl6/1f5Kgmjt/AoCv8OvdAXwP8ICIHATeBd4BpkoNikgc8OfAtzzO+SHwz9Zj/TNwH/DZs55c5HbgdoCSkhI/mqsCqaFrkLFJJ+t9ZMNERQnrl6Wxflkat11Wxvikk0NNvVNXCI/88Rg/eqWBmChhwmn4zsfP9XtW7Wzcq0LVtPcHPgC09lGclUh60sKvVOysJCuJF6s7w90Mn/qGxunsH9UB4CDzJwA0A551eouAVs8DjDEO4BYAcV2vHbN+3K4F3vbsEvK8LSIPA7/z9eTGmF3ALoDNmzfbN2l5iXLX3nenXs4kNjqKzSuz2Lwyiy9/YA1DYxPsbzzFn+q7GRidCGjp47X5qYi42hfoVaKqWvqWdPePm6ss9ChDYxO2WJ3KU32Xa3xH5wAElz//6vuBNSJSimsQ9wbgrzwPEJEMYMgYMwbcBrxqBQW3G/Hq/hGRQmNMm3X3o0DlvF6BCqr32hzERgtluXP/lp0UF8MVa3O5IgiX8Ylx0ZRmJwd8RrBjZJzGniE+uXn2tQkWu9NF4YZtt86u1gAKjVkDgDFmQkTuAJ4DooFHjDFVIrLT2v8QsA54TEQmcQ0O3+o+X0SScGUQfd7roe8VkU24uoAafexXNlDT1s/qvFTbrWQErm6gQGcCvdfq7v+f/wSwxcIzFdRuAaC+c4CE2CiWZyaGuylLml/XfcaY3cBur20PedzeC/ic2WOMGQKyfWz/zJxaqsKipt3BttU54W6GTxUFaTxb1R7QLoypReAjoAvo9LoAc1/TONjqOgdYlZtCdIAzvNSZ7Pe1TtnGycExOhyjrPOj/z8cKgpTMQaOdARucZiqVgf5afHkptqjZEMwZSTFkhofY8u5APWdA9r/HwIaANS03KUWKgrt1T3gdnpxmMCVhKiMkAFgcE2oK7ZhKujg6AQtvcOaARQCGgDUtKqt/nV/MoDCoTgziaS4aKoDNBA8NDbB0a4BzplnBdDFyI5zAdzLfWoRuODTAKCmVdPmICfFvt0hUVHC2vzUqVTVhapu68dpYEMEDAC7lWQn0XTKXmWhpzKAtAZQ0GkAUNOqae9nnU27f9zWFaZS294/r+J03t5b4BoAi1FxVhJjE046+0fD3ZQpdZ0DxEYLK6xBahU8GgCUTxOTTmo7+v1aED2cKgrSOGXNGl2oyhYHWclxFPpR2G6pWGHDqqD1nf2U5iQTY8PU46VG32HlU2PPIGMTTtv2/7t5loRYqMrWPs5ZlhZRxcfsWBa6vnNAJ4CFiAYA5ZN7YHUhK2KFQqAWhxmdmORIR39Edf/A6bLQdgkAI1aBP00BDQ0NAMqnmnYHMVHCqrzwL2A+k4wkV5fNQq8A6joGGJ80EZMC6hYXE0VheqJt5gI0dA3iNFoDKFQ0ACifqtv6WZWbQnyMfVaxmk4gSkK4ZwBvWG7vK55gsFMqaF2n699RM4BCQwOA8qmmzWHbCWDeKgrSqO/sZ3zSOe/HqGztIzUhZqpPPJLYKQAc7RwgSqA0wCW+lW8aANRZ+obGae0bsX3/v1tFQSrjk4aGrvnXtKlscUTcALBbSXYSXf2jDI9Nhrsp1HUOsDI7eVFceS4FGgDUWU6vAbBIrgAK3ZlA8xsInph0Ut0WuEXgF5tid1noU+G/CnAvA6lCQwOAOku1lVGzWK4AynJSiI2WeY8DHO0aZHTCGXEZQG5TqaA94Q0A45NOGrsHtQZQCGkAUGepae8nMymWPJuWgPAWFxPFqtyUeaeCRvIAMNhnLsDxnkEmnEYHgENIA4A6S3V7P+sKF1d/eEWBqyTEfFS29pEYG01pTmR+8GQmxZISHxP2AKCrgIWeBgB1hkmn4Uh7v+1nAHurKEyjtW+EvqHxOZ9b1eJg/bK0iF18xC5loes6XQFgPsuPqvnRAKDOcLxnkOHxyUWTAup2uiTE3LqBnE5DVWtfRFUA9aUkK9EWAaAoM9F2C9QvZRoA1BncA6l2XQVsOu721nbMrRuosWeQwbHJiFoDwJeSrCSaTg6FtSy0qwZQZHbDhYsGAHWGmjYHUbL4ZmLmp8WTkRQ758VhKq1F4CM1BdStJCuJ0QknXQPhKQs96TQc7RpgTf7iuvJc7DQAqDO819ZPWW4KCbGLayKOiFA+j8Vhqlr6iIuOWnQBL9CKw5wJ1HRyiLEJJ6tzI/vfIdQ0AKgz1LQ7Fs0EMG/rCtM40t4/p26MytY+KgpTiY3w2vPhngvgHgBeHeGBONT8+qsXkR0iUisi9SJyl4/9mSLylIgcFpE3RWSDtb1cRA56/DhE5CvWviwReUFE6qzfmQF9ZWrOHCPjNJ8aXjQTwLyVF6QyODZJ86lhv443xlglICK7+wdgeWYiEsay0PXuAKBjACE1awAQkWjgQeBaYD1wo4is9zrsbuCgMeY84CbgAQBjTK0xZpMxZhNwATAEPGWdcxewxxizBthj3VdhdMQ9ALzIMoDcKuaYCdR8api+4fGInQDmKT4mmmVhLAtd19lPQVoCaQmxYXn+SOXPFcAWoN4Y02CMGQOeBK73OmY9rg9xjDE1wEoRyfc65irgqDHmuHX/euBR6/ajwEfm3vzI8OSbJ7jm/leYWEC1S3+4S0AstjkAbmvzUxHxf3WwKvcawHoFAEBxGFNB6zsH9Nt/GPgTAJYDTR73m61tng4BHwMQkS3ACqDI65gbgJ973M83xrQBWL/zfD25iNwuIgdE5EBXV5cfzV169jb0cKRjgEPNvUF9nur2ftISYhbtmrjJ8a5yzv5eAVS2OIiOkqk5BJEuXGWhnU6jASBM/AkAvqZHeo+y3QNkishB4E7gHWBi6gFE4oA/B3411wYaY3YZYzYbYzbn5ubO9fQlobHbVeb4pZrgBkDXGgCLqwSEt4o5LA5T2drHmrzFl/EULCVZSXSGoSx0m2OEobHJiM/ECgd/AkAzUOxxvwho9TzAGOMwxtxi9fXfBOQCxzwOuRZ42xjT4bGtQ0QKAazfnXNvfmRotDIzXj4SvLfI6TTUtvezfpEOALtVFKTR2D0464eYawC4L2IrgPriTgVtDnFZ6Dpr8p7WAAo9fwLAfmCNiJRa3+RvAJ7xPEBEMqx9ALcBrxpjPK/Db+TM7h+sx7jZun0z8PRcGx8JTg2O0Tc8Tn5aPJUtDjodI0F5nqZTQwyOTS7aFFC3ioJUnOb00oLT6ewfpXtgLOJLQHgKV1VQzQAKn1kDgDFmArgDeA6oBn5pjKkSkZ0istM6bB1QJSI1uL7tf9l9vogkAVcDv/F66HuAq0Wkztp/z0JfzFJ0rMfV/fPpi1YA8PKR4HQDuWfQViz2KwCr/bN1A50uAa1XAG7hCgB1HQNkJ8eRlRw3+8EqoPyqumSM2Q3s9tr2kMftvcCaac4dArJ9bO/BlRmkZnDcCgDXnlvA428c55XaLv5ic/EsZ81dTbsDEShf5FPxS7KSSIyNpmaWkhCVLa7Xu1jnPARDVnIcyXHRob8C6NIB4HCJ7OmPi8Cx7iGixNU/u31tHq/WdS1o8fPp1LT1U5qdTGLc4h4QjY4S1uanzJoJVNnaR2lOMsnxWnnSzV0WOpRzAYwx1HX06wBwmGgAsLnjPYMsy0gkPiaaKyty6R+Z4O3jpwL+PNXtjkVXAno6FQVp1LT3Y8z0JSGqWvo0/9+HkqwkjoewHERX/yiOkQmtARQmGgBsrrF7kNIc1wIZ21bnEBMlAR8HGByd4HjP0KKdAOatvCCVk4Nj01a27BkYpbVvRGcA++CeCzBT8Awk9wCwVgENDw0ANmaM4Vj3ICuyXYNzqQmxbF6ZyUs1gU0HddfQXyr94e4rmenGAaq0BPS0SrKtstD9oSkL7S4Cp+sAhIcGABvrHRrHMTLByuzTS+RdWZ5HTXs/7X2BSwd1f1Au9hRQN/eVzHRrBFdaJSC0CNzZQl0Wuq7TNfs8NzU+JM+nzqQBwMbcKaDuLiCA7eWuihkv1wbuKqC6zUFKfAxFmYkBe8xwykqOIy81nuppBoKrWhwUZyWSnqSFx7yFOhW0rsOVAbSYZ58vZhoAbMydArrC4wpgbX4Ky9ITeCmAAcC9BsBS+k9YUZg2bRdQZasOAE9neUZoy0If7RrQGcBhpAHAxk6ngJ7+Zi4iXFGex+v1PYxNLDwd1BhDTVv/kun/d1tXkEp958BZFVT7hsc53jOkE8CmkRAbTUFaQkgCwMnBMboHxjQFNIw0ANhYY/fpFFBPV5bnMjA6wYHjJxf8HC29w/SPTiyZFFC38oJUxiadHLMK6bm9Zw0An6MlIKYVqrkAWgIi/DQA2NjxnsEz+v/dtq3OITZaeKV24emgUyUglkgKqJv79VR7DQRX6QDwrEJVFtpdr0kDQPhoALApdwqoZwaQW3J8DFtKswIyDlBjLQKz1Grir8pLJjpKqPUaCK5s6aMgLUGzTmawIiuJDscoI+PBLQtd3zlAUpxrJTIVHhoAbOqUlQLqngPg7cryPI50DNDS69/6t9Opae9nRXYSKUusJEJ8TDSrcpPPGgiuanXoBLBZlGSHpiy0exGYqKilk3yw2GgAsKlGHymgnraXuxbHWWg6aHWbY8nk/3tzl4RwGxqb4GjXgHb/zCJUcwHcKaAqfDQA2JR7FbAVPrqAAFblplCUmbigVcKGxyY51jO45Pr/3coLUmnpHcYxMg64xjucRktAz2ZqLkAQawI5RsZpd4xoAAgzDQA21djjSgF1/2f0JiJcWZ7Hn452Mzoxv77aIx39GAPrllgGkJv7dblnBE8tAq9dQDPKTo4jKS6aEycX1r04k6NTJSCW5t/eYqEBwKYauwdZnplIXMz0/0Tby3MZGptk/7H5VQd1l0xeanMA3NxXNu5uoMqWPrKT4yhIW5yL3oeKiAQ9E0hrANmDBgCbauzxnQHk6eJV2cTFRM07G6i6rZ+kuGiKM31fZSx2hekJpCbETGU6VbY4OGd5+pKa8RwswZ4LUN85QFxM1NR4gwoPDQA2NFMKqKekuBguKs2a90BwdZuD8oLUJZuFISKsswaCRycmOdLRr2sA+ynYZaHrOvopy3Gl6qrw0QBgQ6eGxumfIQXU05XleRztGpzzgJ0xhpr2/iU7AOxWUZhKbXs/te39TDiNDgD7qSQrieHxyWnXVFio+q4BXQPABjQA2NBsKaCerqywqoMemdtVQLtjhL7hcdYv0QFgt/KCVAZGJ3iuqh3QNQD85U4+CEY30NDYBM2nhrX/3wY0ANiQOwV0pR8BoDQnmRXZSbw8x7IQ1Va/eMUSHQB2c1/h/ObtFlITYs4orKemF8y5AA1dgxijA8B24FcAEJEdIlIrIvUicpeP/Zki8pSIHBaRN0Vkg8e+DBH5tYjUiEi1iFxsbf8nEWkRkYPWz3WBe1mLW2P3oKsKqJ+Ds+500LlM3XfXAFpqJSC8uV9fW98IG5bpALC/3GtDnOgJfCqo1gCyj1kDgIhEAw8C1wLrgRtFZL3XYXcDB40x5wE3AQ947HsAeNYYUwFsBKo99t1vjNlk/exewOtYUhp7hmZNAfV0RXkuI+NO9jX0+P0cNe39LM9IJC1haS+KkhJ/+lu/5v/7L5hloes7B4iJkmknOarQ8ecTZgtQb4xpMMaMAU8C13sdsx7YA2CMqQFWiki+iKQBlwP/Ze0bM8b0BqrxS5U/KaCeLi7LJj4mak7dQDVtjiWb/+/N3Q2kA8BzUxKkVNC6jgFW5iT7/QVHBY8//wLLgSaP+83WNk+HgI8BiMgWYAVQBJQBXcBPROQdEfmxiHh+st1hdRs9IiKZvp5cRG4XkQMicqCra+Hlj+3O3xRQTwmx0VyyKtvvdNCR8UkaugeX7Axgb+5aR1oDaG6KgzQZrL5zQPv/bcKfAOCr09Q7OfgeIFNEDgJ3Au8AE0AMcD7wQ2PM+4BBwD2G8ENgFbAJaAPu8/XkxphdxpjNxpjNubm5fjR3cXOngPozAOxpe3kejT1DZy2A4kt95wCTTrPkU0Dd/vLCYr65o4JVudrlMBclWUm0O0YCWhZ6dGKSxp5B7f+3CX8CQDNQ7HG/CGj1PMAY4zDG3GKM2YRrDCAXOGad22yMecM69Ne4AgLGmA5jzKQxxgk8jKurKeK5P8BX+jEHwNOVc1gs/nQGUGRcARRlJvGF7at0AHiOSrJdYyfNpwI3ENzYPYTT6ACwXfgTAPYDa0SkVETigBuAZzwPsDJ94qy7twGvWkGhHWgSkXJr31XAe9Y5hR4P8VGgcgGvY8lwLwQ/1yuAkuwkynKTecmPcYCa9n4SYqPm1M2kIk8w5gK4M4C0CJw9zLoKiDFmQkTuAJ4DooFHjDFVIrLT2v8QsA54TEQmcX3A3+rxEHcCT1gBogG4xdp+r4hswtWd1Ah8PiCvaJGbawqop+1r83j8jeMMj02SGBc97XHVbQ7K81N1Gr6aUUmW6wtCIMcB6joGiBIo0+44W/BrGSgrRXO317aHPG7vBdZMc+5BYLOP7Z+ZS0MjxbE5poB6urIil0deP8behm7eX5Hv8xhjDNVtDq5ZX7DQpqolLicljsTY6IAGgPrOAYqzkkiInf4LigodzcOymeNzTAH1tKU0i8TY6BkXienqH+XU0HjE9P+r+QtGWWjNALIXDQA2Mp8UUE/xMdFsW53NS7Wd01ZxfK9taa8BoAIrkGWhJyadNHQPsFr7/21DA4CNzDcF1NP28jyaTw1ztMt3Oqh7cZSlug6wCqxAloU+fnKI8UmjVwA2ogHARtwpoKU5818kY7bF4mvaHBSmJ5CRFOdzv1KeSrISGRqbpGdwbMGPVdfhWgVMU0DtQwOAjcy2ELw/ijKTWJOXMm1ZCNcaAPrtX/mnxJqPcjwAC8Qf7XIFgFUaAGxDA4CNHO+Zfwqop+3lubx57CSDoxNnbB+dmKS+c0D7/5XfAjkXoK7DVYAwJd6v5EMVAhoAbGQhKaCerizPY2zSyZ+Onlkd9GjnIBNOs+TXAFCBU5QZuHUB6joHtPvHZjQA2MhCUkA9bV6ZRXJc9FmLxde0WxlA2gWk/JQQG01+WvyCA4DTaTjapQHAbjQA2IQ7BdSfZSBnExcTxbbVObxS23VG9kZNez9xMVEBeQ4VOQIxF6Cld5iRcadmANmMBgCbODk4Zi0EH5gP5ysr8mjpHaauc2BqW3Wbg7X5KcRE6z+78l8g5gJM1QDK1wBgJ/pJYBONVpbFQlJAPbnTQV+qOd0NVN3WHzEloFXgBKIs9FQKaK52P9qJBgA/HO8ZZE91R1CfY2oh+ABdARSmJ1JRkDqVDtrVP0r3wKimgKo5K81Jxhi49oHX+Pun3mX3u22cmuO8gLrOAXJT40lPWtpLkC42mo/lhwderOOZQ60c+vY1JAcphc2dAlq0wBRQT9vL8/jxaw30j4xTa80AXq8ZQGqOPnhOAf/4Z+v5Y303v32nhSfeOIGI629p2+ocLlmVzZbSLJLipv+/oTWA7EkDgB8ONvcy4TQcOH6KK9YGZ1WyYz1DFGUmBXSd1O3luTz0ylFer++m6aRrUY9yvQJQc5QQG81nLy3ls5eWMj7p5HBzL6/X9/B6fTc/ef0Yu15tIDZaeF9xJpeszmbb6hw2FWcQa401GWOo7xzg4+d7rySrwk0DwCz6hsdpsOrq7GvoCVoAaOweZMUcVwGbzQUrMkmNj+Hl2i7GJp3kpcaTnRIf0OdQkSU2OooLVmRxwYosvnTVGobHJtnfeJLXj3bzp/oeHthTx7+/WEdSXDRbSrPYtiqHNfkpDIxOsDpfv3zYjQaAWVS29AGQEBvFXq+JVYFijKGxZ5CPlgT2G1JsdBSXrc3h5douMpPjdAKYCrjEuGguX5vL5dYXo96hMfY19LiuEI5283Jt9dSxq3O1C8huNADM4mBTLwCfvKCYn715goHRiYBPZXengAZjicbta/PY/W477Y4RLl9bFvDHV8pTRlIcOzYUsmODa8XXtr5h/lTfQ/OpYTavzAxz65Q3zQKaxeHmXlZmJ7FjQwGTTsP+xpMBf47GqXWAA9sFBHBF+ekuq3WaAqpCrDA9kY9fUMSXP7BmakxA2Yf+i8ziUFMf5xVlcH5JJnHRUewLQjdQY7drDkAwrgDy0xKmMn90FTCllCcNADPocIzQ7hhhY3EGiXHRbCrOYF9DEAJAEFJAPV13bgEZSbGU5WgfrFLqNA0AMzhk9f9vLEoHYOuqbN5t6cMxMh7Q52kMQgqop51XrOKVr18ZtMdXSi1Ofn0iiMgOEakVkXoRucvH/kwReUpEDovImyKywWNfhoj8WkRqRKRaRC62tmeJyAsiUmf9tt0I0eHmPqKjhHOWWQGgLAungf3HAjsO0Ng9uKBlIGcTEx2lMzCVUmeZNQCISDTwIHAtsB64UUTWex12N3DQGHMecBPwgMe+B4BnjTEVwEbAnRd2F7DHGLMG2GPdt5VDzb2szU8lMS4awDUOEBMV0G4gY4wrAAR4DoBSSs3GnyuALUC9MabBGDMGPAlc73XMelwf4hhjaoCVIpIvImnA5cB/WfvGjDG91jnXA49atx8FPrKA1xFwxhgONfWyqTh9altCbDTnl2SwN4AB4OTgGP2jwUkBVUqpmfgTAJYDTR73m61tng4BHwMQkS3ACqAIKAO6gJ+IyDsi8mMRcX/S5Rtj2gCs33nzfhVB0NgzhGNkgvOKMs7YvrUsm6pWB33DgRkHCGYKqFJKzcSfACA+thmv+/cAmSJyELgTeAeYwDXR7Hzgh8aY9wGDzLGrR0RuF5EDInKgq8v3QufBcLi5F4CNXgHg4rJsjIE3AzQOEMwUUKWUmok/AaAZKPa4XwS0eh5gjHEYY24xxmzCNQaQCxyzzm02xrxhHfprXAEBoENECgGs32euX3j6sXcZYzYbYzbn5ganDo8vh5r6SIiNYq3XAhabSjKIjwlcWYjGnkGioyRoKaBKKTUdfwLAfmCNiJSKSBxwA/CM5wFWpk+cdfc24FUrKLQDTSJSbu27CnjPuv0McLN1+2bg6QW8joA71NzLhmXpZ62eFR8TzQUrMgM2EHyse5DlGQtfCF4ppeZq1k8dY8wEcAfwHK4Mnl8aY6pEZKeI7LQOWwdUiUgNrmyhL3s8xJ3AEyJyGNgE/Ku1/R7gahGpA6627tvC+KSTqta+s/r/3S4uy6a63UHv0NwWxfDleM9QUFNAlVJqOn5VNTPG7AZ2e217yOP2XmDNNOceBDb72N6D64rAdo509DMy7mSjRwaQp62rsjEvwBvHTvLBcwrm/TzuFNDzSzLm/RhKKTVf2u/gw+FmVwlo7wFgt41FGQEpD+1OAQ3UQvBKKTUXGgB8ONTUS3pi7LQLtMTFRLF5RdaCxwHcKaCl2gWklAoDDQA+HGru47yidER8ZcC6XLwqm5r2fk7OcXFsT8esFNBArwSmlFL+0ADgZXhskiMd/WwqzpjxuK1lWQC8sYCrgONWCmhxlgYApVToaQDwUtXax6TTTJsB5HZeUQZJcdEL6gY61j1IUWaiLpShlAoL/eTxctCrBPR0YqOj2Lwya0F1gRp7BnUAWCkVNhoAvBxu7qMwPYG8tIRZj91alsWRjgG6B0bn/DzGGI53D1Gq/f9KqTDRAODlUHPvtOmf3i4uywbgjYa51wXq0RRQpVSYaQDw0Ds0xvGeIc6bZgKYtw3L00mOi2ZvQ/ecn+u4poAqpcJMA4CHQ9YEsE1+XgHERkdxYWkW++ZxBeBOAdUyEEqpcNEA4OGwNQC8YZYBYE8Xl2VT3zlAZ//InJ6rsdtdBTRxTucppVSgaADwcKi5l1W5yaQl+L9+7lZrHGCuVwGNPZoCqpQKL/30sRhjONjU5/cAsNs5y9JIjY+Z83wATQFVSoWbBgBLW98I3QOjbJxlBrC3GPc4wBwKw2kKqFLKDjQAWNxLQJ43h/5/t4vLsmnoHqTD4d84gDsFVAeAlVLhpAHAcrCpj5goYV1h2pzPPT0O4N9VQGO3tRC8dgEppcJIA4DlcHMv6wrTSIiNnvO565elkZbg/zhAY4+mgCqlwk8DAOB0Gt61SkDPR3SUsKU02+8FYjQFVCllBxoAgIbuQfpHJ+Y8AOxpa1kWjT1DtPUNz3qspoAqpexAP4FwrQAG0y8B6Y+LV/k/DtDYM6j9/0qpsNMAgKv/PykumtV5KfN+jHUFaaQnxs7aDeRaCH6IlZoCqpQKMw0AwMHmPjYsTyc6avolIGcTFSVc5EddoJ7BMQY0BVQpZQN+BQAR2SEitSJSLyJ3+difKSJPichhEXlTRDZ47GsUkXdF5KCIHPDY/k8i0mJtPygi1wXmJc3N2IST6lbHrEtA+uPiVdmcODlES+/04wBTKaAaAJRSYTZrABCRaOBB4FpgPXCjiKz3Ouxu4KAx5jzgJuABr/1XGmM2GWM2e22/39q+yRize34vYWFq2h2MTTrnnQHkyT0fYKZuoGM6B0ApZRP+XAFsAeqNMQ3GmDHgSeB6r2PWA3sAjDE1wEoRyQ9oS4PEXQJ6IQPAbuX5qWQmxc44EHy8Z0hTQJVStuBPAFgONHncb7a2eToEfAxARLYAK4Aia58BnheRt0Tkdq/z7rC6jR4RkUxfTy4it4vIARE50NXV5Udz5+ZQUy9ZyXEB+UB2jQPMPB/gmKaAKqVswp9PIV8jo8br/j1ApogcBO4E3gEmrH3bjDHn4+pC+qKIXG5t/yGwCtgEtAH3+XpyY8wuY8xmY8zm3NxcP5o7N4ebe9lYlI7I/AeAPV28KpuW3mGaTg753H9cU0CVUjbhTwBoBoo97hcBrZ4HGGMcxphbjDGbcI0B5ALHrH2t1u9O4ClcXUoYYzqMMZPGGCfwsHt7KA2MTlDXOcB5Aej+cZsaB/DRDeROAdVlIJVSduBPANgPrBGRUhGJA24AnvE8QEQyrH0AtwGvGmMcIpIsIqnWMcnANUCldb/Q4yE+6t4eSpUtfRhDQDKA3Nbmp5CdHOezPHT3gCsFdIXOAVBK2UDMbAcYYyZE5A7gOSAaeMQYUyUiO639DwHrgMdEZBJ4D7jVOj0feMrqXokBfmaMedbad6+IbMLVndQIfD5QL8pfCykBPR0RYWtZNvsaejDGnNG15F4IXlNAlVJ2MGsAALBSNHd7bXvI4/ZeYI2P8xqAjdM85mfm1NIgONTUR1FmItkp8QF93K1lWfz+3TZOnBw6Y9UvTQFVStlJRKeiHGruDUj6p7fp6gJpCqhSyk4iNgD0DIzSfGqYjcWB6/5xW5WbQk5K/FnpoMd6BinWFFCllE1E7CfRYWsCWCAzgNxc4wBZ7LXGAdwau3UheKWUfURsADjY1EuUwLnLA38FAK5uoA7H6NTqX8YYjvdoCqhSyj4iNgAcbu5ldV4KyfF+jYPPmXddIHcKqJaBVkrZRUQGAGMMh5r7gjIA7FaWk0xeavzUQLA7BXSFXgEopWwiIgNA86lhTg6OcV4AJ4B5c88HcI8DuFNAS3UMQCllExEZAA5ZE8A2BfEKAFzjAF39oxztGqSxx7UQ/HJNAVVK2UREBoDDzX3ERUdRXpAa1OdxjwPsa+ihsWdIU0CVUrYSkZ9GB5t6Wb8sjbiY4L78ldlJFKQlsLehh8buQS0BoZSylYgLAJNOQ2VLHxsDWP9nOiLCxauyeaOhh+M9Q1oCQillKxEXAOo7Bxgam2RjEAeAPW0ty9IUUKWULUVcADg0VQE0IyTPd3FZztRtTQFVStlJ5AWApl5S42MoC9GHcXFWIsvSEwBNAVVK2UvEBYDDzX2cW5ROVFRgloCcjWscIIfYaE0BVUrZS0QFgJHxSarbHCHr/3f72jVr2XXTZk0BVUrZSnAK4dhUdZuDCacJSQaQp+UZiSzP0G//Sil7iaivpIeaegFCfgWglFJ2FFEB4HBzH7mp8RSkJYS7KUopFXYRFQAOWktAei7UrpRSkSpiAoBjZJyGrsGQ9/8rpZRd+RUARGSHiNSKSL2I3OVjf6aIPCUih0XkTRHZ4LGvUUTeFZGDInLAY3uWiLwgInXW78zAvCTf3rWWgNT+f6WUcpk1AIhINPAgcC2wHrhRRNZ7HXY3cNAYcx5wE/CA1/4rjTGbjDGbPbbdBewxxqwB9lj3g+b0DGC9AlBKKfDvCmALUG+MaTDGjAFPAtd7HbMe14c4xpgaYKWI5M/yuNcDj1q3HwU+4m+j5+NQUy8rs5PISIoL5tMopdSi4U8AWA40edxvtrZ5OgR8DEBEtgArgCJrnwGeF5G3ROR2j3PyjTFtANbvPF9PLiK3i8gBETnQ1dXlR3N9O9zcF7L6P0optRj4EwB8pcwYr/v3AJkichC4E3gHmLD2bTPGnI+rC+mLInL5XBpojNlljNlsjNmcm5s7l1OndDpGaOsb0e4fpZTy4M9M4Gag2ON+EdDqeYAxxgHcAiCuHMtj1g/GmFbrd6eIPIWrS+lVoENECo0xbSJSCHQu8LVM65A1ALxJB4CVUmqKP1cA+4E1IlIqInHADcAzngeISIa1D+A24FVjjENEkkUk1TomGbgGqLSOewa42bp9M/D0wl7K9A439xIdJZyzTK8AlFLKbdYrAGPMhIjcATwHRAOPGGOqRGSntf8hYB3wmIhMAu8Bt1qn5wNPWROvYoCfGWOetfbdA/xSRG4FTgCfDNzLOlNRZiIfP385iXHRwXoKpZRadMQY7+58+9q8ebM5cODA7AcqpZSaIiJveaXhAxE0E1gppdSZNAAopVSE0gCglFIRSgOAUkpFKA0ASikVoTQAKKVUhNIAoJRSEUoDgFJKRahFNRFMRLqA4/M8PQfoDmBzAk3btzDavoXR9i2cndu4whhzVjXNRRUAFkJEDviaCWcX2r6F0fYtjLZv4RZDG71pF5BSSkUoDQBKKRWhIikA7Ap3A2ah7VsYbd/CaPsWbjG08QwRMwaglFLqTJF0BaCUUsqDBgCllIpQSy4AiMgOEakVkXoRucvHfhGRH1j7D4vI+SFsW7GIvCQi1SJSJSJf9nHMdhHpE5GD1s8/hqp91vM3isi71nOftfpOmN+/co/35aCIOETkK17HhPT9E5FHRKRTRCo9tmWJyAsiUmf9zpzm3Bn/VoPYvu+KSI317/eUiGRMc+6MfwtBbN8/iUiLx7/hddOcG6737xcebWsUkYPTnBv092/BjDFL5gfXkpVHgTIgDjgErPc65jrgD4AAW4E3Qti+QuB863YqcMRH+7YDvwvje9gI5MywP2zvn49/63ZcE1zC9v4BlwPnA5Ue2+4F7rJu3wV8Z5r2z/i3GsT2XQPEWLe/46t9/vwtBLF9/wR83Y9//7C8f1777wP+MVzv30J/ltoVwBag3hjTYIwZA54Ervc65nrgMeOyD8gQkcJQNM4Y02aMedu63Q9UA8tD8dwBFLb3z8tVwFFjzHxnhgeEMeZV4KTX5uuBR63bjwIf8XGqP3+rQWmfMeZ5Y8yEdXcfUBTo5/XXNO+fP8L2/rmJa7HzvwB+HujnDZWlFgCWA00e95s5+wPWn2OCTkRWAu8D3vCx+2IROSQifxCRc0LbMgzwvIi8JSK3+9hvi/cPuIHp/+OF8/0DyDfGtIEr6AN5Po6xy/v4WVxXdL7M9rcQTHdYXVSPTNOFZof37zKgwxhTN83+cL5/fllqAUB8bPPOc/XnmKASkRTgf4CvGGMcXrvfxtWtsRH4/4DfhrJtwDZjzPnAtcAXReRyr/12eP/igD8HfuVjd7jfP3/Z4X38e2ACeGKaQ2b7WwiWHwKrgE1AG65uFm9hf/+AG5n523+43j+/LbUA0AwUe9wvAlrncUzQiEgsrg//J4wxv/Heb4xxGGMGrNu7gVgRyQlV+4wxrdbvTuApXJfansL6/lmuBd42xnR47wj3+2fpcHeLWb87fRwT7r/Dm4E/Az5lrA5rb378LQSFMabDGDNpjHECD0/zvOF+/2KAjwG/mO6YcL1/c7HUAsB+YI2IlFrfEm8AnvE65hngJiubZSvQ575cDzarz/C/gGpjzPenOabAOg4R2YLr36gnRO1LFpFU921cg4WVXoeF7f3zMO03r3C+fx6eAW62bt8MPO3jGH/+VoNCRHYA3wT+3BgzNM0x/vwtBKt9nmNKH53mecP2/lk+ANQYY5p97Qzn+zcn4R6FDvQPriyVI7gyBP7e2rYT2GndFuBBa/+7wOYQtu1SXJeph4GD1s91Xu27A6jCldWwD7gkhO0rs573kNUGW71/1vMn4fpAT/fYFrb3D1cgagPGcX0rvRXIBvYAddbvLOvYZcDumf5WQ9S+elz95+6/wYe82zfd30KI2vdT62/rMK4P9UI7vX/W9v92/815HBvy92+hP1oKQimlItRS6wJSSinlJw0ASikVoTQAKKVUhNIAoJRSEUoDgFJKRSgNAEopFaE0ACilVIT6/wFyh9MTAD7EpgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(np.arange(len(eval_losses)), eval_losses)\n", + "plt.title('test loss')\n", + "plt.show()\n", + "\n", + "plt.plot(np.arange(len(eval_acces)), eval_acces)\n", + "plt.title('test acc')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 练习\n", + "\n", + "* 看一看上面的训练过程，看一下准确率是怎么计算出来的，特别注意 max 这个函数\n", + "* 自己重新实现一个新的网络，试试改变隐藏层的数目和激活函数，看看有什么新的结果" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 参考\n", + "* [损失函数：交叉熵详解](https://zhuanlan.zhihu.com/p/115277553)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/6_pytorch/6-param_initialize.ipynb b/6_pytorch/7-param_initialize.ipynb similarity index 90% rename from 6_pytorch/6-param_initialize.ipynb rename to 6_pytorch/7-param_initialize.ipynb index 5415b7c..cd69fe3 100644 --- a/6_pytorch/6-param_initialize.ipynb +++ b/6_pytorch/7-param_initialize.ipynb @@ -12,14 +12,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "PyTorch 的初始化方式并没有那么显然，如果你使用最原始的方式创建模型，那么你需要定义模型中的所有参数，当然这样你可以非常方便地定义每个变量的初始化方式，但是对于复杂的模型，这并不容易，而且我们推崇使用 Sequential 和 Module 来定义模型，所以这个时候我们就需要知道如何来自定义初始化方式" + "PyTorch 的初始化方式并没有那么显然，如果你使用最原始的方式创建模型，那么需要定义模型中的所有参数，当然这样可以非常方便地定义每个变量的初始化方式。但是对于复杂的模型，这并不容易，而且推荐使用 Sequential 和 Module 来定义模型，所以这个时候就需要知道如何来自定义初始化方式。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## 使用 NumPy 来初始化\n", + "## 1. 使用 NumPy 来初始化\n", "因为 PyTorch 是一个非常灵活的框架，理论上能够对所有的 Tensor 进行操作，所以我们能够通过定义新的 Tensor 来初始化，直接看下面的例子" ] }, @@ -162,9 +162,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "**小练习：一种非常流行的初始化方式叫 Xavier，方法来源于 2010 年的一篇论文 [Understanding the difficulty of training deep feedforward neural networks](http://proceedings.mlr.press/v9/glorot10a.html)，其通过数学的推到，证明了这种初始化方式可以使得每一层的输出方差是尽可能相等的，有兴趣的同学可以去看看论文**\n", - "\n", - "我们给出这种初始化的公式\n", + "一种非常流行的初始化方式叫 Xavier，方法来源于 2010 年的一篇论文 [Understanding the difficulty of training deep feedforward neural networks](http://proceedings.mlr.press/v9/glorot10a.html)，其通过数学的推到，证明了这种初始化方式可以使得每一层的输出方差是尽可能相等。这种初始化的公式为：\n", "\n", "$$\n", "w\\ \\sim \\ Uniform[- \\frac{\\sqrt{6}}{\\sqrt{n_j + n_{j+1}}}, \\frac{\\sqrt{6}}{\\sqrt{n_j + n_{j+1}}}]\n", @@ -340,8 +338,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## torch.nn.init\n", - "因为 PyTorch 灵活的特性，我们可以直接对 Tensor 进行操作从而初始化，PyTorch 也提供了初始化的函数帮助我们快速初始化，就是 `torch.nn.init`，其操作层面仍然在 Tensor 上，下面我们举例说明" + "## 2. `torch.nn.init`\n", + "因为 PyTorch 灵活的特性，可以直接对 Tensor 进行操作从而初始化，PyTorch 也提供了初始化的函数帮助我们快速初始化，就是 `torch.nn.init`，其操作层面仍然在 Tensor 上，下面我们举例说明" ] }, { @@ -439,22 +437,20 @@ "source": [ "可以看到参数已经被修改了\n", "\n", - "`torch.nn.init` 为我们提供了更多的内置初始化方式，避免了我们重复去实现一些相同的操作" + "`torch.nn.init` 提供了更多的内置初始化方式，避免了重复去实现一些相同的操作。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "上面讲了两种初始化方式，其实它们的本质都是一样的，就是去修改某一层参数的实际值，而 `torch.nn.init` 提供了更多成熟的深度学习相关的初始化方式，非常方便\n", - "\n", - "下一节课，我们将讲一下目前流行的各种基于梯度的优化算法" + "上面讲了两种初始化方式，其实它们的本质都是一样的，就是去修改某一层参数的实际值，而 `torch.nn.init` 提供了更多成熟的深度学习相关的初始化方式。\n" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -468,7 +464,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.4" + "version": "3.9.7" } }, "nbformat": 4, diff --git a/6_pytorch/imgs/MNIST.jpeg b/6_pytorch/imgs/MNIST.jpeg new file mode 100644 index 0000000..7b145d4 Binary files /dev/null and b/6_pytorch/imgs/MNIST.jpeg differ diff --git a/6_pytorch/imgs/logistic_function.png b/6_pytorch/imgs/logistic_function.png new file mode 100644 index 0000000..8119e0a Binary files /dev/null and b/6_pytorch/imgs/logistic_function.png differ diff --git a/6_pytorch/imgs/softmax.jpeg b/6_pytorch/imgs/softmax.jpeg new file mode 100644 index 0000000..f5c5227 Binary files /dev/null and b/6_pytorch/imgs/softmax.jpeg differ diff --git a/6_pytorch/optimizer/6_1-sgd.ipynb b/6_pytorch/optimizer/6_1-sgd.ipynb index 1470731..d925cbe 100644 --- a/6_pytorch/optimizer/6_1-sgd.ipynb +++ b/6_pytorch/optimizer/6_1-sgd.ipynb @@ -10,107 +10,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n", - "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ../../../data/MNIST/raw/train-images-idx3-ubyte.gz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "46.4%IOPub message rate exceeded.\n", - "The notebook server will temporarily stop sending output\n", - "to the client in order to avoid crashing it.\n", - "To change this limit, set the config variable\n", - "`--NotebookApp.iopub_msg_rate_limit`.\n", - "\n", - "Current values:\n", - "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", - "NotebookApp.rate_limit_window=3.0 (secs)\n", - "\n", - "98.4%IOPub message rate exceeded.\n", - "The notebook server will temporarily stop sending output\n", - "to the client in order to avoid crashing it.\n", - "To change this limit, set the config variable\n", - "`--NotebookApp.iopub_msg_rate_limit`.\n", - "\n", - "Current values:\n", - "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n", - "NotebookApp.rate_limit_window=3.0 (secs)\n", - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ../../../data/MNIST/raw/train-labels-idx1-ubyte.gz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "102.8%\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extracting ../../../data/MNIST/raw/train-labels-idx1-ubyte.gz to ../../../data/MNIST/raw\n", - "\n", - "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n", - "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ../../../data/MNIST/raw/t10k-images-idx3-ubyte.gz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100.0%\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extracting ../../../data/MNIST/raw/t10k-images-idx3-ubyte.gz to ../../../data/MNIST/raw\n", - "\n", - "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n", - "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ../../../data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "112.7%" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extracting ../../../data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ../../../data/MNIST/raw\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], + "outputs": [], "source": [ "import numpy as np\n", "import torch\n", @@ -129,8 +31,8 @@ " x = torch.from_numpy(x)\n", " return x\n", "\n", - "train_set = MNIST('../../../data/mnist', train=True, transform=data_tf, download=True) # 载入数据集，申明定义的数据变换\n", - "test_set = MNIST('../../../data/mnist', train=False, transform=data_tf, download=True)\n", + "train_set = MNIST('../../data/mnist', train=True, transform=data_tf, download=True) # 载入数据集，申明定义的数据变换\n", + "test_set = MNIST('../../data/mnist', train=False, transform=data_tf, download=True)\n", "\n", "# 定义 loss 函数\n", "criterion = nn.CrossEntropyLoss()" diff --git a/6_pytorch/optimizer/6_2-momentum.ipynb b/6_pytorch/optimizer/6_2-momentum.ipynb index fed3fe6..01f198c 100644 --- a/6_pytorch/optimizer/6_2-momentum.ipynb +++ b/6_pytorch/optimizer/6_2-momentum.ipynb @@ -104,8 +104,8 @@ " x = torch.from_numpy(x)\n", " return x\n", "\n", - "train_set = MNIST('../../../data/mnist', train=True, transform=data_tf, download=True) # 载入数据集，申明定义的数据变换\n", - "test_set = MNIST('../../../data/mnist', train=False, transform=data_tf, download=True)\n", + "train_set = MNIST('../../data/mnist', train=True, transform=data_tf, download=True) # 载入数据集，申明定义的数据变换\n", + "test_set = MNIST('../../data/mnist', train=False, transform=data_tf, download=True)\n", "\n", "# 定义 loss 函数\n", "criterion = nn.CrossEntropyLoss()" diff --git a/6_pytorch/optimizer/6_3-adagrad.ipynb b/6_pytorch/optimizer/6_3-adagrad.ipynb index d3b6c14..c203790 100644 --- a/6_pytorch/optimizer/6_3-adagrad.ipynb +++ b/6_pytorch/optimizer/6_3-adagrad.ipynb @@ -68,8 +68,8 @@ " x = torch.from_numpy(x)\n", " return x\n", "\n", - "train_set = MNIST('../../../data/mnist', train=True, transform=data_tf, download=True) # 载入数据集，申明定义的数据变换\n", - "test_set = MNIST('../../../data/mnist', train=False, transform=data_tf, download=True)\n", + "train_set = MNIST('../../data/mnist', train=True, transform=data_tf, download=True) # 载入数据集，申明定义的数据变换\n", + "test_set = MNIST('../../data/mnist', train=False, transform=data_tf, download=True)\n", "\n", "# 定义 loss 函数\n", "criterion = nn.CrossEntropyLoss()" diff --git a/6_pytorch/optimizer/6_4-rmsprop.ipynb b/6_pytorch/optimizer/6_4-rmsprop.ipynb index eebbd16..a6a5245 100644 --- a/6_pytorch/optimizer/6_4-rmsprop.ipynb +++ b/6_pytorch/optimizer/6_4-rmsprop.ipynb @@ -66,8 +66,8 @@ " x = torch.from_numpy(x)\n", " return x\n", "\n", - "train_set = MNIST('../../../data/mnist', train=True, transform=data_tf, download=True) # 载入数据集，申明定义的数据变换\n", - "test_set = MNIST('../../../data/mnist', train=False, transform=data_tf, download=True)\n", + "train_set = MNIST('../../data/mnist', train=True, transform=data_tf, download=True) # 载入数据集，申明定义的数据变换\n", + "test_set = MNIST('../../data/mnist', train=False, transform=data_tf, download=True)\n", "\n", "# 定义 loss 函数\n", "criterion = nn.CrossEntropyLoss()" diff --git a/6_pytorch/optimizer/6_5-adadelta.ipynb b/6_pytorch/optimizer/6_5-adadelta.ipynb index 6235410..74a04c7 100644 --- a/6_pytorch/optimizer/6_5-adadelta.ipynb +++ b/6_pytorch/optimizer/6_5-adadelta.ipynb @@ -77,8 +77,8 @@ " x = torch.from_numpy(x)\n", " return x\n", "\n", - "train_set = MNIST('../../../data/mnist', train=True, transform=data_tf, download=True) # 载入数据集，申明定义的数据变换\n", - "test_set = MNIST('../../../data/mnist', train=False, transform=data_tf, download=True)\n", + "train_set = MNIST('../../data/mnist', train=True, transform=data_tf, download=True) # 载入数据集，申明定义的数据变换\n", + "test_set = MNIST('../../data/mnist', train=False, transform=data_tf, download=True)\n", "\n", "# 定义 loss 函数\n", "criterion = nn.CrossEntropyLoss()" diff --git a/6_pytorch/optimizer/6_6-adam.ipynb b/6_pytorch/optimizer/6_6-adam.ipynb index 13f2102..48ff972 100644 --- a/6_pytorch/optimizer/6_6-adam.ipynb +++ b/6_pytorch/optimizer/6_6-adam.ipynb @@ -83,8 +83,8 @@ " x = torch.from_numpy(x)\n", " return x\n", "\n", - "train_set = MNIST('../../../data/mnist', train=True, transform=data_tf, download=True) # 载入数据集，申明定义的数据变换\n", - "test_set = MNIST('../../../data/mnist', train=False, transform=data_tf, download=True)\n", + "train_set = MNIST('../../data/mnist', train=True, transform=data_tf, download=True) # 载入数据集，申明定义的数据变换\n", + "test_set = MNIST('../../data/mnist', train=False, transform=data_tf, download=True)\n", "\n", "# 定义 loss 函数\n", "criterion = nn.CrossEntropyLoss()" diff --git a/7_deep_learning/imgs/ResNet.png b/7_deep_learning/imgs/ResNet.png new file mode 100644 index 0000000..ef45c0b Binary files /dev/null and b/7_deep_learning/imgs/ResNet.png differ diff --git a/7_deep_learning/imgs/lena.png b/7_deep_learning/imgs/lena.png new file mode 100644 index 0000000..4a243df Binary files /dev/null and b/7_deep_learning/imgs/lena.png differ diff --git a/7_deep_learning/imgs/lena3.png b/7_deep_learning/imgs/lena3.png new file mode 100644 index 0000000..7091ad5 Binary files /dev/null and b/7_deep_learning/imgs/lena3.png differ diff --git a/7_deep_learning/imgs/lena512.png b/7_deep_learning/imgs/lena512.png new file mode 100644 index 0000000..1b95d4c Binary files /dev/null and b/7_deep_learning/imgs/lena512.png differ diff --git a/7_deep_learning/imgs/nn_lenet.png b/7_deep_learning/imgs/nn_lenet.png new file mode 100644 index 0000000..a85fc42 Binary files /dev/null and b/7_deep_learning/imgs/nn_lenet.png differ diff --git a/7_deep_learning/imgs/residual.png b/7_deep_learning/imgs/residual.png new file mode 100644 index 0000000..3202ab5 Binary files /dev/null and b/7_deep_learning/imgs/residual.png differ diff --git a/7_deep_learning/imgs/resnet1.png b/7_deep_learning/imgs/resnet1.png new file mode 100644 index 0000000..eeb062c Binary files /dev/null and b/7_deep_learning/imgs/resnet1.png differ diff --git a/7_deep_learning/imgs/tensor_data_structure.svg b/7_deep_learning/imgs/tensor_data_structure.svg new file mode 100644 index 0000000..33ad624 --- /dev/null +++ b/7_deep_learning/imgs/tensor_data_structure.svg @@ -0,0 +1,2 @@ + +
Tensor A
Tensor A
+ Long: *size
+ Long: *size
+ Long: *stride
+ Long: *stride
+ int:  nDimention
+ int:  nDimention
+ ptr: storageOffset
+ ptr: storageOffset
+ char: flag
+ char: flag
+ Storage: *storage
+ Storage: *storage
Storage
Storage
+ Long: *size
+ Long: *size
+ char: flag
+ char: flag


+      real: *data
[Not supported by viewer]
Tensor B
Tensor B
+ Long: *size
+ Long: *size
+ Long: *stride
+ Long: *stride
+ int:  nDimention
+ int:  nDimention
+ ptr: storageOffset
+ ptr: storageOffset
+ char: flag
+ char: flag
+ Storage: *storage
+ Storage: *storage \ No newline at end of file diff --git a/7_deep_learning/imgs/trans.bkp.PNG b/7_deep_learning/imgs/trans.bkp.PNG new file mode 100644 index 0000000..2c5fc0c Binary files /dev/null and b/7_deep_learning/imgs/trans.bkp.PNG differ diff --git a/README.md b/README.md index 2f76272..096f4ba 100644 --- a/README.md +++ b/README.md @@ -39,17 +39,15 @@ - [Multi-layer Perceptron & BP](5_nn/2-mlp_bp.ipynb) - [Softmax & cross-entroy](5_nn/3-softmax_ce.ipynb) 8. [PyTorch](6_pytorch/README.md) - - Basic - - [Tensor and Variable](6_pytorch/0_basic/1-Tensor-and-Variable.ipynb) - - [autograd](6_pytorch/0_basic/2-autograd.ipynb) - - NN & Optimization - - [nn/linear-regression-gradient-descend](6_pytorch/1_NN/1-linear-regression-gradient-descend.ipynb) - - [nn/logistic-regression](6_pytorch/1_NN/2-logistic-regression.ipynb) - - [nn/nn-sequential-module](6_pytorch/1_NN/3-nn-sequential-module.ipynb) - - [nn/deep-nn](6_pytorch/1_NN/4-deep-nn.ipynb) - - [nn/param_initialize](6_pytorch/1_NN/5-param_initialize.ipynb) - - [optim/sgd](6_pytorch/1_NN/optimizer/6_1-sgd.ipynb) - - [optim/adam](6_pytorch/1_NN/optimizer/6_6-adam.ipynb) + - [Tensor](6_pytorch/1-tensor.ipynb) + - [autograd](6_pytorch/2-autograd.ipynb) + - [linear-regression](6_pytorch/3-linear-regression.ipynb) + - [logistic-regression](6_pytorch/4-logistic-regression.ipynb) + - [nn-sequential-module](6_pytorch/5-nn-sequential-module.ipynb) + - [deep-nn](6_pytorch/6-deep-nn.ipynb) + - [param_initialize](6_pytorch/7-param_initialize.ipynb) + - [optim/sgd](6_pytorch/optimizer/6_1-sgd.ipynb) + - [optim/adam](6_pytorch/optimizer/6_6-adam.ipynb) 9. [Deep Learning](7_deep_learning/README.md) - CNN - [CNN Introduction](7_deep_learning/1_CNN/CNN_Introduction.pptx) diff --git a/README_ENG.md b/README_ENG.md index 5694f8e..096f4ba 100644 --- a/README_ENG.md +++ b/README_ENG.md @@ -1,16 +1,21 @@ -# 机器学习 +# 机器学习与人工智能 -本教程主要讲解机器学习的基本原理与实现，通过本教程的引导来快速学习Python、Python常用库、机器学习的理论知识与实际编程，并学习如何解决实际问题。 +机器学习越来越多应用到飞行器、机器人等领域，其目的是利用计算机实现类似人类的智能，从而实现装备的智能化与无人化。本课程旨在引导学生掌握机器学习的基本知识、典型方法与技术，通过具体的应用案例激发学生对该学科的兴趣，鼓励学生能够从人工智能的角度来分析、解决飞行器、机器人所面临的问题和挑战。本课程主要内容包括Python编程基础，机器学习模型，无监督学习、监督学习、深度学习基础知识与实现，并学习如何利用机器学习解决实际问题，从而全面提升自我的[《综合能力》](Targets.md)。 -由于**本课程需要大量的编程练习才能取得比较好的学习效果**，因此需要认真去完成[作业和报告](https://gitee.com/pi-lab/machinelearning_homework)，写作业的过程可以查阅网上的资料，但是不能直接照抄，需要自己独立思考并独立写出代码。 +由于**本课程需要大量的编程练习才能取得比较好的学习效果**，因此需要认真去完成[《机器学习与人工智能-作业和报告》](https://gitee.com/pi-lab/machinelearning_homework)，写作业的过程可以查阅网上的资料，但是不能直接照抄，需要自己独立思考并独立写出代码。本教程的Python等运行环境的安装说明请参考[《Python环境安装》](references_tips/InstallPython.md)。 -![Machine Learning Cover](images/machine_learning.png) +为了让大家更好的自学本课程，课程讲座的视频在[《B站 - 机器学习与人工智能》](https://www.bilibili.com/video/BV1oZ4y1N7ei/)，欢迎大家观看学习。 + + + +![Machine Learning Cover](images/machine_learning_1.jpg) ## 1. 内容 1. [课程简介](CourseIntroduction.pdf) -2. [Python](0_python/) - - [Install Python](tips/InstallPython.md) +2. [Python](0_python/README.md) + - [Install Python](references_tips/InstallPython.md) + - [ipython & notebook](0_python/0-ipython_notebook.ipynb) - [Python Basics](0_python/1_Basics.ipynb) - [Print Statement](0_python/2_Print_Statement.ipynb) - [Data Structure 1](0_python/3_Data_Structure_1.ipynb) @@ -18,93 +23,91 @@ - [Control Flow](0_python/5_Control_Flow.ipynb) - [Function](0_python/6_Function.ipynb) - [Class](0_python/7_Class.ipynb) -3. [numpy & matplotlib](1_numpy_matplotlib_scipy_sympy/) - - [numpy](1_numpy_matplotlib_scipy_sympy/numpy_tutorial.ipynb) - - [matplotlib](1_numpy_matplotlib_scipy_sympy/matplotlib_simple_tutorial.ipynb) - - [ipython & notebook](1_numpy_matplotlib_scipy_sympy/ipython_notebook.ipynb) -4. [knn](2_knn/knn_classification.ipynb) -5. [kMenas](3_kmeans/k-means.ipynb) +3. [numpy & matplotlib](1_numpy_matplotlib_scipy_sympy/README.md) + - [numpy](1_numpy_matplotlib_scipy_sympy/1-numpy_tutorial.ipynb) + - [matplotlib](1_numpy_matplotlib_scipy_sympy/2-matplotlib_tutorial.ipynb) +4. [kNN](2_knn/knn_classification.ipynb) +5. [kMeans](3_kmeans/1-k-means.ipynb) + - [kMeans - Image Compression](3_kmeans/2-kmeans-color-vq.ipynb) + - [Cluster Algorithms](3_kmeans/3-ClusteringAlgorithms.ipynb) 6. [Logistic Regression](4_logistic_regression/) - - [Least squares](4_logistic_regression/Least_squares.ipynb) - - [Logistic regression](4_logistic_regression/Logistic_regression.ipynb) + - [Least squares](4_logistic_regression/1-Least_squares.ipynb) + - [Logistic regression](4_logistic_regression/2-Logistic_regression.ipynb) + - [PCA and Logistic regression](4_logistic_regression/3-PCA_and_Logistic_Regression.ipynb) 7. [Neural Network](5_nn/) - - [Perceptron](5_nn/Perceptron.ipynb) - - [Multi-layer Perceptron & BP](5_nn/mlp_bp.ipynb) - - [Softmax & cross-entroy](5_nn/softmax_ce.ipynb) -8. [PyTorch](6_pytorch/) - - Basic - - [short tutorial](6_pytorch/PyTorch_quick_intro.ipynb) - - [basic/Tensor-and-Variable](6_pytorch/0_basic/Tensor-and-Variable.ipynb) - - [basic/autograd](6_pytorch/0_basic/autograd.ipynb) - - [basic/dynamic-graph](6_pytorch/0_basic/dynamic-graph.ipynb) - - NN & Optimization - - [nn/linear-regression-gradient-descend](6_pytorch/1_NN/linear-regression-gradient-descend.ipynb) - - [nn/logistic-regression](6_pytorch/1_NN/logistic-regression.ipynb) - - [nn/nn-sequential-module](6_pytorch/1_NN/nn-sequential-module.ipynb) - - [nn/bp](6_pytorch/1_NN/bp.ipynb) - - [nn/deep-nn](6_pytorch/1_NN/deep-nn.ipynb) - - [nn/param_initialize](6_pytorch/1_NN/param_initialize.ipynb) - - [optim/sgd](6_pytorch/1_NN/optimizer/sgd.ipynb) - - [optim/adam](6_pytorch/1_NN/optimizer/adam.ipynb) + - [Perceptron](5_nn/1-Perceptron.ipynb) + - [Multi-layer Perceptron & BP](5_nn/2-mlp_bp.ipynb) + - [Softmax & cross-entroy](5_nn/3-softmax_ce.ipynb) +8. [PyTorch](6_pytorch/README.md) + - [Tensor](6_pytorch/1-tensor.ipynb) + - [autograd](6_pytorch/2-autograd.ipynb) + - [linear-regression](6_pytorch/3-linear-regression.ipynb) + - [logistic-regression](6_pytorch/4-logistic-regression.ipynb) + - [nn-sequential-module](6_pytorch/5-nn-sequential-module.ipynb) + - [deep-nn](6_pytorch/6-deep-nn.ipynb) + - [param_initialize](6_pytorch/7-param_initialize.ipynb) + - [optim/sgd](6_pytorch/optimizer/6_1-sgd.ipynb) + - [optim/adam](6_pytorch/optimizer/6_6-adam.ipynb) +9. [Deep Learning](7_deep_learning/README.md) - CNN + - [CNN Introduction](7_deep_learning/1_CNN/CNN_Introduction.pptx) - [CNN simple demo](demo_code/3_CNN_MNIST.py) - - [cnn/basic_conv](6_pytorch/2_CNN/basic_conv.ipynb) - - [cnn/minist (demo code)](./demo_code/3_CNN_MNIST.py) - - [cnn/batch-normalization](6_pytorch/2_CNN/batch-normalization.ipynb) - - [cnn/regularization](6_pytorch/2_CNN/regularization.ipynb) - - [cnn/lr-decay](6_pytorch/2_CNN/lr-decay.ipynb) - - [cnn/vgg](6_pytorch/2_CNN/vgg.ipynb) - - [cnn/googlenet](6_pytorch/2_CNN/googlenet.ipynb) - - [cnn/resnet](6_pytorch/2_CNN/resnet.ipynb) - - [cnn/densenet](6_pytorch/2_CNN/densenet.ipynb) + - [cnn/basic_conv](7_deep_learning/1_CNN/1-basic_conv.ipynb) + - [cnn/batch-normalization](7_deep_learning/1_CNN/2-batch-normalization.ipynb) + - [cnn/lr-decay](7_deep_learning/2_CNN/1-lr-decay.ipynb) + - [cnn/regularization](7_deep_learning/1_CNN/4-regularization.ipynb) + - [cnn/vgg](7_deep_learning/1_CNN/6-vgg.ipynb) + - [cnn/googlenet](7_deep_learning/1_CNN/7-googlenet.ipynb) + - [cnn/resnet](7_deep_learning/1_CNN/8-resnet.ipynb) + - [cnn/densenet](7_deep_learning/1_CNN/9-densenet.ipynb) - RNN - - [rnn/pytorch-rnn](6_pytorch/3_RNN/pytorch-rnn.ipynb) - - [rnn/rnn-for-image](6_pytorch/3_RNN/rnn-for-image.ipynb) - - [rnn/lstm-time-series](6_pytorch/3_RNN/time-series/lstm-time-series.ipynb) + - [rnn/pytorch-rnn](7_deep_learning/2_RNN/pytorch-rnn.ipynb) + - [rnn/rnn-for-image](7_deep_learning/2_RNN/rnn-for-image.ipynb) + - [rnn/lstm-time-series](7_deep_learning/2_RNN/time-series/lstm-time-series.ipynb) - GAN - - [gan/autoencoder](6_pytorch/4_GAN/autoencoder.ipynb) - - [gan/vae](6_pytorch/4_GAN/vae.ipynb) - - [gan/gan](6_pytorch/4_GAN/gan.ipynb) + - [gan/autoencoder](7_deep_learning/3_GAN/autoencoder.ipynb) + - [gan/vae](7_deep_learning/3_GAN/vae.ipynb) + - [gan/gan](7_deep_learning/3_GAN/gan.ipynb) ## 2. 学习的建议 -1. 为了更好的学习本课程，需要大家把Python编程的基础能力培养好，这样后续的机器学习方法学习才比较扎实。 -2. 每个课程前部分是理论基础，然后是代码实现。个人如果想学的更扎实，可以自己把各个方法的代码亲自实现一下。做的过程尽可能自己想解决办法，因为重要的学习目标不是代码本身，而是学会分析问题、解决问题的能力。 +1. 为了更好的学习本课程，需要大家把Python编程能力培养好，通过一定数量的练习题、小项目培养Python编程思维，为后续的机器学习理论与实践打好坚实的基础。 +2. 每个课程前半部分是理论基础，后半部分是代码实现。如果想学的更扎实，可以自己把各个方法的代码亲自实现一下。做的过程如果遇到问题尽可能自己想解决办法，因为最重要的目标不是代码本身，而是学会分析问题、解决问题的能力。 +3. **不能直接抄已有的程序，或者抄别人的程序**，如果自己不会要自己去想，去找解决方法，或者去问。如果直接抄别人的代码，这样的练习一点意义都没有。**如果感觉太难，可以做的慢一些，但是坚持自己思考、自己编写练习代码**。。 +4. **请先遍历一遍所有的文件夹，了解有什么内容，资料**。各个目录里有很多说明文档，如果不会先找找有没有文档，如果找不到合适的文档就去网上找找。通过这个过程锻炼自己搜索文献、资料的能力。 +5. 本课程的练习题最好使用[《Linux》](https://gitee.com/pi-lab/learn_programming/blob/master/6_tools/linux)以及Linux下的工具来做。逼迫自己使用[《Linux》](https://gitee.com/pi-lab/learn_programming/blob/master/6_tools/linux)，只有多练、多用才能快速进步。如果实在太难，先在虚拟机（建议VirtualBox）里装一个Linux（例如Ubuntu，或者LinuxMint等），先熟悉一下。但是最终需要学会使用Linux。 -## 3. 其他参考资料 + +## 3. 参考资料 * 资料速查 * [相关学习参考资料汇总](References.md) - * [一些速查手册](tips/cheatsheet) + * [一些速查手册](references_tips/cheatsheet) * 机器学习方面技巧等 - * [Confusion Matrix](tips/confusion_matrix.ipynb) - * [Datasets](tips/datasets.ipynb) - * [构建深度神经网络的一些实战建议](tips/构建深度神经网络的一些实战建议.md) - * [Intro to Deep Learning](tips/Intro_to_Deep_Learning.pdf) + * [Confusion Matrix](references_tips/confusion_matrix.ipynb) + * [Datasets](references_tips/datasets.ipynb) + * [构建深度神经网络的一些实战建议](references_tips/构建深度神经网络的一些实战建议.md) + * [Intro to Deep Learning](references_tips/Intro_to_Deep_Learning.pdf) * Python技巧等 - * [安装Python环境](tips/InstallPython.md) - * [Python tips](tips/python) + * [安装Python环境](references_tips/InstallPython.md) + * [Python tips](references_tips/python) + +* [Git教程](https://gitee.com/pi-lab/learn_programming/blob/master/6_tools/git/README.md) +* [Markdown教程](https://gitee.com/pi-lab/learn_programming/blob/master/6_tools/markdown/README.md) -* Git - * [Git Tips - 常用方法速查，快速入门](https://gitee.com/pi-lab/learn_programming/blob/master/6_tools/git/git-tips.md) - * [Git快速入门 - Git初体验](https://my.oschina.net/dxqr/blog/134811) - * [在win7系统下使用TortoiseGit(乌龟git)简单操作Git](https://my.oschina.net/longxuu/blog/141699) - * [Git系统学习 - 廖雪峰的Git教程](https://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000) -* Markdown - * [Markdown——入门指南](https://www.jianshu.com/p/1e402922ee32) -## 4. 相关学习资料参考 +## 4. 更进一步学习 在上述内容学习完成之后，可以进行更进一步机器学习、计算机视觉方面的学习与研究，具体的资料可以参考： -1. [《一步一步学编程》](https://gitee.com/pi-lab/learn_programming) -2. 智能系统实验室-培训教程与作业 - - [《智能系统实验室-暑期培训教程》](https://gitee.com/pi-lab/SummerCamp) - - [《智能系统实验室-暑期培训作业》](https://gitee.com/pi-lab/SummerCampHomework) -3. [《智能系统实验室研究课题》](https://gitee.com/pi-lab/pilab_research_fields) -4. [《编程代码参考、技巧集合》](https://gitee.com/pi-lab/code_cook) - - 可以在这个代码、技巧集合中找到某项功能的示例，从而加快自己代码的编写 +1. 编程是机器学习研究、实现过程非常重要的能力，编程能力弱则无法快速试错，导致学习、研究进度缓慢；如果编程能力强，则可以快速试错，快速编写实验代码等。强烈建议大家在学习本课程之后或之中，好好把数据结构、算法等基本功锻炼一下。具体的教程可以参考[《一步一步学编程》](https://gitee.com/pi-lab/learn_programming) +2. 飞行器智能感知与控制实验室-培训教程与作业：这个教程是实验室积累的机器学习与计算机视觉方面的教程集合，每个课程介绍基本的原理、编程实现、应用方法等资料，可以作为快速入门的学习材料。 + - [《飞行器智能感知与控制实验室-暑期培训教程》](https://gitee.com/pi-lab/SummerCamp) + - [《飞行器智能感知与控制实验室-暑期培训作业》](https://gitee.com/pi-lab/SummerCampHomework) +3. 视觉SLAM是一类算法、技巧、编程高度集成的系统，通过学习、练习SLAM能够极大的提高自己的编程、解决问题能力。具体的教程可以参考[《一步一步学SLAM》](https://gitee.com/pi-lab/learn_slam) +3. [《编程代码参考、技巧集合》](https://gitee.com/pi-lab/code_cook)：可以在这个代码、技巧集合中找到某项功能的示例，从而加快自己代码的编写 +5. [《学习方法论与技巧》](https://gitee.com/pi-lab/pilab_research_fields)