From 7624cb4d3d85014a0450f5a6c3976caf88d61356 Mon Sep 17 00:00:00 2001 From: yinkanglong_lab Date: Tue, 23 Mar 2021 18:02:30 +0800 Subject: [PATCH] =?UTF-8?q?pytorch=E5=9F=BA=E7=A1=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pytorch/官方教程/01.md | 1 - pytorch/官方教程/01概述.md | 88 ++ pytorch/官方教程/02.md | 39 - pytorch/官方教程/02Pytorch.md | 28 + pytorch/官方教程/{03.md => 03Tensor.md} | 0 pytorch/官方教程/{04.md => 04Autograd.md} | 0 pytorch/官方教程/{05.md => 05NN.md} | 4 +- .../{06.md => 06ImageClassification.md} | 0 pytorch/官方教程/{07.md => 07example.md} | 66 +- pytorch/官方教程/08.md | 996 +++++++++++++++++- pytorch/官方教程/09.md | 370 ++++++- pytorch/官方教程/10.md | 77 -- pytorch/官方教程/11.md | 103 -- pytorch/官方教程/12.md | 87 -- pytorch/官方教程/13.md | 71 -- pytorch/官方教程/14.md | 75 -- pytorch/官方教程/15.md | 82 -- pytorch/官方教程/16.md | 971 ----------------- pytorch/官方教程/17.md | 348 ------ pytorch/官方教程/README.md | 35 - pytorch/官方教程/book.json | 176 ---- pytorch/实战/.gitignore | 1 + pytorch/实战/1.ipynb | 186 +++- pytorch/实战/6.ipynb | 392 +++++++ pytorch/实战/7.ipynb | 897 ++++++++++++++++ pytorch/实战/cifar_net.pth | Bin 0 -> 251391 bytes 26 files changed, 2881 insertions(+), 2212 deletions(-) delete mode 100644 pytorch/官方教程/01.md create mode 100644 pytorch/官方教程/01概述.md delete mode 100644 pytorch/官方教程/02.md create mode 100644 pytorch/官方教程/02Pytorch.md rename pytorch/官方教程/{03.md => 03Tensor.md} (100%) rename pytorch/官方教程/{04.md => 04Autograd.md} (100%) rename pytorch/官方教程/{05.md => 05NN.md} (98%) rename pytorch/官方教程/{06.md => 06ImageClassification.md} (100%) rename pytorch/官方教程/{07.md => 07example.md} (92%) delete mode 100644 pytorch/官方教程/10.md delete mode 100644 pytorch/官方教程/11.md delete mode 100644 pytorch/官方教程/12.md delete mode 100644 pytorch/官方教程/13.md delete mode 100644 pytorch/官方教程/14.md delete mode 100644 pytorch/官方教程/15.md delete mode 100644 pytorch/官方教程/16.md delete mode 100644 pytorch/官方教程/17.md delete mode 100644 pytorch/官方教程/README.md delete mode 100644 pytorch/官方教程/book.json create mode 100644 pytorch/实战/.gitignore create mode 100644 pytorch/实战/6.ipynb create mode 100644 pytorch/实战/7.ipynb create mode 100644 pytorch/实战/cifar_net.pth diff --git a/pytorch/官方教程/01.md b/pytorch/官方教程/01.md deleted file mode 100644 index fef39340..00000000 --- a/pytorch/官方教程/01.md +++ /dev/null @@ -1 +0,0 @@ -# 学习 PyTorch \ No newline at end of file diff --git a/pytorch/官方教程/01概述.md b/pytorch/官方教程/01概述.md new file mode 100644 index 00000000..bac5dce5 --- /dev/null +++ b/pytorch/官方教程/01概述.md @@ -0,0 +1,88 @@ +# 学习 PyTorch + + +## 过程 + +1. 获取数据集 +2. 数据预处理 +3. 训练模型 + 1. 神经网络：torch.nn.Model.__init__定义具有一些可学习参数（或权重）的神经网络 + 2. 正向传播：torch.nn.Model.forward通过网络处理输入，进行正向传播 + 3. 计算损失：torch.nn.loss输出正确的距离有多远 + 4. 反向传播：torch.tensor.backward将梯度传播回网络参数 + 5. 更新权重：troch.optim通常使用简单的更新规则来更新网络的权重：weight = weight - learning_rate * gradient +4. 验证模型 +5. 使用模型 + + +## 术语 + +* 特征`3*32*32` +* 层：卷积层、池化层、全连接层 +* 算子：卷积层使用的卷积算子。池化层的赤化算子`3*3` +* 激活函数：卷积层的的每个卷积算子计算完成后输出一个新的特征。激活函数对这个卷积算子处理后的结果进行第二次处理。`1*1`。不改变特征的维度。只添加一个对特征的调整。 +* 权重。在深度神经网络中，权重使用来计算z的求和使用的。在卷积神经网络中， + + + +## 标准神经网络 + +* 现实生活中，channel表示通道的数量。神经网络的计算图，从前向后，有无数的通道。channel就是表示这个通道的数量。channel:某一层输入输出的数量。分别用inchannls和outchannels +* 通道的数量，指某一层的通道的数量，而非相对于某一个神经元来说。同一层的神经元遵循相同的计算方法（使用同一个算子） +* 在普通神经网络中，一个channel表示一条通道（连线），就只能产生一个值。这个值会×权重，作为下一层的激活值。然后调用激活函数，作为下一层的输出值。 +* 在卷积神经网络中，channel代表的含义也一样。一个channel表示一条通道（连线），但是这个通道上传递的是高维的特征数据，而非简单的一个数据。如conv2d，传递的可能是`32*32`的特征。第二层使用了inchannel3，outchannel6，卷积算子（卷积核）的大小为3.该层处理的输入特征为3个channel的`32*32`。输出特征是6个channel的`28*28`。表示该层 + +* 在标准神经网络的构建过程中，可以在前向传播过程中对函数过程进行控制。可以构造任意形状的计算图。每一层的神经元可以不一样。 +## 卷积神经网络 + + +* 与之前的卷积过程相比较，卷积神经网络的单层结构多了激活函数和偏移量；而与标准神经网络： + +$$Z^{[l]} = W^{[l]}A^{[l-1]}+b$$ +$$A^{[l]} = g^{[l]}(Z^{[l]})$$ + +* 相比，滤波器的数值对应着权重 $W^{[l]}$，卷积运算对应着 $W^{[l]}$与 $A^{[l-1]}$的乘积运算，所选的激活函数变为 ReLU。 + +* 对于一个 3x3x3 的滤波器，包括偏移量 $b$在内共有 28 个参数。不论输入的图片有多大，用这一个滤波器来提取特征时，参数始终都是 28 个，固定不变。即**选定滤波器组后，参数的数目与输入图片的尺寸无关**。因此，卷积神经网络的参数相较于标准神经网络来说要少得多。这是 CNN 的优点之一。 + +## 数据规模——普通神经网络 + +## 数据规模——卷积神经网络 + +### channel的理解 +> 与数据规模相关的量主要包括以下几种。他们共同构成了张量的各个维度。在torch.nn当中的运算，都是以层为单位进行计算的。也就是说，同一层只有一种神经元，多个神经元表示多个channel，同一层的输入输出使用一个张量来表示。 + +### 数据的规模 +对torch.nn来说。一个张量至少应该包括四个维度。batch_size,channesl,height,width。每一个张量表示某一层的所有输入或输出。 + + +* batch_size:张量的第一个维度。表示输入样本的个数。在传播计算和理解过程中，可以假设没有这个维度。但是在实际的运算过程中，第一维表示的batch_size +* channels:表示该层算子的个数、神经元的个数。in_channels表示输入的神经元的个数。out_channels表示输出神经元的个数。 +* height +* width[-depth]表示一张图片或者一个条数据的大小。 + + +### 参数的数量 +对于每一层的参数的数量的计算如下。也就是说每一个卷积层有两个参数， 一个参数是weight，另一个参数是bias。具体的就是conv2.weight conv2.bias + +```py +>>> conv2 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=(4,3,2)) +>>> for (name, param) in conv2.named_parameters(): +>>> print(name) +weight +bias +>>> print(conv2.weight.shape) +torch.Size([32, 3, 4, 3, 2]) +``` + + +## 构成 + +> 在构建普通神经网络的时候。可以实现不同的控制级别。 + +* 神经网络的构成主要包括以下几个内容：数据+算子+过程。实现模型的训练。 + * 数据（样本）或者说激活值。 + * 算子。 + * 自己定义的算子，需要自己声明参数并初始化。 + * 使用系统定义的算子，系统会自动添加参数。 + * 过程：前项传播的函数。后向传播的函数。误差计算的函数。梯度下降的函数。 \ No newline at end of file diff --git a/pytorch/官方教程/02.md b/pytorch/官方教程/02.md deleted file mode 100644 index ef79c60d..00000000 --- a/pytorch/官方教程/02.md +++ /dev/null @@ -1,39 +0,0 @@ -# PyTorch 深度学习：60分钟快速入门 - -> 原文： - -**作者**： [Soumith Chintala](http://soumith.ch) - - - -## 什么是 PyTorch？ - -PyTorch 是基于以下两个目的而打造的python科学计算框架： - -* 无缝替换NumPy，并且通过利用GPU的算力来实现神经网络的加速。 -* 通过自动微分机制，来让神经网络的实现变得更加容易。 - -## 本次教程的目标： - -* 深入了解PyTorch的张量单元以及如何使用Pytorch来搭建神经网络。 -* 自己动手训练一个小型神经网络来实现图像的分类。 - -注意 - -确保已安装[`torch`](https://github.com/pytorch/pytorch)和[`torchvision`](https://github.com/pytorch/vision)包。 - -![../_img/tensor_illustration_flat.png](img/0c7a402331744a44f5e17575b1607904.png) - -[张量](blitz/tensor_tutorial.html#sphx-glr-beginner-blitz-tensor-tutorial-py) - -![../_img/autodiff.png](img/0a7a97c39d6dfc0e08d2701eb7a49231.png) - -[`torch.autograd`的简要介绍](blitz/autograd_tutorial.html#sphx-glr-beginner-blitz-autograd-tutorial-py) - -![../_img/mnist1.png](img/be60e8e1f4baa0de87cf9d37c5325525.png) - -[神经网络简介](blitz/neural_networks_tutorial.html#sphx-glr-beginner-blitz-neural-networks-tutorial-py) - -![../_img/cifar101.png](img/7a28f697e6bab9f3d9b1e8da4a5a5249.png) - -[自己动手训练一个图像分类器](blitz/cifar10_tutorial.html#sphx-glr-beginner-blitz-cifar10-tutorial-py) diff --git a/pytorch/官方教程/02Pytorch.md b/pytorch/官方教程/02Pytorch.md new file mode 100644 index 00000000..6904f60c --- /dev/null +++ b/pytorch/官方教程/02Pytorch.md @@ -0,0 +1,28 @@ +# PyTorch 深度学习：60分钟快速入门 + +> 原文： + +**作者**： [Soumith Chintala](http://soumith.ch) + + + +## 什么是 PyTorch？ + +PyTorch 是基于以下两个目的而打造的python科学计算框架： + +* 无缝替换NumPy，并且通过利用GPU的算力来实现神经网络的加速。 +* 通过自动微分机制，来让神经网络的实现变得更加容易。 + +## 本次教程的目标： + +* 深入了解PyTorch的张量单元以及如何使用Pytorch来搭建神经网络。 +* 自己动手训练一个小型神经网络来实现图像的分类。 + + +## 目录 + +* [02Pytorch](02Pytorch.md) +* [03Tensor张量](03Tensor.md) +* [04autograd](04Autograd.md) +* [05神经网络](05NN.md) +* [06图像分类器](06Classification.md) diff --git a/pytorch/官方教程/03.md b/pytorch/官方教程/03Tensor.md similarity index 100% rename from pytorch/官方教程/03.md rename to pytorch/官方教程/03Tensor.md diff --git a/pytorch/官方教程/04.md b/pytorch/官方教程/04Autograd.md similarity index 100% rename from pytorch/官方教程/04.md rename to pytorch/官方教程/04Autograd.md diff --git a/pytorch/官方教程/05.md b/pytorch/官方教程/05NN.md similarity index 98% rename from pytorch/官方教程/05.md rename to pytorch/官方教程/05NN.md index 06eac934..9783d1b5 100644 --- a/pytorch/官方教程/05.md +++ b/pytorch/官方教程/05NN.md @@ -17,8 +17,8 @@ 神经网络的典型训练过程如下： * 定义具有一些可学习参数（或权重）的神经网络 -* 遍历输入数据集 -* 通过网络处理输入 +* 遍历输入数据集，进行数据预处理 +* 通过网络处理输入，进行正向传播 * 计算损失（输出正确的距离有多远） * 将梯度传播回网络参数 * 通常使用简单的更新规则来更新网络的权重：`weight = weight - learning_rate * gradient` diff --git a/pytorch/官方教程/06.md b/pytorch/官方教程/06ImageClassification.md similarity index 100% rename from pytorch/官方教程/06.md rename to pytorch/官方教程/06ImageClassification.md diff --git a/pytorch/官方教程/07.md b/pytorch/官方教程/07example.md similarity index 92% rename from pytorch/官方教程/07.md rename to pytorch/官方教程/07example.md index 4cedfe0b..691e68b4 100644 --- a/pytorch/官方教程/07.md +++ b/pytorch/官方教程/07example.md @@ -17,9 +17,7 @@ PyTorch 的核心是提供两个主要功能： 您可以在[本页](#examples-download)浏览各个示例。 -## 张量 - -### 预热：NumPy +## 1 预热：NumPy 在介绍 PyTorch 之前，我们将首先使用 numpy 实现网络。 @@ -68,7 +66,7 @@ print(f'Result: y = {a} + {b} x + {c} x^2 + {d} x^3') ``` -### PyTorch：张量 +## 2 PyTorch：张量 Numpy 是一个很棒的框架，但是它不能利用 GPU 来加速其数值计算。 对于现代深度神经网络，GPU 通常会提供 [50 倍或更高](https://github.com/jcjohnson/cnn-benchmarks)的加速，因此遗憾的是，numpy 不足以实现现代深度学习。 @@ -125,9 +123,9 @@ print(f'Result: y = {a.item()} + {b.item()} x + {c.item()} x^2 + {d.item()} x^3' ``` -## Autograd +## 3 Autograd -### PyTorch：张量和 Autograd +## 3.1 PyTorch：张量和 Autograd 在上述示例中，我们必须手动实现神经网络的前向和后向传递。 对于小型的两层网络，手动实现反向传递并不是什么大问题，但是对于大型的复杂网络来说，可以很快变得非常麻烦。 @@ -198,7 +196,7 @@ print(f'Result: y = {a.item()} + {b.item()} x + {c.item()} x^2 + {d.item()} x^3' ``` -### PyTorch：定义新的 Autograd 函数 +## 3.2 PyTorch：定义新的 Autograd 函数 在幕后，每个原始的 Autograd 运算符实际上都是在张量上运行的两个函数。 **正向**函数从输入张量计算输出张量。 **反向**函数接收相对于某个标量值的输出张量的梯度，并计算相对于相同标量值的输入张量的梯度。 @@ -293,9 +291,9 @@ print(f'Result: y = {a.item()} + {b.item()} * P3({c.item()} + {d.item()} x)') ``` -## `nn`模块 +## 4 `nn`模块 -### PyTorch：`nn` +## 4.1 PyTorch：`nn` 计算图和 Autograd 是定义复杂运算符并自动采用导数的非常强大的范例。 但是对于大型神经网络，原始的 Autograd 可能会太低级。 @@ -380,7 +378,7 @@ print(f'Result: y = {linear_layer.bias.item()} + {linear_layer.weight[:, 0].item ``` -### PyTorch：`optim` +## 4.2 PyTorch：`optim` 到目前为止，我们已经通过使用`torch.no_grad()`手动更改持有可学习参数的张量来更新模型的权重。 对于像随机梯度下降这样的简单优化算法来说，这并不是一个巨大的负担，但是在实践中，我们经常使用更复杂的优化器（例如 AdaGrad，RMSProp，Adam 等）来训练神经网络。 @@ -443,7 +441,7 @@ print(f'Result: y = {linear_layer.bias.item()} + {linear_layer.weight[:, 0].item ``` -### PyTorch：自定义`nn`模块 +## 4.3 PyTorch：自定义`nn`模块 有时，您将需要指定比一系列现有模块更复杂的模型。 对于这些情况，您可以通过子类化`nn.Module`并定义一个`forward`来定义自己的模块，该模块使用其他模块或在 Tensors 上的其他自动转换操作来接收输入 Tensors 并生成输出 Tensors。 @@ -510,7 +508,7 @@ print(f'Result: {model.string()}') ``` -### PyTorch：控制流 + 权重共享 +## 4.4 PyTorch：控制流 + 权重共享 作为动态图和权重共享的示例，我们实现了一个非常奇怪的模型：一个三阶多项式，在每个正向传播中选择 3 到 5 之间的一个随机数，并使用该阶数，多次使用相同的权重重复计算四和五阶。 @@ -586,46 +584,4 @@ for t in range(30000): print(f'Result: {model.string()}') -``` - -## 示例 - -您可以在此处浏览以上示例。 - -### 张量 - -![../_img/sphx_glr_polynomial_numpy_thumb.png](img/ea0bddb69dfbd67215b823007544ab8f.png) - -[热身：NumPy](examples_tensor/polynomial_numpy.html#sphx-glr-beginner-examples-tensor-polynomial-numpy-py) - -![../_img/sphx_glr_polynomial_tensor_thumb.png](img/04ee335faf821b337dba0c4d7ccb0b67.png) - -[PyTorch：张量](examples_tensor/polynomial_tensor.html#sphx-glr-beginner-examples-tensor-polynomial-tensor-py) - -### Autograd - -![../_img/sphx_glr_polynomial_autograd_thumb.png](img/ffad28c33f8a48d06521421f1aa441ed.png) - -[PyTorch：张量和 Autograd](examples_autograd/polynomial_autograd.html#sphx-glr-beginner-examples-autograd-polynomial-autograd-py) - -![../_img/sphx_glr_polynomial_custom_function_thumb.png](img/a5c5d931ed12e34bf68476f4f157b780.png) - -[PyTorch：定义新的 Autograd 函数](examples_autograd/polynomial_custom_function.html#sphx-glr-beginner-examples-autograd-polynomial-custom-function-py) - -### `nn`模块 - -![../_img/sphx_glr_polynomial_nn_thumb.png](img/335fb81e535f98bfda7cbdb3e50d8832.png) - -[PyTorch：`nn`](examples_nn/polynomial_nn.html#sphx-glr-beginner-examples-nn-polynomial-nn-py) - -![../_img/sphx_glr_polynomial_optim_thumb.png](img/87aa5017f5f0ba9a29d66e74ac6b3d1a.png) - -[PyTorch：`optim`](examples_nn/polynomial_optim.html#sphx-glr-beginner-examples-nn-polynomial-optim-py) - -![../_img/sphx_glr_polynomial_module_thumb.png](img/b3f0b96ed8ba751fee4a5fc7ca878eb1.png) - -[PyTorch：自定义`nn`模块](examples_nn/polynomial_module.html#sphx-glr-beginner-examples-nn-polynomial-module-py) - -![../_img/sphx_glr_dynamic_net_thumb.png](img/bf0b252ce2d39ba6da26c16bee984d39.png) - -[PyTorch：控制流 + 权重共享](examples_nn/dynamic_net.html#sphx-glr-beginner-examples-nn-dynamic-net-py) \ No newline at end of file +``` \ No newline at end of file diff --git a/pytorch/官方教程/08.md b/pytorch/官方教程/08.md index d78d6eb0..e6867d85 100644 --- a/pytorch/官方教程/08.md +++ b/pytorch/官方教程/08.md @@ -1,59 +1,971 @@ -# 热身：NumPy +# `torch.nn`到底是什么？ -> 原文： +> 原文： -经过训练的三阶多项式，可以通过最小化平方的欧几里得距离来预测`y = sin(x)`从`-pi`到`pi`。 +作者：Jeremy Howard，[fast.ai](https://www.fast.ai)。 感谢 Rachel Thomas 和 Francisco Ingham。 -此实现使用 numpy 手动计算正向传播，损失和后向通过。 +我们建议将本教程作为笔记本而不是脚本来运行。 要下载笔记本（`.ipynb`）文件，请单击页面顶部的链接。 -numpy 数组是通用的 n 维数组； 它对深度学习，梯度或计算图一无所知，而只是执行通用数值计算的一种方法。 +PyTorch 提供设计精美的模块和类[`torch.nn`](https://pytorch.org/docs/stable/nn.html)，[`torch.optim`](https://pytorch.org/docs/stable/optim.html)，[`Dataset`](https://pytorch.org/docs/stable/data.html?highlight=dataset#torch.utils.data.Dataset)和[`DataLoader`](https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader)神经网络。 为了充分利用它们的功能并针对您的问题对其进行自定义，您需要真正了解它们在做什么。 为了建立这种理解，我们将首先在 MNIST 数据集上训练基本神经网络，而无需使用这些模型的任何功能。 我们最初将仅使用最基本的 PyTorch 张量函数。 然后，我们将一次从`torch.nn`，`torch.optim`，`Dataset`或`DataLoader`中逐个添加一个函数，以准确显示每个函数，以及如何使代码更简洁或更有效。 灵活。 + +**本教程假定您已经安装了 PyTorch，并且熟悉张量操作的基础知识。** （如果您熟悉 Numpy 数组操作，将会发现此处使用的 PyTorch 张量操作几乎相同）。 + +## MNIST 数据集 + +我们将使用经典的 [MNIST](http://deeplearning.net/data/mnist/) 数据集，该数据集由手绘数字的黑白图像组成（0 到 9 之间）。 + +我们将使用[`pathlib`](https://docs.python.org/3/library/pathlib.html)处理路径（Python 3 标准库的一部分），并使用[`requests`](http://docs.python-requests.org/en/master/)下载数据集。 我们只会在使用模块时才导入它们，因此您可以确切地看到每个位置上正在使用的模块。 ```py -import numpy as np -import math +from pathlib import Path +import requests -# Create random input and output data -x = np.linspace(-math.pi, math.pi, 2000) -y = np.sin(x) +DATA_PATH = Path("data") +PATH = DATA_PATH / "mnist" -# Randomly initialize weights -a = np.random.randn() -b = np.random.randn() -c = np.random.randn() -d = np.random.randn() +PATH.mkdir(parents=True, exist_ok=True) -learning_rate = 1e-6 -for t in range(2000): - # Forward pass: compute predicted y - # y = a + b x + c x^2 + d x^3 - y_pred = a + b * x + c * x ** 2 + d * x ** 3 +URL = "https://github.com/pytorch/tutorials/raw/master/_static/" +FILENAME = "mnist.pkl.gz" - # Compute and print loss - loss = np.square(y_pred - y).sum() - if t % 100 == 99: - print(t, loss) - - # Backprop to compute gradients of a, b, c, d with respect to loss - grad_y_pred = 2.0 * (y_pred - y) - grad_a = grad_y_pred.sum() - grad_b = (grad_y_pred * x).sum() - grad_c = (grad_y_pred * x ** 2).sum() - grad_d = (grad_y_pred * x ** 3).sum() - - # Update weights - a -= learning_rate * grad_a - b -= learning_rate * grad_b - c -= learning_rate * grad_c - d -= learning_rate * grad_d - -print(f'Result: y = {a} + {b} x + {c} x^2 + {d} x^3') +if not (PATH / FILENAME).exists(): + content = requests.get(URL + FILENAME).content + (PATH / FILENAME).open("wb").write(content) ``` -**脚本的总运行时间**：（0 分钟 0.000 秒） +该数据集为 numpy 数组格式，并已使用`pickle`（一种用于序列化数据的 python 特定格式）存储。 -[下载 Python 源码：`polynomial_numpy.py`](https://pytorch.org/tutorials/_downloads/6287cd68dd239d4f34ac75d774a66e23/polynomial_numpy.py) +```py +import pickle +import gzip -[下载 Jupyter 笔记本：`polynomial_numpy.ipynb`](https://pytorch.org/tutorials/_downloads/d4cfaf6a36486a5e37afb34266028d9e/polynomial_numpy.ipynb) +with gzip.open((PATH / FILENAME).as_posix(), "rb") as f: + ((x_train, y_train), (x_valid, y_valid), _) = pickle.load(f, encoding="latin-1") + +``` + +每个图像为`28 x 28`，并存储为长度为`784 = 28x28`的扁平行。 让我们来看一个； 我们需要先将其重塑为 2d。 + +```py +from matplotlib import pyplot +import numpy as np + +pyplot.imshow(x_train[0].reshape((28, 28)), cmap="gray") +print(x_train.shape) + +``` + +![../_img/sphx_glr_nn_tutorial_001.png](img/7c783def0bbe536f41ed172041b7e89e.png) + +出： + +```py +(50000, 784) + +``` + +PyTorch 使用`torch.tensor`而不是 numpy 数组，因此我们需要转换数据。 + +```py +import torch + +x_train, y_train, x_valid, y_valid = map( + torch.tensor, (x_train, y_train, x_valid, y_valid) +) +n, c = x_train.shape +x_train, x_train.shape, y_train.min(), y_train.max() +print(x_train, y_train) +print(x_train.shape) +print(y_train.min(), y_train.max()) + +``` + +出： + +```py +tensor([[0., 0., 0., ..., 0., 0., 0.], + [0., 0., 0., ..., 0., 0., 0.], + [0., 0., 0., ..., 0., 0., 0.], + ..., + [0., 0., 0., ..., 0., 0., 0.], + [0., 0., 0., ..., 0., 0., 0.], + [0., 0., 0., ..., 0., 0., 0.]]) tensor([5, 0, 4, ..., 8, 4, 8]) +torch.Size([50000, 784]) +tensor(0) tensor(9) + +``` + +## 从零开始的神经网络（没有`torch.nn`） + +首先，我们仅使用 PyTorch 张量操作创建模型。 我们假设您已经熟悉神经网络的基础知识。 （如果不是，则可以在 [course.fast.ai](https://course.fast.ai) 中学习它们）。 + +PyTorch 提供了创建随机或零填充张量的方法，我们将使用它们来为简单的线性模型创建权重和偏差。 这些只是常规张量，还有一个非常特殊的附加值：我们告诉 PyTorch 它们需要梯度。 这使 PyTorch 记录了在张量上完成的所有操作，因此它可以在反向传播时*自动计算*的梯度！ + +**对于权重，我们在初始化之后设置`requires_grad`，因为我们不希望该步骤包含在梯度中。 （请注意，PyTorch 中的尾随`_`表示该操作是原地执行的。）** + +注意 + +我们在这里用 [Xavier 初始化](http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf)（通过乘以`1 / sqrt(n)`）来初始化权重。 + +```py +import math + +weights = torch.randn(784, 10) / math.sqrt(784) +weights.requires_grad_() +bias = torch.zeros(10, requires_grad=True) + +``` + +由于 PyTorch 具有自动计算梯度的功能，我们可以将任何标准的 Python 函数（或可调用对象）用作模型！ 因此，我们只需编写一个普通矩阵乘法和广播加法即可创建一个简单的线性模型。 我们还需要激活函数，因此我们将编写并使用`log_softmax`。 请记住：尽管 PyTorch 提供了许多预写的损失函数，激活函数等，但是您可以使用纯 Python 轻松编写自己的函数。 PyTorch 甚至会自动为您的函数创建快速 GPU 或向量化的 CPU 代码。 + +```py +def log_softmax(x): + return x - x.exp().sum(-1).log().unsqueeze(-1) + +def model(xb): + return log_softmax(xb @ weights + bias) + +``` + +在上面，`@`代表点积运算。 我们将对一批数据（在本例中为 64 张图像）调用函数。 这是一个*正向传播*。 请注意，由于我们从随机权重开始，因此在这一阶段，我们的预测不会比随机预测更好。 + +```py +bs = 64 # batch size + +xb = x_train[0:bs] # a mini-batch from x +preds = model(xb) # predictions +preds[0], preds.shape +print(preds[0], preds.shape) + +``` + +出： + +```py +tensor([-2.5964, -2.3153, -2.1321, -2.4480, -2.2930, -1.9507, -2.1289, -2.4175, + -2.5332, -2.3967], grad_fn=) torch.Size([64, 10]) + +``` + +如您所见，`preds`张量不仅包含张量值，还包含梯度函数。 稍后我们将使用它进行反向传播。 + +让我们实现负对数可能性作为损失函数（同样，我们只能使用标准 Python）： + +```py +def nll(input, target): + return -input[range(target.shape[0]), target].mean() + +loss_func = nll + +``` + +让我们使用随机模型来检查损失，以便我们稍后查看反向传播后是否可以改善我们的损失。 + +```py +yb = y_train[0:bs] +print(loss_func(preds, yb)) + +``` + +出： + +```py +tensor(2.3735, grad_fn=) + +``` + +我们还实现一个函数来计算模型的准确率。 对于每个预测，如果具有最大值的索引与目标值匹配，则该预测是正确的。 + +```py +def accuracy(out, yb): + preds = torch.argmax(out, dim=1) + return (preds == yb).float().mean() + +``` + +让我们检查一下随机模型的准确率，以便我们可以看出随着损失的增加，准确率是否有所提高。 + +```py +print(accuracy(preds, yb)) + +``` + +出： + +```py +tensor(0.0938) + +``` + +现在，我们可以运行一个训练循环。 对于每次迭代，我们将： + +* 选择一个小批量数据（大小为`bs`） +* 使用模型进行预测 +* 计算损失 +* `loss.backward()`更新模型的梯度，在这种情况下为`weights`和`bias`。 + +现在，我们使用这些梯度来更新权重和偏差。 我们在`torch.no_grad()`上下文管理器中执行此操作，因为我们不希望在下一步的梯度计算中记录这些操作。 [您可以在这里阅读有关 PyTorch 的 Autograd 如何记录操作的更多信息](https://pytorch.org/docs/stable/notes/autograd.html)。 + +然后，将梯度设置为零，以便为下一个循环做好准备。 否则，我们的梯度会记录所有已发生操作的运行记录（即`loss.backward()`将梯度添加到已存储的内容中，而不是替换它们）。 + +小费 + +您可以使用标准的 python 调试器逐步浏览 PyTorch 代码，从而可以在每一步检查各种变量值。 取消注释以下`set_trace()`即可尝试。 + +```py +from IPython.core.debugger import set_trace + +lr = 0.5 # learning rate +epochs = 2 # how many epochs to train for + +for epoch in range(epochs): + for i in range((n - 1) // bs + 1): + # set_trace() + start_i = i * bs + end_i = start_i + bs + xb = x_train[start_i:end_i] + yb = y_train[start_i:end_i] + pred = model(xb) + loss = loss_func(pred, yb) + + loss.backward() + with torch.no_grad(): + weights -= weights.grad * lr + bias -= bias.grad * lr + weights.grad.zero_() + bias.grad.zero_() + +``` + +就是这样：我们完全从头开始创建并训练了一个最小的神经网络（在这种情况下，是逻辑回归，因为我们没有隐藏的层）！ + +让我们检查损失和准确率，并将其与我们之前获得的进行比较。 我们希望损失会减少，准确率会增加，而且确实如此。 + +```py +print(loss_func(model(xb), yb), accuracy(model(xb), yb)) + +``` + +出： + +```py +tensor(0.0811, grad_fn=) tensor(1.) + +``` + +## 使用`torch.nn.functional` + +现在，我们将重构代码，使其执行与以前相同的操作，只是我们将开始利用 PyTorch 的`nn`类使其更加简洁和灵活。 从这里开始的每一步，我们都应该使代码中的一个或多个：更短，更易理解和/或更灵活。 + +第一步也是最简单的步骤，就是用`torch.nn.functional`（通常按照惯例将其导入到名称空间`F`中）替换我们的手写激活和损失函数，从而缩短代码长度。 该模块包含`torch.nn`库中的所有函数（而该库的其他部分包含类）。 除了广泛的损失和激活函数外，您还会在这里找到一些方便的函数来创建神经网络，例如合并函数。 （还有一些用于进行卷积，线性层等的函数，但是正如我们将看到的那样，通常可以使用库的其他部分来更好地处理这些函数。） + +如果您使用的是负对数似然损失和对数 softmax 激活，那么 Pytorch 会提供结合了两者的单一函数`F.cross_entropy`。 因此，我们甚至可以从模型中删除激活函数。 + +```py +import torch.nn.functional as F + +loss_func = F.cross_entropy + +def model(xb): + return xb @ weights + bias + +``` + +请注意，我们不再在`model`函数中调用`log_softmax`。 让我们确认我们的损失和准确率与以前相同： + +```py +print(loss_func(model(xb), yb), accuracy(model(xb), yb)) + +``` + +出： + +```py +tensor(0.0811, grad_fn=) tensor(1.) + +``` + +## 使用`nn.Module`重构 + +接下来，我们将使用`nn.Module`和`nn.Parameter`进行更清晰，更简洁的训练循环。 我们将`nn.Module`子类化（它本身是一个类并且能够跟踪状态）。 在这种情况下，我们要创建一个类，该类包含前进步骤的权重，偏置和方法。 `nn.Module`具有许多我们将要使用的属性和方法（例如`.parameters()`和`.zero_grad()`）。 + +注意 + +`nn.Module`（大写`M`）是 PyTorch 的特定概念，并且是我们将经常使用的一类。 不要将`nn.Module`与[模块](https://docs.python.org/3/tutorial/modules.html)（小写`m`）的 Python 概念混淆，该模块是可以导入的 Python 代码文件。 + +```py +from torch import nn + +class Mnist_Logistic(nn.Module): + def __init__(self): + super().__init__() + self.weights = nn.Parameter(torch.randn(784, 10) / math.sqrt(784)) + self.bias = nn.Parameter(torch.zeros(10)) + + def forward(self, xb): + return xb @ self.weights + self.bias + +``` + +由于我们现在使用的是对象而不是仅使用函数，因此我们首先必须实例化模型： + +```py +model = Mnist_Logistic() + +``` + +现在我们可以像以前一样计算损失。 请注意，`nn.Module`对象的使用就好像它们是函数一样（即，它们是*可调用的*），但是在后台 Pytorch 会自动调用我们的`forward`方法。 + +```py +print(loss_func(model(xb), yb)) + +``` + +出： + +```py +tensor(2.3903, grad_fn=) + +``` + +以前，在我们的训练循环中，我们必须按名称更新每个参数的值，并手动将每个参数的梯度分别归零，如下所示： + +```py +with torch.no_grad(): + weights -= weights.grad * lr + bias -= bias.grad * lr + weights.grad.zero_() + bias.grad.zero_() + +``` + +现在我们可以利用`model.parameters()`和`model.zero_grad()`（它们都由 PyTorch 为`nn.Module`定义）来使这些步骤更简洁，并且更不会出现忘记某些参数的错误，尤其是当我们有一个更复杂的模型的时候： + +```py +with torch.no_grad(): + for p in model.parameters(): p -= p.grad * lr + model.zero_grad() + +``` + +我们将把小的训练循环包装在`fit`函数中，以便稍后再运行。 + +```py +def fit(): + for epoch in range(epochs): + for i in range((n - 1) // bs + 1): + start_i = i * bs + end_i = start_i + bs + xb = x_train[start_i:end_i] + yb = y_train[start_i:end_i] + pred = model(xb) + loss = loss_func(pred, yb) + + loss.backward() + with torch.no_grad(): + for p in model.parameters(): + p -= p.grad * lr + model.zero_grad() + +fit() + +``` + +让我们仔细检查一下我们的损失是否减少了： + +```py +print(loss_func(model(xb), yb)) + +``` + +出： + +```py +tensor(0.0808, grad_fn=) + +``` + +## 使用`nn.Linear`重构 + +我们继续重构我们的代码。 代替手动定义和初始化`self.weights`和`self.bias`并计算`xb  @ self.weights + self.bias`，我们将对线性层使用 Pytorch 类[`nn.Linear`](https://pytorch.org/docs/stable/nn.html#linear-layers)，这将为我们完成所有工作。 Pytorch 具有许多类型的预定义层，可以大大简化我们的代码，并且通常也可以使其速度更快。 + +```py +class Mnist_Logistic(nn.Module): + def __init__(self): + super().__init__() + self.lin = nn.Linear(784, 10) + + def forward(self, xb): + return self.lin(xb) + +``` + +我们以与以前相同的方式实例化模型并计算损失： + +```py +model = Mnist_Logistic() +print(loss_func(model(xb), yb)) + +``` + +出： + +```py +tensor(2.4215, grad_fn=) + +``` + +我们仍然可以使用与以前相同的`fit`方法。 + +```py +fit() + +print(loss_func(model(xb), yb)) + +``` + +出： + +```py +tensor(0.0824, grad_fn=) + +``` + +## 使用`optim`重构 + +Pytorch 还提供了一个包含各种优化算法的包`torch.optim`。 我们可以使用优化器中的`step`方法采取向前的步骤，而不是手动更新每个参数。 + +这将使我们替换之前的手动编码优化步骤： + +```py +with torch.no_grad(): + for p in model.parameters(): p -= p.grad * lr + model.zero_grad() + +``` + +而是只使用： + +```py +opt.step() +opt.zero_grad() + +``` + +（`optim.zero_grad()`将梯度重置为 0，我们需要在计算下一个小批量的梯度之前调用它。） + +```py +from torch import optim + +``` + +我们将定义一个小函数来创建模型和优化器，以便将来重用。 + +```py +def get_model(): + model = Mnist_Logistic() + return model, optim.SGD(model.parameters(), lr=lr) + +model, opt = get_model() +print(loss_func(model(xb), yb)) + +for epoch in range(epochs): + for i in range((n - 1) // bs + 1): + start_i = i * bs + end_i = start_i + bs + xb = x_train[start_i:end_i] + yb = y_train[start_i:end_i] + pred = model(xb) + loss = loss_func(pred, yb) + + loss.backward() + opt.step() + opt.zero_grad() + +print(loss_func(model(xb), yb)) + +``` + +出： + +```py +tensor(2.2999, grad_fn=) +tensor(0.0823, grad_fn=) + +``` + +## 使用`Dataset`重构 + +PyTorch 有一个抽象的`Dataset`类。 数据集可以是具有`__len__`函数（由 Python 的标准`len`函数调用）和具有`__getitem__`函数作为对其进行索引的一种方法。 [本教程](https://pytorch.org/tutorials/beginner/data_loading_tutorial.html)演示了一个不错的示例，该示例创建一个自定义`FacialLandmarkDataset`类作为`Dataset`的子类。 + +PyTorch 的[`TensorDataset`](https://pytorch.org/docs/stable/_modules/torch/utils/data/dataset.html#TensorDataset)是一个数据集包装张量。 通过定义索引的长度和方式，这也为我们提供了沿张量的第一维进行迭代，索引和切片的方法。 这将使我们在训练的同一行中更容易访问自变量和因变量。 + +```py +from torch.utils.data import TensorDataset + +``` + +`x_train`和`y_train`都可以合并为一个`TensorDataset`，这将更易于迭代和切片。 + +```py +train_ds = TensorDataset(x_train, y_train) + +``` + +以前，我们不得不分别遍历`x`和`y`值的小批量： + +```py +xb = x_train[start_i:end_i] +yb = y_train[start_i:end_i] + +``` + +现在，我们可以一起执行以下两个步骤： + +```py +xb,yb = train_ds[i*bs : i*bs+bs] + +``` + +```py +model, opt = get_model() + +for epoch in range(epochs): + for i in range((n - 1) // bs + 1): + xb, yb = train_ds[i * bs: i * bs + bs] + pred = model(xb) + loss = loss_func(pred, yb) + + loss.backward() + opt.step() + opt.zero_grad() + +print(loss_func(model(xb), yb)) + +``` + +出： + +```py +tensor(0.0819, grad_fn=) + +``` + +## 使用`DataLoader`重构 + +Pytorch 的`DataLoader`负责批量管理。 您可以从任何`Dataset`创建一个`DataLoader`。 `DataLoader`使迭代迭代变得更加容易。 不必使用`train_ds[i*bs : i*bs+bs]`，`DataLoader`会自动为我们提供每个小批量。 + +```py +from torch.utils.data import DataLoader + +train_ds = TensorDataset(x_train, y_train) +train_dl = DataLoader(train_ds, batch_size=bs) + +``` + +以前，我们的循环遍历如下批量`(xb, yb)`： + +```py +for i in range((n-1)//bs + 1): + xb,yb = train_ds[i*bs : i*bs+bs] + pred = model(xb) + +``` + +现在，我们的循环更加简洁了，因为`(xb, yb)`是从数据加载器自动加载的： + +```py +for xb,yb in train_dl: + pred = model(xb) + +``` + +```py +model, opt = get_model() + +for epoch in range(epochs): + for xb, yb in train_dl: + pred = model(xb) + loss = loss_func(pred, yb) + + loss.backward() + opt.step() + opt.zero_grad() + +print(loss_func(model(xb), yb)) + +``` + +出： + +```py +tensor(0.0821, grad_fn=) + +``` + +得益于 Pytorch 的`nn.Module`，`nn.Parameter`，`Dataset`和`DataLoader`，我们的训练循环现在变得更小，更容易理解。 现在，让我们尝试添加在实践中创建有效模型所需的基本功能。 + +## 添加验证 + +在第 1 节中，我们只是试图建立一个合理的训练循环以用于我们的训练数据。 实际上，您也应该**始终**具有[验证集](https://www.fast.ai/2017/11/13/validation-sets/)，以便识别您是否过拟合。 + +[对训练数据进行打乱](https://www.quora.com/Does-the-order-of-training-data-matter-when-training-neural-networks)对于防止批量与过拟合之间的相关性很重要。 另一方面，无论我们是否打乱验证集，验证损失都是相同的。 由于打乱需要花费更多时间，因此打乱验证数据没有任何意义。 + +我们将验证集的批量大小设为训练集的两倍。 这是因为验证集不需要反向传播，因此占用的内存更少（不需要存储梯度）。 我们利用这一优势来使用更大的批量，并更快地计算损失。 + +```py +train_ds = TensorDataset(x_train, y_train) +train_dl = DataLoader(train_ds, batch_size=bs, shuffle=True) + +valid_ds = TensorDataset(x_valid, y_valid) +valid_dl = DataLoader(valid_ds, batch_size=bs * 2) + +``` + +我们将在每个周期结束时计算并打印验证损失。 + +（请注意，我们总是在训练之前调用`model.train()`，并在推理之前调用`model.eval()`，因为诸如`nn.BatchNorm2d`和`nn.Dropout`之类的层会使用它们，以确保这些不同阶段的行为正确。） + +```py +model, opt = get_model() + +for epoch in range(epochs): + model.train() + for xb, yb in train_dl: + pred = model(xb) + loss = loss_func(pred, yb) + + loss.backward() + opt.step() + opt.zero_grad() + + model.eval() + with torch.no_grad(): + valid_loss = sum(loss_func(model(xb), yb) for xb, yb in valid_dl) + + print(epoch, valid_loss / len(valid_dl)) + +``` + +出： + +```py +0 tensor(0.3743) +1 tensor(0.3316) + +``` + +## 创建`fit()`和`get_data()` + +现在，我们将自己进行一些重构。 由于我们经历了两次相似的过程来计算训练集和验证集的损失，因此我们将其设为自己的函数`loss_batch`，该函数可计算一批损失。 + +我们将优化器传入训练集中，然后使用它执行反向传播。 对于验证集，我们没有通过优化程序，因此该方法不会执行反向传播。 + +```py +def loss_batch(model, loss_func, xb, yb, opt=None): + loss = loss_func(model(xb), yb) + + if opt is not None: + loss.backward() + opt.step() + opt.zero_grad() + + return loss.item(), len(xb) + +``` + +`fit`运行必要的操作来训练我们的模型，并计算每个周期的训练和验证损失。 + +```py +import numpy as np + +def fit(epochs, model, loss_func, opt, train_dl, valid_dl): + for epoch in range(epochs): + model.train() + for xb, yb in train_dl: + loss_batch(model, loss_func, xb, yb, opt) + + model.eval() + with torch.no_grad(): + losses, nums = zip( + *[loss_batch(model, loss_func, xb, yb) for xb, yb in valid_dl] + ) + val_loss = np.sum(np.multiply(losses, nums)) / np.sum(nums) + + print(epoch, val_loss) + +``` + +`get_data`返回训练和验证集的数据加载器。 + +```py +def get_data(train_ds, valid_ds, bs): + return ( + DataLoader(train_ds, batch_size=bs, shuffle=True), + DataLoader(valid_ds, batch_size=bs * 2), + ) + +``` + +现在，我们获取数据加载器和拟合模型的整个过程可以在 3 行代码中运行： + +```py +train_dl, valid_dl = get_data(train_ds, valid_ds, bs) +model, opt = get_model() +fit(epochs, model, loss_func, opt, train_dl, valid_dl) + +``` + +出： + +```py +0 0.3120644524335861 +1 0.28915613491535186 + +``` + +您可以使用这些基本的 3 行代码来训练各种各样的模型。 让我们看看是否可以使用它们来训练卷积神经网络（CNN）！ + +## 切换到 CNN + +现在，我们将构建具有三个卷积层的神经网络。 由于上一节中的任何功能都不假设任何有关模型形式的信息，因此我们将能够使用它们来训练 CNN，而无需进行任何修改。 + +我们将使用 Pytorch 的预定义[`Conv2d`](https://pytorch.org/docs/stable/nn.html#torch.nn.Conv2d)类作为我们的卷积层。 我们定义了具有 3 个卷积层的 CNN。 每个卷积后跟一个 ReLU。 最后，我们执行平均池化。 （请注意，`view`是 numpy 的`reshape`的 PyTorch 版本） + +```py +class Mnist_CNN(nn.Module): + def __init__(self): + super().__init__() + self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=2, padding=1) + self.conv2 = nn.Conv2d(16, 16, kernel_size=3, stride=2, padding=1) + self.conv3 = nn.Conv2d(16, 10, kernel_size=3, stride=2, padding=1) + + def forward(self, xb): + xb = xb.view(-1, 1, 28, 28) + xb = F.relu(self.conv1(xb)) + xb = F.relu(self.conv2(xb)) + xb = F.relu(self.conv3(xb)) + xb = F.avg_pool2d(xb, 4) + return xb.view(-1, xb.size(1)) + +lr = 0.1 + +``` + +[动量](https://cs231n.github.io/neural-networks-3/#sgd)是随机梯度下降的一种变体，它也考虑了以前的更新，通常可以加快训练速度。 + +```py +model = Mnist_CNN() +opt = optim.SGD(model.parameters(), lr=lr, momentum=0.9) + +fit(epochs, model, loss_func, opt, train_dl, valid_dl) + +``` + +出： + +```py +0 0.32337012240886687 +1 0.25021172934770586 + +``` + +## `nn.Sequential` + +`torch.nn`还有另一个方便的类，可以用来简化我们的代码：[`Sequential`](https://pytorch.org/docs/stable/nn.html#torch.nn.Sequential)。 `Sequential`对象以顺序方式运行其中包含的每个模块。 这是编写神经网络的一种简单方法。 + +为了利用这一点，我们需要能够从给定的函数轻松定义**自定义层**。 例如，PyTorch 没有视层，我们需要为我们的网络创建一个层。 `Lambda`将创建一个层，然后在使用`Sequential`定义网络时可以使用该层。 + +```py +class Lambda(nn.Module): + def __init__(self, func): + super().__init__() + self.func = func + + def forward(self, x): + return self.func(x) + +def preprocess(x): + return x.view(-1, 1, 28, 28) + +``` + +用`Sequential`创建的模型很简单： + +```py +model = nn.Sequential( + Lambda(preprocess), + nn.Conv2d(1, 16, kernel_size=3, stride=2, padding=1), + nn.ReLU(), + nn.Conv2d(16, 16, kernel_size=3, stride=2, padding=1), + nn.ReLU(), + nn.Conv2d(16, 10, kernel_size=3, stride=2, padding=1), + nn.ReLU(), + nn.AvgPool2d(4), + Lambda(lambda x: x.view(x.size(0), -1)), +) + +opt = optim.SGD(model.parameters(), lr=lr, momentum=0.9) + +fit(epochs, model, loss_func, opt, train_dl, valid_dl) + +``` + +出： + +```py +0 0.30119081069231035 +1 0.25335356528759 + +``` + +## 包装`DataLoader` + +Our CNN is fairly concise, but it only works with MNIST, because: + +* 假设输入为`28 * 28`长向量 +* 假设 CNN 的最终网格尺寸为`4 * 4`（因为这是平均值 + +我们使用的合并核大小） + +让我们摆脱这两个假设，因此我们的模型适用于任何 2d 单通道图像。 首先，我们可以删除初始的 Lambda 层，但将数据预处理移至生成器中： + +```py +def preprocess(x, y): + return x.view(-1, 1, 28, 28), y + +class WrappedDataLoader: + def __init__(self, dl, func): + self.dl = dl + self.func = func + + def __len__(self): + return len(self.dl) + + def __iter__(self): + batches = iter(self.dl) + for b in batches: + yield (self.func(*b)) + +train_dl, valid_dl = get_data(train_ds, valid_ds, bs) +train_dl = WrappedDataLoader(train_dl, preprocess) +valid_dl = WrappedDataLoader(valid_dl, preprocess) + +``` + +接下来，我们可以将`nn.AvgPool2d`替换为`nn.AdaptiveAvgPool2d`，这使我们能够定义所需的*输出*张量的大小，而不是所需的*输入*张量的大小。 结果，我们的模型将适用于任何大小的输入。 + +```py +model = nn.Sequential( + nn.Conv2d(1, 16, kernel_size=3, stride=2, padding=1), + nn.ReLU(), + nn.Conv2d(16, 16, kernel_size=3, stride=2, padding=1), + nn.ReLU(), + nn.Conv2d(16, 10, kernel_size=3, stride=2, padding=1), + nn.ReLU(), + nn.AdaptiveAvgPool2d(1), + Lambda(lambda x: x.view(x.size(0), -1)), +) + +opt = optim.SGD(model.parameters(), lr=lr, momentum=0.9) + +``` + +试试看： + +```py +fit(epochs, model, loss_func, opt, train_dl, valid_dl) + +``` + +出： + +```py +0 0.327303307390213 +1 0.2181092014491558 + +``` + +## 使用您的 GPU + +如果您足够幸运地能够使用具有 CUDA 功能的 GPU（可以从大多数云提供商处以每小时 0.50 美元的价格租用一个），则可以使用它来加速代码。 首先检查您的 GPU 是否在 Pytorch 中正常工作： + +```py +print(torch.cuda.is_available()) + +``` + +出： + +```py +True + +``` + +然后为其创建一个设备对象： + +```py +dev = torch.device( + "cuda") if torch.cuda.is_available() else torch.device("cpu") + +``` + +让我们更新`preprocess`，将批量移至 GPU： + +```py +def preprocess(x, y): + return x.view(-1, 1, 28, 28).to(dev), y.to(dev) + +train_dl, valid_dl = get_data(train_ds, valid_ds, bs) +train_dl = WrappedDataLoader(train_dl, preprocess) +valid_dl = WrappedDataLoader(valid_dl, preprocess) + +``` + +最后，我们可以将模型移至 GPU。 + +```py +model.to(dev) +opt = optim.SGD(model.parameters(), lr=lr, momentum=0.9) + +``` + +您应该发现它现在运行得更快： + +```py +fit(epochs, model, loss_func, opt, train_dl, valid_dl) + +``` + +出： + +```py +0 0.1833980613708496 +1 0.17365939717292786 + +``` + +## 总结 + +现在，我们有了一个通用的数据管道和训练循环，您可以将其用于使用 Pytorch 训练许多类型的模型。 要了解现在可以轻松进行模型训练，请查看`mnist_sample`示例笔记本。 + +当然，您需要添加很多内容，例如数据扩充，超参数调整，监控训练，迁移学习等。 这些功能可在 fastai 库中使用，该库是使用本教程中所示的相同设计方法开发的，为希望进一步推广其模型的从业人员提供了自然的下一步。 + +我们承诺在本教程开始时将通过示例分别说明`torch.nn`，`torch.optim`，`Dataset`和`DataLoader`。 因此，让我们总结一下我们所看到的： + +> * `torch.nn` +> * `Module`：创建一个行为类似于函数的可调用对象，但也可以包含状态（例如神经网络层权重）。 它知道其中包含的 `Parameter` ，并且可以将其所有坡度归零，遍历它们以进行权重更新等。 +> * `Parameter`：张量的包装器，用于告知 `Module` 具有在反向传播期间需要更新的权重。 仅更新具有`require_grad`属性集的张量 +> * `functional`：一个模块（通常按照惯例导入到 `F` 名称空间中），其中包含激活函数，损失函数等。 以及卷积和线性层等层的无状态版本。 +> * `torch.optim`：包含诸如 `SGD` 的优化程序，这些优化程序在后退步骤 +> * `Dataset` 中更新 `Parameter` 的权重。 具有 `__len__` 和 `__getitem__` 的对象，包括 Pytorch 提供的类，例如 `TensorDataset` +> * `DataLoader`：获取任何 `Dataset` 并创建一个迭代器，该迭代器返回批量数据。 + +**脚本的总运行时间**：（0 分钟 57.062 秒） + +[下载 Python 源码：`nn_tutorial.py`](../_downloads/a6246751179fbfb7cad9222ef1c16617/nn_tutorial.py) + +[下载 Jupyter 笔记本：`nn_tutorial.ipynb`](../_downloads/5ddab57bb7482fbcc76722617dd47324/nn_tutorial.ipynb) [由 Sphinx 画廊](https://sphinx-gallery.readthedocs.io)生成的画廊 \ No newline at end of file diff --git a/pytorch/官方教程/09.md b/pytorch/官方教程/09.md index 709223d7..12d5eeb4 100644 --- a/pytorch/官方教程/09.md +++ b/pytorch/官方教程/09.md @@ -1,64 +1,348 @@ -# PyTorch：张量 +# 使用 TensorBoard 可视化模型，数据和训练 -> 原文： +> 原文： -经过训练的三阶多项式，可以通过最小化平方的欧几里得距离来预测`y = sin(x)`从`-pi`到`pi`。 +在 [60 分钟突击](https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html)中，我们向您展示了如何加载数据，如何通过定义为`nn.Module`子类的模型提供数据，如何在训练数据上训练该模型以及在测试数据上对其进行测试。 为了了解发生的情况，我们在模型训练期间打印一些统计数据，以了解训练是否在进行中。 但是，我们可以做得更好：PyTorch 与 TensorBoard 集成在一起，TensorBoard 是一种工具，用于可视化神经网络训练运行的结果。 本教程使用 [Fashion-MNIST 数据集](https://github.com/zalandoresearch/fashion-mnist)说明了其某些功能，可以使用`torchvision.datasets`将其读入 PyTorch。 -此实现使用 PyTorch 张量手动计算正向传播，损失和后向通过。 +在本教程中，我们将学习如何： -PyTorch 张量基本上与 numpy 数组相同：它对深度学习或计算图或梯度一无所知，只是用于任意数值计算的通用 n 维数组。 +> 1. 读取数据并进行适当的转换（与先前的教程几乎相同）。 +> 2. 设置 TensorBoard。 +> 3. 写入 TensorBoard。 +> 4. 使用 TensorBoard 检查模型架构。 +> 5. 使用 TensorBoard 来创建我们在上一个教程中创建的可视化的交互式版本，并使用较少的代码 -numpy 数组和 PyTorch 张量之间的最大区别是 PyTorch 张量可以在 CPU 或 GPU 上运行。 要在 GPU 上运行操作，只需将张量转换为 cuda 数据类型。 +具体来说，在第 5 点，我们将看到： + +> * 有两种方法可以检查我们的训练数据 +> * 在训练模型时如何跟踪其表现 +> * 在训练后如何评估模型的表现。 + +我们将从 [CIFAR-10 教程](https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html)中类似的样板代码开始： ```py +# imports +import matplotlib.pyplot as plt +import numpy as np + import torch -import math +import torchvision +import torchvision.transforms as transforms -dtype = torch.float -device = torch.device("cpu") -# device = torch.device("cuda:0") # Uncomment this to run on GPU +import torch.nn as nn +import torch.nn.functional as F +import torch.optim as optim -# Create random input and output data -x = torch.linspace(-math.pi, math.pi, 2000, device=device, dtype=dtype) -y = torch.sin(x) +# transforms +transform = transforms.Compose( + [transforms.ToTensor(), + transforms.Normalize((0.5,), (0.5,))]) -# Randomly initialize weights -a = torch.randn((), device=device, dtype=dtype) -b = torch.randn((), device=device, dtype=dtype) -c = torch.randn((), device=device, dtype=dtype) -d = torch.randn((), device=device, dtype=dtype) +# datasets +trainset = torchvision.datasets.FashionMNIST('./data', + download=True, + train=True, + transform=transform) +testset = torchvision.datasets.FashionMNIST('./data', + download=True, + train=False, + transform=transform) -learning_rate = 1e-6 -for t in range(2000): - # Forward pass: compute predicted y - y_pred = a + b * x + c * x ** 2 + d * x ** 3 +# dataloaders +trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, + shuffle=True, num_workers=2) - # Compute and print loss - loss = (y_pred - y).pow(2).sum().item() - if t % 100 == 99: - print(t, loss) +testloader = torch.utils.data.DataLoader(testset, batch_size=4, + shuffle=False, num_workers=2) - # Backprop to compute gradients of a, b, c, d with respect to loss - grad_y_pred = 2.0 * (y_pred - y) - grad_a = grad_y_pred.sum() - grad_b = (grad_y_pred * x).sum() - grad_c = (grad_y_pred * x ** 2).sum() - grad_d = (grad_y_pred * x ** 3).sum() +# constant for classes +classes = ('T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', + 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle Boot') - # Update weights using gradient descent - a -= learning_rate * grad_a - b -= learning_rate * grad_b - c -= learning_rate * grad_c - d -= learning_rate * grad_d - -print(f'Result: y = {a.item()} + {b.item()} x + {c.item()} x^2 + {d.item()} x^3') +# helper function to show an image +# (used in the `plot_classes_preds` function below) +def matplotlib_imshow(img, one_channel=False): + if one_channel: + img = img.mean(dim=0) + img = img / 2 + 0.5 # unnormalize + npimg = img.numpy() + if one_channel: + plt.imshow(npimg, cmap="Greys") + else: + plt.imshow(np.transpose(npimg, (1, 2, 0))) ``` -**脚本的总运行时间**：（0 分钟 0.000 秒） +我们将在该教程中定义一个类似的模型架构，仅需进行少量修改即可解决以下事实：图像现在是一个通道而不是三个通道，而图像是`28x28`而不是`32x32`： -[下载 Python 源码：`polynomial_tensor.py`](https://pytorch.org/tutorials/_downloads/38bc029908996abe0c601bcf0f5fd9d8/polynomial_tensor.py) +```py +class Net(nn.Module): + def __init__(self): + super(Net, self).__init__() + self.conv1 = nn.Conv2d(1, 6, 5) + self.pool = nn.MaxPool2d(2, 2) + self.conv2 = nn.Conv2d(6, 16, 5) + self.fc1 = nn.Linear(16 * 4 * 4, 120) + self.fc2 = nn.Linear(120, 84) + self.fc3 = nn.Linear(84, 10) -[下载 Jupyter 笔记本：`polynomial_tensor.ipynb`](https://pytorch.org/tutorials/_downloads/1c715a0888ae0e33279df327e1653329/polynomial_tensor.ipynb) + def forward(self, x): + x = self.pool(F.relu(self.conv1(x))) + x = self.pool(F.relu(self.conv2(x))) + x = x.view(-1, 16 * 4 * 4) + x = F.relu(self.fc1(x)) + x = F.relu(self.fc2(x)) + x = self.fc3(x) + return x -[由 Sphinx 画廊](https://sphinx-gallery.readthedocs.io)生成的画廊 \ No newline at end of file +net = Net() + +``` + +我们将在之前定义相同的`optimizer`和`criterion`： + +```py +criterion = nn.CrossEntropyLoss() +optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) + +``` + +## 1\. TensorBoard 设置 + +现在，我们将设置 TensorBoard，从`torch.utils`导入`tensorboard`并定义`SummaryWriter`，这是将信息写入 TensorBoard 的关键对象。 + +```py +from torch.utils.tensorboard import SummaryWriter + +# default `log_dir` is "runs" - we'll be more specific here +writer = SummaryWriter('runs/fashion_mnist_experiment_1') + +``` + +请注意，仅此行会创建一个`runs/fashion_mnist_experiment_1`文件夹。 + +## 2\. 写入 TensorBoard + +现在，使用[`make_grid`](https://pytorch.org/docs/stable/torchvision/utils.html#torchvision.utils.make_grid)将图像写入到 TensorBoard 中，具体来说就是网格。 + +```py +# get some random training images +dataiter = iter(trainloader) +images, labels = dataiter.next() + +# create grid of images +img_grid = torchvision.utils.make_grid(images) + +# show images +matplotlib_imshow(img_grid, one_channel=True) + +# write to tensorboard +writer.add_image('four_fashion_mnist_images', img_grid) + +``` + +正在运行 + +```py +tensorboard --logdir=runs + +``` + +从命令行，然后导航到`https://localhost:6006`应该显示以下内容。 + +![intermediate/../../_static/img/tensorboard_first_view.png](img/8b09d6361316e495383ceedf9b8407ea.png) + +现在您知道如何使用 TensorBoard 了！ 但是，此示例可以在 Jupyter 笔记本中完成-TensorBoard 真正擅长的地方是创建交互式可视化。 接下来，我们将介绍其中之一，并在本教程结束时介绍更多内容。 + +## 3\. 使用 TensorBoard 检查模型 + +TensorBoard 的优势之一是其可视化复杂模型结构的能力。 让我们可视化我们构建的模型。 + +```py +writer.add_graph(net, images) +writer.close() + +``` + +现在刷新 TensorBoard 后，您应该会看到一个`Graphs`标签，如下所示： + +![intermediate/../../_static/img/tensorboard_model_viz.png](img/8f596b99dbb3c262b61db267d5db2d63.png) + +继续并双击`Net`以展开它，查看构成模型的各个操作的详细视图。 + +TensorBoard 具有非常方便的功能，可在低维空间中可视化高维数据，例如图像数据。 接下来我们将介绍这一点。 + +## 4\. 在 TensorBoard 中添加“投影仪” + +我们可以通过[`add_embedding`](https://pytorch.org/docs/stable/tensorboard.html#torch.utils.tensorboard.writer.SummaryWriter.add_embedding)方法可视化高维数据的低维表示 + +```py +# helper function +def select_n_random(data, labels, n=100): + ''' + Selects n random datapoints and their corresponding labels from a dataset + ''' + assert len(data) == len(labels) + + perm = torch.randperm(len(data)) + return data[perm][:n], labels[perm][:n] + +# select random images and their target indices +images, labels = select_n_random(trainset.data, trainset.targets) + +# get the class labels for each image +class_labels = [classes[lab] for lab in labels] + +# log embeddings +features = images.view(-1, 28 * 28) +writer.add_embedding(features, + metadata=class_labels, + label_img=images.unsqueeze(1)) +writer.close() + +``` + +现在，在 TensorBoard 的“投影仪”选项卡中，您可以看到这 100 张图像-每个图像 784 维-向下投影到三维空间中。 此外，这是交互式的：您可以单击并拖动以旋转三维投影。 最后，一些技巧可以使可视化效果更容易看到：选择左上方的“颜色：标签”，以及启用“夜间模式”，这将使图像更容易看到，因为它们的背景是白色的： + +![intermediate/../../_static/img/tensorboard_projector.png](img/f4990a0920dff7e4647a23cfc1639a8a.png) + +现在我们已经彻底检查了我们的数据，让我们展示了 TensorBoard 如何从训练开始就可以使跟踪模型的训练和评估更加清晰。 + +## 5\. 使用 TensorBoard 跟踪模型训练 + +在前面的示例中，我们仅*每 2000 次迭代*打印该模型的运行损失。 现在，我们将运行损失记录到 TensorBoard 中，并通过`plot_classes_preds`函数查看模型所做的预测。 + +```py +# helper functions + +def images_to_probs(net, images): + ''' + Generates predictions and corresponding probabilities from a trained + network and a list of images + ''' + output = net(images) + # convert output probabilities to predicted class + _, preds_tensor = torch.max(output, 1) + preds = np.squeeze(preds_tensor.numpy()) + return preds, [F.softmax(el, dim=0)[i].item() for i, el in zip(preds, output)] + +def plot_classes_preds(net, images, labels): + ''' + Generates matplotlib Figure using a trained network, along with images + and labels from a batch, that shows the network's top prediction along + with its probability, alongside the actual label, coloring this + information based on whether the prediction was correct or not. + Uses the "images_to_probs" function. + ''' + preds, probs = images_to_probs(net, images) + # plot the images in the batch, along with predicted and true labels + fig = plt.figure(figsize=(12, 48)) + for idx in np.arange(4): + ax = fig.add_subplot(1, 4, idx+1, xticks=[], yticks=[]) + matplotlib_imshow(images[idx], one_channel=True) + ax.set_title("{0}, {1:.1f}%\n(label: {2})".format( + classes[preds[idx]], + probs[idx] * 100.0, + classes[labels[idx]]), + color=("green" if preds[idx]==labels[idx].item() else "red")) + return fig + +``` + +最后，让我们使用与之前教程相同的模型训练代码来训练模型，但是每 1000 批将结果写入 TensorBoard，而不是打印到控制台。 这是通过[`add_scalar`](https://pytorch.org/docs/stable/tensorboard.html#torch.utils.tensorboard.writer.SummaryWriter.add_scalar)函数完成的。 + +此外，在训练过程中，我们将生成一幅图像，显示该批量中包含的四幅图像的模型预测与实际结果。 + +```py +running_loss = 0.0 +for epoch in range(1): # loop over the dataset multiple times + + for i, data in enumerate(trainloader, 0): + + # get the inputs; data is a list of [inputs, labels] + inputs, labels = data + + # zero the parameter gradients + optimizer.zero_grad() + + # forward + backward + optimize + outputs = net(inputs) + loss = criterion(outputs, labels) + loss.backward() + optimizer.step() + + running_loss += loss.item() + if i % 1000 == 999: # every 1000 mini-batches... + + # ...log the running loss + writer.add_scalar('training loss', + running_loss / 1000, + epoch * len(trainloader) + i) + + # ...log a Matplotlib Figure showing the model's predictions on a + # random mini-batch + writer.add_figure('predictions vs. actuals', + plot_classes_preds(net, inputs, labels), + global_step=epoch * len(trainloader) + i) + running_loss = 0.0 +print('Finished Training') + +``` + +现在，您可以查看“标量”选项卡，以查看在 15,000 次训练迭代中绘制的运行损失： + +![intermediate/../../_static/img/tensorboard_scalar_runs.png](img/afda8238ecd1f547d61be4d155844f68.png) + +此外，我们可以查看整个学习过程中模型在任意批量上所做的预测。 查看“图像”选项卡，然后在“预测与实际”可视化条件下向下滚动以查看此内容； 这表明，例如，仅经过 3000 次训练迭代，该模型就已经能够区分出视觉上截然不同的类，例如衬衫，运动鞋和外套，尽管它并没有像后来的训练那样有信心： + +![intermediate/../../_static/img/tensorboard_images.png](img/d5ab1f07cb4a9d9200c2a2d3b238340d.png) + +在之前的教程中，我们研究了模型训练后的每类准确率； 在这里，我们将使用 TensorBoard 绘制每个类别的精确调用曲线（[在这里解释](https://www.scikit-yb.org/en/latest/api/classifier/prcurve.html)）。 + +## 6\. 使用 TensorBoard 评估经过训练的模型 + +```py +# 1\. gets the probability predictions in a test_size x num_classes Tensor +# 2\. gets the preds in a test_size Tensor +# takes ~10 seconds to run +class_probs = [] +class_preds = [] +with torch.no_grad(): + for data in testloader: + images, labels = data + output = net(images) + class_probs_batch = [F.softmax(el, dim=0) for el in output] + _, class_preds_batch = torch.max(output, 1) + + class_probs.append(class_probs_batch) + class_preds.append(class_preds_batch) + +test_probs = torch.cat([torch.stack(batch) for batch in class_probs]) +test_preds = torch.cat(class_preds) + +# helper function +def add_pr_curve_tensorboard(class_index, test_probs, test_preds, global_step=0): + ''' + Takes in a "class_index" from 0 to 9 and plots the corresponding + precision-recall curve + ''' + tensorboard_preds = test_preds == class_index + tensorboard_probs = test_probs[:, class_index] + + writer.add_pr_curve(classes[class_index], + tensorboard_preds, + tensorboard_probs, + global_step=global_step) + writer.close() + +# plot all the pr curves +for i in range(len(classes)): + add_pr_curve_tensorboard(i, test_probs, test_preds) + +``` + +现在，您将看到一个`PR Curves`选项卡，其中包含每个类别的精确调用曲线。 继续四处戳； 您会发现在某些类别中，模型的“曲线下面积”接近 100%，而在另一些类别中，该面积更低： + +![intermediate/../../_static/img/tensorboard_pr_curves.png](img/d15de2be2b754f9a4f46418764232b5e.png) + +这是 TensorBoard 和 PyTorch 与之集成的介绍。 当然，您可以在 Jupyter 笔记本中完成 TensorBoard 的所有操作，但是使用 TensorBoard 时，默认情况下会获得交互式的视觉效果。 \ No newline at end of file diff --git a/pytorch/官方教程/10.md b/pytorch/官方教程/10.md deleted file mode 100644 index da742903..00000000 --- a/pytorch/官方教程/10.md +++ /dev/null @@ -1,77 +0,0 @@ -# PyTorch：张量和 Autograd - -> 原文： - -经过训练的三阶多项式，可以通过最小化平方的欧几里得距离来预测`y = sin(x)`从`-pi`到`pi`。 - -此实现使用 PyTorch 张量上的运算来计算正向传播，并使用 PyTorch Autograd 来计算梯度。 - -PyTorch 张量表示计算图中的一个节点。 如果`x`是具有`x.requires_grad=True`的张量，则`x.grad`是另一个张量，其保持`x`相对于某个标量值的梯度。 - -```py -import torch -import math - -dtype = torch.float -device = torch.device("cpu") -# device = torch.device("cuda:0") # Uncomment this to run on GPU - -# Create Tensors to hold input and outputs. -# By default, requires_grad=False, which indicates that we do not need to -# compute gradients with respect to these Tensors during the backward pass. -x = torch.linspace(-math.pi, math.pi, 2000, device=device, dtype=dtype) -y = torch.sin(x) - -# Create random Tensors for weights. For a third order polynomial, we need -# 4 weights: y = a + b x + c x^2 + d x^3 -# Setting requires_grad=True indicates that we want to compute gradients with -# respect to these Tensors during the backward pass. -a = torch.randn((), device=device, dtype=dtype, requires_grad=True) -b = torch.randn((), device=device, dtype=dtype, requires_grad=True) -c = torch.randn((), device=device, dtype=dtype, requires_grad=True) -d = torch.randn((), device=device, dtype=dtype, requires_grad=True) - -learning_rate = 1e-6 -for t in range(2000): - # Forward pass: compute predicted y using operations on Tensors. - y_pred = a + b * x + c * x ** 2 + d * x ** 3 - - # Compute and print loss using operations on Tensors. - # Now loss is a Tensor of shape (1,) - # loss.item() gets the scalar value held in the loss. - loss = (y_pred - y).pow(2).sum() - if t % 100 == 99: - print(t, loss.item()) - - # Use autograd to compute the backward pass. This call will compute the - # gradient of loss with respect to all Tensors with requires_grad=True. - # After this call a.grad, b.grad. c.grad and d.grad will be Tensors holding - # the gradient of the loss with respect to a, b, c, d respectively. - loss.backward() - - # Manually update weights using gradient descent. Wrap in torch.no_grad() - # because weights have requires_grad=True, but we don't need to track this - # in autograd. - with torch.no_grad(): - a -= learning_rate * a.grad - b -= learning_rate * b.grad - c -= learning_rate * c.grad - d -= learning_rate * d.grad - - # Manually zero the gradients after updating weights - a.grad = None - b.grad = None - c.grad = None - d.grad = None - -print(f'Result: y = {a.item()} + {b.item()} x + {c.item()} x^2 + {d.item()} x^3') - -``` - -**脚本的总运行时间**：（0 分钟 0.000 秒） - -[下载 Python 源码：`polynomial_autograd.py`](https://pytorch.org/tutorials/_downloads/2956e289de4f5fdd59114171805b23d2/polynomial_autograd.py) - -[下载 Jupyter 笔记本：`polynomial_autograd.ipynb`](https://pytorch.org/tutorials/_downloads/e1d4d0ca7bd75ea2fff8032fcb79076e/polynomial_autograd.ipynb) - -[由 Sphinx 画廊](https://sphinx-gallery.readthedocs.io)生成的画廊 \ No newline at end of file diff --git a/pytorch/官方教程/11.md b/pytorch/官方教程/11.md deleted file mode 100644 index a7cda6fa..00000000 --- a/pytorch/官方教程/11.md +++ /dev/null @@ -1,103 +0,0 @@ -# PyTorch：定义新的 Autograd 函数 - -> 原文： - -经过训练的三阶多项式，可以通过最小化平方的欧几里得距离来预测`y = sin(x)`从`-pi`到`pi`。 而不是将多项式写为`y = a + bx + cx ^ 2 + dx ^ 3`，我们将多项式写为`y = a + b P[3](c + dx)`其中`P[3](x) = 1/2 (5x ^ 3 - 3x)`是三次的[勒让德多项式](https://en.wikipedia.org/wiki/Legendre_polynomials)。 - -此实现使用 PyTorch 张量上的运算来计算正向传播，并使用 PyTorch Autograd 来计算梯度。 - -在此实现中，我们实现了自己的自定义 Autograd 函数来执行`P'[3](x)`。 通过数学，`P'[3](x) = 3/2 (5x ^ 2 - 1)`： - -```py -import torch -import math - -class LegendrePolynomial3(torch.autograd.Function): - """ - We can implement our own custom autograd Functions by subclassing - torch.autograd.Function and implementing the forward and backward passes - which operate on Tensors. - """ - - @staticmethod - def forward(ctx, input): - """ - In the forward pass we receive a Tensor containing the input and return - a Tensor containing the output. ctx is a context object that can be used - to stash information for backward computation. You can cache arbitrary - objects for use in the backward pass using the ctx.save_for_backward method. - """ - ctx.save_for_backward(input) - return 0.5 * (5 * input ** 3 - 3 * input) - - @staticmethod - def backward(ctx, grad_output): - """ - In the backward pass we receive a Tensor containing the gradient of the loss - with respect to the output, and we need to compute the gradient of the loss - with respect to the input. - """ - input, = ctx.saved_tensors - return grad_output * 1.5 * (5 * input ** 2 - 1) - -dtype = torch.float -device = torch.device("cpu") -# device = torch.device("cuda:0") # Uncomment this to run on GPU - -# Create Tensors to hold input and outputs. -# By default, requires_grad=False, which indicates that we do not need to -# compute gradients with respect to these Tensors during the backward pass. -x = torch.linspace(-math.pi, math.pi, 2000, device=device, dtype=dtype) -y = torch.sin(x) - -# Create random Tensors for weights. For this example, we need -# 4 weights: y = a + b * P3(c + d * x), these weights need to be initialized -# not too far from the correct result to ensure convergence. -# Setting requires_grad=True indicates that we want to compute gradients with -# respect to these Tensors during the backward pass. -a = torch.full((), 0.0, device=device, dtype=dtype, requires_grad=True) -b = torch.full((), -1.0, device=device, dtype=dtype, requires_grad=True) -c = torch.full((), 0.0, device=device, dtype=dtype, requires_grad=True) -d = torch.full((), 0.3, device=device, dtype=dtype, requires_grad=True) - -learning_rate = 5e-6 -for t in range(2000): - # To apply our Function, we use Function.apply method. We alias this as 'P3'. - P3 = LegendrePolynomial3.apply - - # Forward pass: compute predicted y using operations; we compute - # P3 using our custom autograd operation. - y_pred = a + b * P3(c + d * x) - - # Compute and print loss - loss = (y_pred - y).pow(2).sum() - if t % 100 == 99: - print(t, loss.item()) - - # Use autograd to compute the backward pass. - loss.backward() - - # Update weights using gradient descent - with torch.no_grad(): - a -= learning_rate * a.grad - b -= learning_rate * b.grad - c -= learning_rate * c.grad - d -= learning_rate * d.grad - - # Manually zero the gradients after updating weights - a.grad = None - b.grad = None - c.grad = None - d.grad = None - -print(f'Result: y = {a.item()} + {b.item()} * P3({c.item()} + {d.item()} x)') - -``` - -**脚本的总运行时间**：（0 分钟 0.000 秒） - -[下载 Python 源码：`polynomial_custom_function.py`](https://pytorch.org/tutorials/_downloads/b7ec15fd7bec1ca3f921104cfb6a54ed/polynomial_custom_function.py) - -[下载 Jupyter 笔记本：`polynomial_custom_function.ipynb`](https://pytorch.org/tutorials/_downloads/0a64809624bf2f3eb497d30d5303a9a0/polynomial_custom_function.ipynb) - -[由 Sphinx 画廊](https://sphinx-gallery.readthedocs.io)生成的画廊 \ No newline at end of file diff --git a/pytorch/官方教程/12.md b/pytorch/官方教程/12.md deleted file mode 100644 index 9dc0b70d..00000000 --- a/pytorch/官方教程/12.md +++ /dev/null @@ -1,87 +0,0 @@ -# PyTorch：`nn` - -> 原文： - -经过训练的三阶多项式，可以通过最小化平方的欧几里得距离来预测`y = sin(x)`从`-pi`到`pi`。 - -此实现使用来自 PyTorch 的`nn`包来构建网络。 PyTorch Autograd 使定义计算图和获取梯度变得容易，但是原始的 Autograd 对于定义复杂的神经网络来说可能太低了。 这是`nn`包可以提供帮助的地方。 `nn`包定义了一组模块，您可以将其视为神经网络层，该神经网络层从输入产生输出并且可能具有一些可训练的权重。 - -```py -import torch -import math - -# Create Tensors to hold input and outputs. -x = torch.linspace(-math.pi, math.pi, 2000) -y = torch.sin(x) - -# For this example, the output y is a linear function of (x, x^2, x^3), so -# we can consider it as a linear layer neural network. Let's prepare the -# tensor (x, x^2, x^3). -p = torch.tensor([1, 2, 3]) -xx = x.unsqueeze(-1).pow(p) - -# In the above code, x.unsqueeze(-1) has shape (2000, 1), and p has shape -# (3,), for this case, broadcasting semantics will apply to obtain a tensor -# of shape (2000, 3) - -# Use the nn package to define our model as a sequence of layers. nn.Sequential -# is a Module which contains other Modules, and applies them in sequence to -# produce its output. The Linear Module computes output from input using a -# linear function, and holds internal Tensors for its weight and bias. -# The Flatten layer flatens the output of the linear layer to a 1D tensor, -# to match the shape of `y`. -model = torch.nn.Sequential( - torch.nn.Linear(3, 1), - torch.nn.Flatten(0, 1) -) - -# The nn package also contains definitions of popular loss functions; in this -# case we will use Mean Squared Error (MSE) as our loss function. -loss_fn = torch.nn.MSELoss(reduction='sum') - -learning_rate = 1e-6 -for t in range(2000): - - # Forward pass: compute predicted y by passing x to the model. Module objects - # override the __call__ operator so you can call them like functions. When - # doing so you pass a Tensor of input data to the Module and it produces - # a Tensor of output data. - y_pred = model(xx) - - # Compute and print loss. We pass Tensors containing the predicted and true - # values of y, and the loss function returns a Tensor containing the - # loss. - loss = loss_fn(y_pred, y) - if t % 100 == 99: - print(t, loss.item()) - - # Zero the gradients before running the backward pass. - model.zero_grad() - - # Backward pass: compute gradient of the loss with respect to all the learnable - # parameters of the model. Internally, the parameters of each Module are stored - # in Tensors with requires_grad=True, so this call will compute gradients for - # all learnable parameters in the model. - loss.backward() - - # Update the weights using gradient descent. Each parameter is a Tensor, so - # we can access its gradients like we did before. - with torch.no_grad(): - for param in model.parameters(): - param -= learning_rate * param.grad - -# You can access the first layer of `model` like accessing the first item of a list -linear_layer = model[0] - -# For linear layer, its parameters are stored as `weight` and `bias`. -print(f'Result: y = {linear_layer.bias.item()} + {linear_layer.weight[:, 0].item()} x + {linear_layer.weight[:, 1].item()} x^2 + {linear_layer.weight[:, 2].item()} x^3') - -``` - -**脚本的总运行时间**：（0 分钟 0.000 秒） - -[下载 Python 源码：`polynomial_nn.py`](https://pytorch.org/tutorials/_downloads/b4767df4367deade63dc8a0d3712c1d4/polynomial_nn.py) - -[下载 Jupyter 笔记本：`polynomial_nn.ipynb`](https://pytorch.org/tutorials/_downloads/7bc167d8b8308ae65a717d7461d838fa/polynomial_nn.ipynb) - -[由 Sphinx 画廊](https://sphinx-gallery.readthedocs.io)生成的画廊 \ No newline at end of file diff --git a/pytorch/官方教程/13.md b/pytorch/官方教程/13.md deleted file mode 100644 index ac2d8a92..00000000 --- a/pytorch/官方教程/13.md +++ /dev/null @@ -1,71 +0,0 @@ -# PyTorch：`optim` - -> 原文： - -经过训练的三阶多项式，可以通过最小化平方的欧几里得距离来预测`y = sin(x)`从`-pi`到`pi`。 - -此实现使用来自 PyTorch 的`nn`包来构建网络。 - -与其像以前那样手动更新模型的权重，不如使用`optim`包定义一个优化器，该优化器将为我们更新权重。 `optim`包定义了许多深度学习常用的优化算法，包括 SGD + 动量，RMSProp，Adam 等。 - -```py -import torch -import math - -# Create Tensors to hold input and outputs. -x = torch.linspace(-math.pi, math.pi, 2000) -y = torch.sin(x) - -# Prepare the input tensor (x, x^2, x^3). -p = torch.tensor([1, 2, 3]) -xx = x.unsqueeze(-1).pow(p) - -# Use the nn package to define our model and loss function. -model = torch.nn.Sequential( - torch.nn.Linear(3, 1), - torch.nn.Flatten(0, 1) -) -loss_fn = torch.nn.MSELoss(reduction='sum') - -# Use the optim package to define an Optimizer that will update the weights of -# the model for us. Here we will use RMSprop; the optim package contains many other -# optimization algorithms. The first argument to the RMSprop constructor tells the -# optimizer which Tensors it should update. -learning_rate = 1e-3 -optimizer = torch.optim.RMSprop(model.parameters(), lr=learning_rate) -for t in range(2000): - # Forward pass: compute predicted y by passing x to the model. - y_pred = model(xx) - - # Compute and print loss. - loss = loss_fn(y_pred, y) - if t % 100 == 99: - print(t, loss.item()) - - # Before the backward pass, use the optimizer object to zero all of the - # gradients for the variables it will update (which are the learnable - # weights of the model). This is because by default, gradients are - # accumulated in buffers( i.e, not overwritten) whenever .backward() - # is called. Checkout docs of torch.autograd.backward for more details. - optimizer.zero_grad() - - # Backward pass: compute gradient of the loss with respect to model - # parameters - loss.backward() - - # Calling the step function on an Optimizer makes an update to its - # parameters - optimizer.step() - -linear_layer = model[0] -print(f'Result: y = {linear_layer.bias.item()} + {linear_layer.weight[:, 0].item()} x + {linear_layer.weight[:, 1].item()} x^2 + {linear_layer.weight[:, 2].item()} x^3') - -``` - -**脚本的总运行时间**：（0 分钟 0.000 秒） - -[下载 Python 源码：`polynomial_optim.py`](https://pytorch.org/tutorials/_downloads/bcfec6f02e0fe747a42dbd1579267469/polynomial_optim.py) - -[下载 Jupyter 笔记本：`polynomial_optim.ipynb`](https://pytorch.org/tutorials/_downloads/8ef669b2c61c6c5aa47c54dceac4979e/polynomial_optim.ipynb) - -[由 Sphinx 画廊](https://sphinx-gallery.readthedocs.io)生成的画廊 \ No newline at end of file diff --git a/pytorch/官方教程/14.md b/pytorch/官方教程/14.md deleted file mode 100644 index 619ffac4..00000000 --- a/pytorch/官方教程/14.md +++ /dev/null @@ -1,75 +0,0 @@ -# PyTorch：自定义`nn`模块 - -> 原文： - -经过训练的三阶多项式，可以通过最小化平方的欧几里得距离来预测`y = sin(x)`从`-pi`到`pi`。 - -此实现将模型定义为自定义`Module`子类。 每当您想要一个比现有模块的简单序列更复杂的模型时，都需要以这种方式定义模型。 - -```py -import torch -import math - -class Polynomial3(torch.nn.Module): - def __init__(self): - """ - In the constructor we instantiate four parameters and assign them as - member parameters. - """ - super().__init__() - self.a = torch.nn.Parameter(torch.randn(())) - self.b = torch.nn.Parameter(torch.randn(())) - self.c = torch.nn.Parameter(torch.randn(())) - self.d = torch.nn.Parameter(torch.randn(())) - - def forward(self, x): - """ - In the forward function we accept a Tensor of input data and we must return - a Tensor of output data. We can use Modules defined in the constructor as - well as arbitrary operators on Tensors. - """ - return self.a + self.b * x + self.c * x ** 2 + self.d * x ** 3 - - def string(self): - """ - Just like any class in Python, you can also define custom method on PyTorch modules - """ - return f'y = {self.a.item()} + {self.b.item()} x + {self.c.item()} x^2 + {self.d.item()} x^3' - -# Create Tensors to hold input and outputs. -x = torch.linspace(-math.pi, math.pi, 2000) -y = torch.sin(x) - -# Construct our model by instantiating the class defined above -model = Polynomial3() - -# Construct our loss function and an Optimizer. The call to model.parameters() -# in the SGD constructor will contain the learnable parameters of the nn.Linear -# module which is members of the model. -criterion = torch.nn.MSELoss(reduction='sum') -optimizer = torch.optim.SGD(model.parameters(), lr=1e-6) -for t in range(2000): - # Forward pass: Compute predicted y by passing x to the model - y_pred = model(x) - - # Compute and print loss - loss = criterion(y_pred, y) - if t % 100 == 99: - print(t, loss.item()) - - # Zero gradients, perform a backward pass, and update the weights. - optimizer.zero_grad() - loss.backward() - optimizer.step() - -print(f'Result: {model.string()}') - -``` - -**脚本的总运行时间**：（0 分钟 0.000 秒） - -[下载 Python 源码：`polynomial_module.py`](https://pytorch.org/tutorials/_downloads/916a9c460c899330dbc53216cc775358/polynomial_module.py) - -[下载 Jupyter 笔记本：`polynomial_module.ipynb`](https://pytorch.org/tutorials/_downloads/19f4ecdd2763dd4b90693df4d6e10ebe/polynomial_module.ipynb) - -[由 Sphinx 画廊](https://sphinx-gallery.readthedocs.io)生成的画廊 \ No newline at end of file diff --git a/pytorch/官方教程/15.md b/pytorch/官方教程/15.md deleted file mode 100644 index 50fb29a1..00000000 --- a/pytorch/官方教程/15.md +++ /dev/null @@ -1,82 +0,0 @@ -# PyTorch：控制流 + 权重共享 - -> 原文： - -为了展示 PyTorch 动态图的强大功能，我们将实现一个非常奇怪的模型：一个三阶多项式，在每个正向传播中选择 3 到 5 之间的一个随机数，并使用该数量的阶次，多次使用相同的权重重复计算四和五阶。 - -```py -import random -import torch -import math - -class DynamicNet(torch.nn.Module): - def __init__(self): - """ - In the constructor we instantiate five parameters and assign them as members. - """ - super().__init__() - self.a = torch.nn.Parameter(torch.randn(())) - self.b = torch.nn.Parameter(torch.randn(())) - self.c = torch.nn.Parameter(torch.randn(())) - self.d = torch.nn.Parameter(torch.randn(())) - self.e = torch.nn.Parameter(torch.randn(())) - - def forward(self, x): - """ - For the forward pass of the model, we randomly choose either 4, 5 - and reuse the e parameter to compute the contribution of these orders. - - Since each forward pass builds a dynamic computation graph, we can use normal - Python control-flow operators like loops or conditional statements when - defining the forward pass of the model. - - Here we also see that it is perfectly safe to reuse the same parameter many - times when defining a computational graph. - """ - y = self.a + self.b * x + self.c * x ** 2 + self.d * x ** 3 - for exp in range(4, random.randint(4, 6)): - y = y + self.e * x ** exp - return y - - def string(self): - """ - Just like any class in Python, you can also define custom method on PyTorch modules - """ - return f'y = {self.a.item()} + {self.b.item()} x + {self.c.item()} x^2 + {self.d.item()} x^3 + {self.e.item()} x^4 ? + {self.e.item()} x^5 ?' - -# Create Tensors to hold input and outputs. -x = torch.linspace(-math.pi, math.pi, 2000) -y = torch.sin(x) - -# Construct our model by instantiating the class defined above -model = DynamicNet() - -# Construct our loss function and an Optimizer. Training this strange model with -# vanilla stochastic gradient descent is tough, so we use momentum -criterion = torch.nn.MSELoss(reduction='sum') -optimizer = torch.optim.SGD(model.parameters(), lr=1e-8, momentum=0.9) -for t in range(30000): - # Forward pass: Compute predicted y by passing x to the model - y_pred = model(x) - - # Compute and print loss - loss = criterion(y_pred, y) - if t % 2000 == 1999: - print(t, loss.item()) - - # Zero gradients, perform a backward pass, and update the weights. - optimizer.zero_grad() - loss.backward() - optimizer.step() - -print(f'Result: {model.string()}') - -``` - -**脚本的总运行时间**：（0 分钟 0.000 秒） - -[下载 Python 源码：`dynamic_net.py`](https://pytorch.org/tutorials/_downloads/3900c903cde097dc0088c3b06d588c0b/dynamic_net.py) - -[下载 Jupyter 笔记本：`dynamic_net.ipynb`](https://pytorch.org/tutorials/_downloads/ad230923bd9eb0d42576725b63ad8d91/dynamic_net.ipynb) - -[由 Sphinx 画廊](https://sphinx-gallery.readthedocs.io)生成的画廊 \ No newline at end of file diff --git a/pytorch/官方教程/16.md b/pytorch/官方教程/16.md deleted file mode 100644 index e6867d85..00000000 --- a/pytorch/官方教程/16.md +++ /dev/null @@ -1,971 +0,0 @@ -# `torch.nn`到底是什么？ - -> 原文： - -作者：Jeremy Howard，[fast.ai](https://www.fast.ai)。 感谢 Rachel Thomas 和 Francisco Ingham。 - -我们建议将本教程作为笔记本而不是脚本来运行。 要下载笔记本（`.ipynb`）文件，请单击页面顶部的链接。 - -PyTorch 提供设计精美的模块和类[`torch.nn`](https://pytorch.org/docs/stable/nn.html)，[`torch.optim`](https://pytorch.org/docs/stable/optim.html)，[`Dataset`](https://pytorch.org/docs/stable/data.html?highlight=dataset#torch.utils.data.Dataset)和[`DataLoader`](https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader)神经网络。 为了充分利用它们的功能并针对您的问题对其进行自定义，您需要真正了解它们在做什么。 为了建立这种理解，我们将首先在 MNIST 数据集上训练基本神经网络，而无需使用这些模型的任何功能。 我们最初将仅使用最基本的 PyTorch 张量函数。 然后，我们将一次从`torch.nn`，`torch.optim`，`Dataset`或`DataLoader`中逐个添加一个函数，以准确显示每个函数，以及如何使代码更简洁或更有效。 灵活。 - -**本教程假定您已经安装了 PyTorch，并且熟悉张量操作的基础知识。** （如果您熟悉 Numpy 数组操作，将会发现此处使用的 PyTorch 张量操作几乎相同）。 - -## MNIST 数据集 - -我们将使用经典的 [MNIST](http://deeplearning.net/data/mnist/) 数据集，该数据集由手绘数字的黑白图像组成（0 到 9 之间）。 - -我们将使用[`pathlib`](https://docs.python.org/3/library/pathlib.html)处理路径（Python 3 标准库的一部分），并使用[`requests`](http://docs.python-requests.org/en/master/)下载数据集。 我们只会在使用模块时才导入它们，因此您可以确切地看到每个位置上正在使用的模块。 - -```py -from pathlib import Path -import requests - -DATA_PATH = Path("data") -PATH = DATA_PATH / "mnist" - -PATH.mkdir(parents=True, exist_ok=True) - -URL = "https://github.com/pytorch/tutorials/raw/master/_static/" -FILENAME = "mnist.pkl.gz" - -if not (PATH / FILENAME).exists(): - content = requests.get(URL + FILENAME).content - (PATH / FILENAME).open("wb").write(content) - -``` - -该数据集为 numpy 数组格式，并已使用`pickle`（一种用于序列化数据的 python 特定格式）存储。 - -```py -import pickle -import gzip - -with gzip.open((PATH / FILENAME).as_posix(), "rb") as f: - ((x_train, y_train), (x_valid, y_valid), _) = pickle.load(f, encoding="latin-1") - -``` - -每个图像为`28 x 28`，并存储为长度为`784 = 28x28`的扁平行。 让我们来看一个； 我们需要先将其重塑为 2d。 - -```py -from matplotlib import pyplot -import numpy as np - -pyplot.imshow(x_train[0].reshape((28, 28)), cmap="gray") -print(x_train.shape) - -``` - -![../_img/sphx_glr_nn_tutorial_001.png](img/7c783def0bbe536f41ed172041b7e89e.png) - -出： - -```py -(50000, 784) - -``` - -PyTorch 使用`torch.tensor`而不是 numpy 数组，因此我们需要转换数据。 - -```py -import torch - -x_train, y_train, x_valid, y_valid = map( - torch.tensor, (x_train, y_train, x_valid, y_valid) -) -n, c = x_train.shape -x_train, x_train.shape, y_train.min(), y_train.max() -print(x_train, y_train) -print(x_train.shape) -print(y_train.min(), y_train.max()) - -``` - -出： - -```py -tensor([[0., 0., 0., ..., 0., 0., 0.], - [0., 0., 0., ..., 0., 0., 0.], - [0., 0., 0., ..., 0., 0., 0.], - ..., - [0., 0., 0., ..., 0., 0., 0.], - [0., 0., 0., ..., 0., 0., 0.], - [0., 0., 0., ..., 0., 0., 0.]]) tensor([5, 0, 4, ..., 8, 4, 8]) -torch.Size([50000, 784]) -tensor(0) tensor(9) - -``` - -## 从零开始的神经网络（没有`torch.nn`） - -首先，我们仅使用 PyTorch 张量操作创建模型。 我们假设您已经熟悉神经网络的基础知识。 （如果不是，则可以在 [course.fast.ai](https://course.fast.ai) 中学习它们）。 - -PyTorch 提供了创建随机或零填充张量的方法，我们将使用它们来为简单的线性模型创建权重和偏差。 这些只是常规张量，还有一个非常特殊的附加值：我们告诉 PyTorch 它们需要梯度。 这使 PyTorch 记录了在张量上完成的所有操作，因此它可以在反向传播时*自动计算*的梯度！ - -**对于权重，我们在初始化之后设置`requires_grad`，因为我们不希望该步骤包含在梯度中。 （请注意，PyTorch 中的尾随`_`表示该操作是原地执行的。）** - -注意 - -我们在这里用 [Xavier 初始化](http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf)（通过乘以`1 / sqrt(n)`）来初始化权重。 - -```py -import math - -weights = torch.randn(784, 10) / math.sqrt(784) -weights.requires_grad_() -bias = torch.zeros(10, requires_grad=True) - -``` - -由于 PyTorch 具有自动计算梯度的功能，我们可以将任何标准的 Python 函数（或可调用对象）用作模型！ 因此，我们只需编写一个普通矩阵乘法和广播加法即可创建一个简单的线性模型。 我们还需要激活函数，因此我们将编写并使用`log_softmax`。 请记住：尽管 PyTorch 提供了许多预写的损失函数，激活函数等，但是您可以使用纯 Python 轻松编写自己的函数。 PyTorch 甚至会自动为您的函数创建快速 GPU 或向量化的 CPU 代码。 - -```py -def log_softmax(x): - return x - x.exp().sum(-1).log().unsqueeze(-1) - -def model(xb): - return log_softmax(xb @ weights + bias) - -``` - -在上面，`@`代表点积运算。 我们将对一批数据（在本例中为 64 张图像）调用函数。 这是一个*正向传播*。 请注意，由于我们从随机权重开始，因此在这一阶段，我们的预测不会比随机预测更好。 - -```py -bs = 64 # batch size - -xb = x_train[0:bs] # a mini-batch from x -preds = model(xb) # predictions -preds[0], preds.shape -print(preds[0], preds.shape) - -``` - -出： - -```py -tensor([-2.5964, -2.3153, -2.1321, -2.4480, -2.2930, -1.9507, -2.1289, -2.4175, - -2.5332, -2.3967], grad_fn=) torch.Size([64, 10]) - -``` - -如您所见，`preds`张量不仅包含张量值，还包含梯度函数。 稍后我们将使用它进行反向传播。 - -让我们实现负对数可能性作为损失函数（同样，我们只能使用标准 Python）： - -```py -def nll(input, target): - return -input[range(target.shape[0]), target].mean() - -loss_func = nll - -``` - -让我们使用随机模型来检查损失，以便我们稍后查看反向传播后是否可以改善我们的损失。 - -```py -yb = y_train[0:bs] -print(loss_func(preds, yb)) - -``` - -出： - -```py -tensor(2.3735, grad_fn=) - -``` - -我们还实现一个函数来计算模型的准确率。 对于每个预测，如果具有最大值的索引与目标值匹配，则该预测是正确的。 - -```py -def accuracy(out, yb): - preds = torch.argmax(out, dim=1) - return (preds == yb).float().mean() - -``` - -让我们检查一下随机模型的准确率，以便我们可以看出随着损失的增加，准确率是否有所提高。 - -```py -print(accuracy(preds, yb)) - -``` - -出： - -```py -tensor(0.0938) - -``` - -现在，我们可以运行一个训练循环。 对于每次迭代，我们将： - -* 选择一个小批量数据（大小为`bs`） -* 使用模型进行预测 -* 计算损失 -* `loss.backward()`更新模型的梯度，在这种情况下为`weights`和`bias`。 - -现在，我们使用这些梯度来更新权重和偏差。 我们在`torch.no_grad()`上下文管理器中执行此操作，因为我们不希望在下一步的梯度计算中记录这些操作。 [您可以在这里阅读有关 PyTorch 的 Autograd 如何记录操作的更多信息](https://pytorch.org/docs/stable/notes/autograd.html)。 - -然后，将梯度设置为零，以便为下一个循环做好准备。 否则，我们的梯度会记录所有已发生操作的运行记录（即`loss.backward()`将梯度添加到已存储的内容中，而不是替换它们）。 - -小费 - -您可以使用标准的 python 调试器逐步浏览 PyTorch 代码，从而可以在每一步检查各种变量值。 取消注释以下`set_trace()`即可尝试。 - -```py -from IPython.core.debugger import set_trace - -lr = 0.5 # learning rate -epochs = 2 # how many epochs to train for - -for epoch in range(epochs): - for i in range((n - 1) // bs + 1): - # set_trace() - start_i = i * bs - end_i = start_i + bs - xb = x_train[start_i:end_i] - yb = y_train[start_i:end_i] - pred = model(xb) - loss = loss_func(pred, yb) - - loss.backward() - with torch.no_grad(): - weights -= weights.grad * lr - bias -= bias.grad * lr - weights.grad.zero_() - bias.grad.zero_() - -``` - -就是这样：我们完全从头开始创建并训练了一个最小的神经网络（在这种情况下，是逻辑回归，因为我们没有隐藏的层）！ - -让我们检查损失和准确率，并将其与我们之前获得的进行比较。 我们希望损失会减少，准确率会增加，而且确实如此。 - -```py -print(loss_func(model(xb), yb), accuracy(model(xb), yb)) - -``` - -出： - -```py -tensor(0.0811, grad_fn=) tensor(1.) - -``` - -## 使用`torch.nn.functional` - -现在，我们将重构代码，使其执行与以前相同的操作，只是我们将开始利用 PyTorch 的`nn`类使其更加简洁和灵活。 从这里开始的每一步，我们都应该使代码中的一个或多个：更短，更易理解和/或更灵活。 - -第一步也是最简单的步骤，就是用`torch.nn.functional`（通常按照惯例将其导入到名称空间`F`中）替换我们的手写激活和损失函数，从而缩短代码长度。 该模块包含`torch.nn`库中的所有函数（而该库的其他部分包含类）。 除了广泛的损失和激活函数外，您还会在这里找到一些方便的函数来创建神经网络，例如合并函数。 （还有一些用于进行卷积，线性层等的函数，但是正如我们将看到的那样，通常可以使用库的其他部分来更好地处理这些函数。） - -如果您使用的是负对数似然损失和对数 softmax 激活，那么 Pytorch 会提供结合了两者的单一函数`F.cross_entropy`。 因此，我们甚至可以从模型中删除激活函数。 - -```py -import torch.nn.functional as F - -loss_func = F.cross_entropy - -def model(xb): - return xb @ weights + bias - -``` - -请注意，我们不再在`model`函数中调用`log_softmax`。 让我们确认我们的损失和准确率与以前相同： - -```py -print(loss_func(model(xb), yb), accuracy(model(xb), yb)) - -``` - -出： - -```py -tensor(0.0811, grad_fn=) tensor(1.) - -``` - -## 使用`nn.Module`重构 - -接下来，我们将使用`nn.Module`和`nn.Parameter`进行更清晰，更简洁的训练循环。 我们将`nn.Module`子类化（它本身是一个类并且能够跟踪状态）。 在这种情况下，我们要创建一个类，该类包含前进步骤的权重，偏置和方法。 `nn.Module`具有许多我们将要使用的属性和方法（例如`.parameters()`和`.zero_grad()`）。 - -注意 - -`nn.Module`（大写`M`）是 PyTorch 的特定概念，并且是我们将经常使用的一类。 不要将`nn.Module`与[模块](https://docs.python.org/3/tutorial/modules.html)（小写`m`）的 Python 概念混淆，该模块是可以导入的 Python 代码文件。 - -```py -from torch import nn - -class Mnist_Logistic(nn.Module): - def __init__(self): - super().__init__() - self.weights = nn.Parameter(torch.randn(784, 10) / math.sqrt(784)) - self.bias = nn.Parameter(torch.zeros(10)) - - def forward(self, xb): - return xb @ self.weights + self.bias - -``` - -由于我们现在使用的是对象而不是仅使用函数，因此我们首先必须实例化模型： - -```py -model = Mnist_Logistic() - -``` - -现在我们可以像以前一样计算损失。 请注意，`nn.Module`对象的使用就好像它们是函数一样（即，它们是*可调用的*），但是在后台 Pytorch 会自动调用我们的`forward`方法。 - -```py -print(loss_func(model(xb), yb)) - -``` - -出： - -```py -tensor(2.3903, grad_fn=) - -``` - -以前，在我们的训练循环中，我们必须按名称更新每个参数的值，并手动将每个参数的梯度分别归零，如下所示： - -```py -with torch.no_grad(): - weights -= weights.grad * lr - bias -= bias.grad * lr - weights.grad.zero_() - bias.grad.zero_() - -``` - -现在我们可以利用`model.parameters()`和`model.zero_grad()`（它们都由 PyTorch 为`nn.Module`定义）来使这些步骤更简洁，并且更不会出现忘记某些参数的错误，尤其是当我们有一个更复杂的模型的时候： - -```py -with torch.no_grad(): - for p in model.parameters(): p -= p.grad * lr - model.zero_grad() - -``` - -我们将把小的训练循环包装在`fit`函数中，以便稍后再运行。 - -```py -def fit(): - for epoch in range(epochs): - for i in range((n - 1) // bs + 1): - start_i = i * bs - end_i = start_i + bs - xb = x_train[start_i:end_i] - yb = y_train[start_i:end_i] - pred = model(xb) - loss = loss_func(pred, yb) - - loss.backward() - with torch.no_grad(): - for p in model.parameters(): - p -= p.grad * lr - model.zero_grad() - -fit() - -``` - -让我们仔细检查一下我们的损失是否减少了： - -```py -print(loss_func(model(xb), yb)) - -``` - -出： - -```py -tensor(0.0808, grad_fn=) - -``` - -## 使用`nn.Linear`重构 - -我们继续重构我们的代码。 代替手动定义和初始化`self.weights`和`self.bias`并计算`xb  @ self.weights + self.bias`，我们将对线性层使用 Pytorch 类[`nn.Linear`](https://pytorch.org/docs/stable/nn.html#linear-layers)，这将为我们完成所有工作。 Pytorch 具有许多类型的预定义层，可以大大简化我们的代码，并且通常也可以使其速度更快。 - -```py -class Mnist_Logistic(nn.Module): - def __init__(self): - super().__init__() - self.lin = nn.Linear(784, 10) - - def forward(self, xb): - return self.lin(xb) - -``` - -我们以与以前相同的方式实例化模型并计算损失： - -```py -model = Mnist_Logistic() -print(loss_func(model(xb), yb)) - -``` - -出： - -```py -tensor(2.4215, grad_fn=) - -``` - -我们仍然可以使用与以前相同的`fit`方法。 - -```py -fit() - -print(loss_func(model(xb), yb)) - -``` - -出： - -```py -tensor(0.0824, grad_fn=) - -``` - -## 使用`optim`重构 - -Pytorch 还提供了一个包含各种优化算法的包`torch.optim`。 我们可以使用优化器中的`step`方法采取向前的步骤，而不是手动更新每个参数。 - -这将使我们替换之前的手动编码优化步骤： - -```py -with torch.no_grad(): - for p in model.parameters(): p -= p.grad * lr - model.zero_grad() - -``` - -而是只使用： - -```py -opt.step() -opt.zero_grad() - -``` - -（`optim.zero_grad()`将梯度重置为 0，我们需要在计算下一个小批量的梯度之前调用它。） - -```py -from torch import optim - -``` - -我们将定义一个小函数来创建模型和优化器，以便将来重用。 - -```py -def get_model(): - model = Mnist_Logistic() - return model, optim.SGD(model.parameters(), lr=lr) - -model, opt = get_model() -print(loss_func(model(xb), yb)) - -for epoch in range(epochs): - for i in range((n - 1) // bs + 1): - start_i = i * bs - end_i = start_i + bs - xb = x_train[start_i:end_i] - yb = y_train[start_i:end_i] - pred = model(xb) - loss = loss_func(pred, yb) - - loss.backward() - opt.step() - opt.zero_grad() - -print(loss_func(model(xb), yb)) - -``` - -出： - -```py -tensor(2.2999, grad_fn=) -tensor(0.0823, grad_fn=) - -``` - -## 使用`Dataset`重构 - -PyTorch 有一个抽象的`Dataset`类。 数据集可以是具有`__len__`函数（由 Python 的标准`len`函数调用）和具有`__getitem__`函数作为对其进行索引的一种方法。 [本教程](https://pytorch.org/tutorials/beginner/data_loading_tutorial.html)演示了一个不错的示例，该示例创建一个自定义`FacialLandmarkDataset`类作为`Dataset`的子类。 - -PyTorch 的[`TensorDataset`](https://pytorch.org/docs/stable/_modules/torch/utils/data/dataset.html#TensorDataset)是一个数据集包装张量。 通过定义索引的长度和方式，这也为我们提供了沿张量的第一维进行迭代，索引和切片的方法。 这将使我们在训练的同一行中更容易访问自变量和因变量。 - -```py -from torch.utils.data import TensorDataset - -``` - -`x_train`和`y_train`都可以合并为一个`TensorDataset`，这将更易于迭代和切片。 - -```py -train_ds = TensorDataset(x_train, y_train) - -``` - -以前，我们不得不分别遍历`x`和`y`值的小批量： - -```py -xb = x_train[start_i:end_i] -yb = y_train[start_i:end_i] - -``` - -现在，我们可以一起执行以下两个步骤： - -```py -xb,yb = train_ds[i*bs : i*bs+bs] - -``` - -```py -model, opt = get_model() - -for epoch in range(epochs): - for i in range((n - 1) // bs + 1): - xb, yb = train_ds[i * bs: i * bs + bs] - pred = model(xb) - loss = loss_func(pred, yb) - - loss.backward() - opt.step() - opt.zero_grad() - -print(loss_func(model(xb), yb)) - -``` - -出： - -```py -tensor(0.0819, grad_fn=) - -``` - -## 使用`DataLoader`重构 - -Pytorch 的`DataLoader`负责批量管理。 您可以从任何`Dataset`创建一个`DataLoader`。 `DataLoader`使迭代迭代变得更加容易。 不必使用`train_ds[i*bs : i*bs+bs]`，`DataLoader`会自动为我们提供每个小批量。 - -```py -from torch.utils.data import DataLoader - -train_ds = TensorDataset(x_train, y_train) -train_dl = DataLoader(train_ds, batch_size=bs) - -``` - -以前，我们的循环遍历如下批量`(xb, yb)`： - -```py -for i in range((n-1)//bs + 1): - xb,yb = train_ds[i*bs : i*bs+bs] - pred = model(xb) - -``` - -现在，我们的循环更加简洁了，因为`(xb, yb)`是从数据加载器自动加载的： - -```py -for xb,yb in train_dl: - pred = model(xb) - -``` - -```py -model, opt = get_model() - -for epoch in range(epochs): - for xb, yb in train_dl: - pred = model(xb) - loss = loss_func(pred, yb) - - loss.backward() - opt.step() - opt.zero_grad() - -print(loss_func(model(xb), yb)) - -``` - -出： - -```py -tensor(0.0821, grad_fn=) - -``` - -得益于 Pytorch 的`nn.Module`，`nn.Parameter`，`Dataset`和`DataLoader`，我们的训练循环现在变得更小，更容易理解。 现在，让我们尝试添加在实践中创建有效模型所需的基本功能。 - -## 添加验证 - -在第 1 节中，我们只是试图建立一个合理的训练循环以用于我们的训练数据。 实际上，您也应该**始终**具有[验证集](https://www.fast.ai/2017/11/13/validation-sets/)，以便识别您是否过拟合。 - -[对训练数据进行打乱](https://www.quora.com/Does-the-order-of-training-data-matter-when-training-neural-networks)对于防止批量与过拟合之间的相关性很重要。 另一方面，无论我们是否打乱验证集，验证损失都是相同的。 由于打乱需要花费更多时间，因此打乱验证数据没有任何意义。 - -我们将验证集的批量大小设为训练集的两倍。 这是因为验证集不需要反向传播，因此占用的内存更少（不需要存储梯度）。 我们利用这一优势来使用更大的批量，并更快地计算损失。 - -```py -train_ds = TensorDataset(x_train, y_train) -train_dl = DataLoader(train_ds, batch_size=bs, shuffle=True) - -valid_ds = TensorDataset(x_valid, y_valid) -valid_dl = DataLoader(valid_ds, batch_size=bs * 2) - -``` - -我们将在每个周期结束时计算并打印验证损失。 - -（请注意，我们总是在训练之前调用`model.train()`，并在推理之前调用`model.eval()`，因为诸如`nn.BatchNorm2d`和`nn.Dropout`之类的层会使用它们，以确保这些不同阶段的行为正确。） - -```py -model, opt = get_model() - -for epoch in range(epochs): - model.train() - for xb, yb in train_dl: - pred = model(xb) - loss = loss_func(pred, yb) - - loss.backward() - opt.step() - opt.zero_grad() - - model.eval() - with torch.no_grad(): - valid_loss = sum(loss_func(model(xb), yb) for xb, yb in valid_dl) - - print(epoch, valid_loss / len(valid_dl)) - -``` - -出： - -```py -0 tensor(0.3743) -1 tensor(0.3316) - -``` - -## 创建`fit()`和`get_data()` - -现在，我们将自己进行一些重构。 由于我们经历了两次相似的过程来计算训练集和验证集的损失，因此我们将其设为自己的函数`loss_batch`，该函数可计算一批损失。 - -我们将优化器传入训练集中，然后使用它执行反向传播。 对于验证集，我们没有通过优化程序，因此该方法不会执行反向传播。 - -```py -def loss_batch(model, loss_func, xb, yb, opt=None): - loss = loss_func(model(xb), yb) - - if opt is not None: - loss.backward() - opt.step() - opt.zero_grad() - - return loss.item(), len(xb) - -``` - -`fit`运行必要的操作来训练我们的模型，并计算每个周期的训练和验证损失。 - -```py -import numpy as np - -def fit(epochs, model, loss_func, opt, train_dl, valid_dl): - for epoch in range(epochs): - model.train() - for xb, yb in train_dl: - loss_batch(model, loss_func, xb, yb, opt) - - model.eval() - with torch.no_grad(): - losses, nums = zip( - *[loss_batch(model, loss_func, xb, yb) for xb, yb in valid_dl] - ) - val_loss = np.sum(np.multiply(losses, nums)) / np.sum(nums) - - print(epoch, val_loss) - -``` - -`get_data`返回训练和验证集的数据加载器。 - -```py -def get_data(train_ds, valid_ds, bs): - return ( - DataLoader(train_ds, batch_size=bs, shuffle=True), - DataLoader(valid_ds, batch_size=bs * 2), - ) - -``` - -现在，我们获取数据加载器和拟合模型的整个过程可以在 3 行代码中运行： - -```py -train_dl, valid_dl = get_data(train_ds, valid_ds, bs) -model, opt = get_model() -fit(epochs, model, loss_func, opt, train_dl, valid_dl) - -``` - -出： - -```py -0 0.3120644524335861 -1 0.28915613491535186 - -``` - -您可以使用这些基本的 3 行代码来训练各种各样的模型。 让我们看看是否可以使用它们来训练卷积神经网络（CNN）！ - -## 切换到 CNN - -现在，我们将构建具有三个卷积层的神经网络。 由于上一节中的任何功能都不假设任何有关模型形式的信息，因此我们将能够使用它们来训练 CNN，而无需进行任何修改。 - -我们将使用 Pytorch 的预定义[`Conv2d`](https://pytorch.org/docs/stable/nn.html#torch.nn.Conv2d)类作为我们的卷积层。 我们定义了具有 3 个卷积层的 CNN。 每个卷积后跟一个 ReLU。 最后，我们执行平均池化。 （请注意，`view`是 numpy 的`reshape`的 PyTorch 版本） - -```py -class Mnist_CNN(nn.Module): - def __init__(self): - super().__init__() - self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=2, padding=1) - self.conv2 = nn.Conv2d(16, 16, kernel_size=3, stride=2, padding=1) - self.conv3 = nn.Conv2d(16, 10, kernel_size=3, stride=2, padding=1) - - def forward(self, xb): - xb = xb.view(-1, 1, 28, 28) - xb = F.relu(self.conv1(xb)) - xb = F.relu(self.conv2(xb)) - xb = F.relu(self.conv3(xb)) - xb = F.avg_pool2d(xb, 4) - return xb.view(-1, xb.size(1)) - -lr = 0.1 - -``` - -[动量](https://cs231n.github.io/neural-networks-3/#sgd)是随机梯度下降的一种变体，它也考虑了以前的更新，通常可以加快训练速度。 - -```py -model = Mnist_CNN() -opt = optim.SGD(model.parameters(), lr=lr, momentum=0.9) - -fit(epochs, model, loss_func, opt, train_dl, valid_dl) - -``` - -出： - -```py -0 0.32337012240886687 -1 0.25021172934770586 - -``` - -## `nn.Sequential` - -`torch.nn`还有另一个方便的类，可以用来简化我们的代码：[`Sequential`](https://pytorch.org/docs/stable/nn.html#torch.nn.Sequential)。 `Sequential`对象以顺序方式运行其中包含的每个模块。 这是编写神经网络的一种简单方法。 - -为了利用这一点，我们需要能够从给定的函数轻松定义**自定义层**。 例如，PyTorch 没有视层，我们需要为我们的网络创建一个层。 `Lambda`将创建一个层，然后在使用`Sequential`定义网络时可以使用该层。 - -```py -class Lambda(nn.Module): - def __init__(self, func): - super().__init__() - self.func = func - - def forward(self, x): - return self.func(x) - -def preprocess(x): - return x.view(-1, 1, 28, 28) - -``` - -用`Sequential`创建的模型很简单： - -```py -model = nn.Sequential( - Lambda(preprocess), - nn.Conv2d(1, 16, kernel_size=3, stride=2, padding=1), - nn.ReLU(), - nn.Conv2d(16, 16, kernel_size=3, stride=2, padding=1), - nn.ReLU(), - nn.Conv2d(16, 10, kernel_size=3, stride=2, padding=1), - nn.ReLU(), - nn.AvgPool2d(4), - Lambda(lambda x: x.view(x.size(0), -1)), -) - -opt = optim.SGD(model.parameters(), lr=lr, momentum=0.9) - -fit(epochs, model, loss_func, opt, train_dl, valid_dl) - -``` - -出： - -```py -0 0.30119081069231035 -1 0.25335356528759 - -``` - -## 包装`DataLoader` - -Our CNN is fairly concise, but it only works with MNIST, because: - -* 假设输入为`28 * 28`长向量 -* 假设 CNN 的最终网格尺寸为`4 * 4`（因为这是平均值 - -我们使用的合并核大小） - -让我们摆脱这两个假设，因此我们的模型适用于任何 2d 单通道图像。 首先，我们可以删除初始的 Lambda 层，但将数据预处理移至生成器中： - -```py -def preprocess(x, y): - return x.view(-1, 1, 28, 28), y - -class WrappedDataLoader: - def __init__(self, dl, func): - self.dl = dl - self.func = func - - def __len__(self): - return len(self.dl) - - def __iter__(self): - batches = iter(self.dl) - for b in batches: - yield (self.func(*b)) - -train_dl, valid_dl = get_data(train_ds, valid_ds, bs) -train_dl = WrappedDataLoader(train_dl, preprocess) -valid_dl = WrappedDataLoader(valid_dl, preprocess) - -``` - -接下来，我们可以将`nn.AvgPool2d`替换为`nn.AdaptiveAvgPool2d`，这使我们能够定义所需的*输出*张量的大小，而不是所需的*输入*张量的大小。 结果，我们的模型将适用于任何大小的输入。 - -```py -model = nn.Sequential( - nn.Conv2d(1, 16, kernel_size=3, stride=2, padding=1), - nn.ReLU(), - nn.Conv2d(16, 16, kernel_size=3, stride=2, padding=1), - nn.ReLU(), - nn.Conv2d(16, 10, kernel_size=3, stride=2, padding=1), - nn.ReLU(), - nn.AdaptiveAvgPool2d(1), - Lambda(lambda x: x.view(x.size(0), -1)), -) - -opt = optim.SGD(model.parameters(), lr=lr, momentum=0.9) - -``` - -试试看： - -```py -fit(epochs, model, loss_func, opt, train_dl, valid_dl) - -``` - -出： - -```py -0 0.327303307390213 -1 0.2181092014491558 - -``` - -## 使用您的 GPU - -如果您足够幸运地能够使用具有 CUDA 功能的 GPU（可以从大多数云提供商处以每小时 0.50 美元的价格租用一个），则可以使用它来加速代码。 首先检查您的 GPU 是否在 Pytorch 中正常工作： - -```py -print(torch.cuda.is_available()) - -``` - -出： - -```py -True - -``` - -然后为其创建一个设备对象： - -```py -dev = torch.device( - "cuda") if torch.cuda.is_available() else torch.device("cpu") - -``` - -让我们更新`preprocess`，将批量移至 GPU： - -```py -def preprocess(x, y): - return x.view(-1, 1, 28, 28).to(dev), y.to(dev) - -train_dl, valid_dl = get_data(train_ds, valid_ds, bs) -train_dl = WrappedDataLoader(train_dl, preprocess) -valid_dl = WrappedDataLoader(valid_dl, preprocess) - -``` - -最后，我们可以将模型移至 GPU。 - -```py -model.to(dev) -opt = optim.SGD(model.parameters(), lr=lr, momentum=0.9) - -``` - -您应该发现它现在运行得更快： - -```py -fit(epochs, model, loss_func, opt, train_dl, valid_dl) - -``` - -出： - -```py -0 0.1833980613708496 -1 0.17365939717292786 - -``` - -## 总结 - -现在，我们有了一个通用的数据管道和训练循环，您可以将其用于使用 Pytorch 训练许多类型的模型。 要了解现在可以轻松进行模型训练，请查看`mnist_sample`示例笔记本。 - -当然，您需要添加很多内容，例如数据扩充，超参数调整，监控训练，迁移学习等。 这些功能可在 fastai 库中使用，该库是使用本教程中所示的相同设计方法开发的，为希望进一步推广其模型的从业人员提供了自然的下一步。 - -我们承诺在本教程开始时将通过示例分别说明`torch.nn`，`torch.optim`，`Dataset`和`DataLoader`。 因此，让我们总结一下我们所看到的： - -> * `torch.nn` -> * `Module`：创建一个行为类似于函数的可调用对象，但也可以包含状态（例如神经网络层权重）。 它知道其中包含的 `Parameter` ，并且可以将其所有坡度归零，遍历它们以进行权重更新等。 -> * `Parameter`：张量的包装器，用于告知 `Module` 具有在反向传播期间需要更新的权重。 仅更新具有`require_grad`属性集的张量 -> * `functional`：一个模块（通常按照惯例导入到 `F` 名称空间中），其中包含激活函数，损失函数等。 以及卷积和线性层等层的无状态版本。 -> * `torch.optim`：包含诸如 `SGD` 的优化程序，这些优化程序在后退步骤 -> * `Dataset` 中更新 `Parameter` 的权重。 具有 `__len__` 和 `__getitem__` 的对象，包括 Pytorch 提供的类，例如 `TensorDataset` -> * `DataLoader`：获取任何 `Dataset` 并创建一个迭代器，该迭代器返回批量数据。 - -**脚本的总运行时间**：（0 分钟 57.062 秒） - -[下载 Python 源码：`nn_tutorial.py`](../_downloads/a6246751179fbfb7cad9222ef1c16617/nn_tutorial.py) - -[下载 Jupyter 笔记本：`nn_tutorial.ipynb`](../_downloads/5ddab57bb7482fbcc76722617dd47324/nn_tutorial.ipynb) - -[由 Sphinx 画廊](https://sphinx-gallery.readthedocs.io)生成的画廊 \ No newline at end of file diff --git a/pytorch/官方教程/17.md b/pytorch/官方教程/17.md deleted file mode 100644 index 12d5eeb4..00000000 --- a/pytorch/官方教程/17.md +++ /dev/null @@ -1,348 +0,0 @@ -# 使用 TensorBoard 可视化模型，数据和训练 - -> 原文： - -在 [60 分钟突击](https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html)中，我们向您展示了如何加载数据，如何通过定义为`nn.Module`子类的模型提供数据，如何在训练数据上训练该模型以及在测试数据上对其进行测试。 为了了解发生的情况，我们在模型训练期间打印一些统计数据，以了解训练是否在进行中。 但是，我们可以做得更好：PyTorch 与 TensorBoard 集成在一起，TensorBoard 是一种工具，用于可视化神经网络训练运行的结果。 本教程使用 [Fashion-MNIST 数据集](https://github.com/zalandoresearch/fashion-mnist)说明了其某些功能，可以使用`torchvision.datasets`将其读入 PyTorch。 - -在本教程中，我们将学习如何： - -> 1. 读取数据并进行适当的转换（与先前的教程几乎相同）。 -> 2. 设置 TensorBoard。 -> 3. 写入 TensorBoard。 -> 4. 使用 TensorBoard 检查模型架构。 -> 5. 使用 TensorBoard 来创建我们在上一个教程中创建的可视化的交互式版本，并使用较少的代码 - -具体来说，在第 5 点，我们将看到： - -> * 有两种方法可以检查我们的训练数据 -> * 在训练模型时如何跟踪其表现 -> * 在训练后如何评估模型的表现。 - -我们将从 [CIFAR-10 教程](https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html)中类似的样板代码开始： - -```py -# imports -import matplotlib.pyplot as plt -import numpy as np - -import torch -import torchvision -import torchvision.transforms as transforms - -import torch.nn as nn -import torch.nn.functional as F -import torch.optim as optim - -# transforms -transform = transforms.Compose( - [transforms.ToTensor(), - transforms.Normalize((0.5,), (0.5,))]) - -# datasets -trainset = torchvision.datasets.FashionMNIST('./data', - download=True, - train=True, - transform=transform) -testset = torchvision.datasets.FashionMNIST('./data', - download=True, - train=False, - transform=transform) - -# dataloaders -trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, - shuffle=True, num_workers=2) - -testloader = torch.utils.data.DataLoader(testset, batch_size=4, - shuffle=False, num_workers=2) - -# constant for classes -classes = ('T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', - 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle Boot') - -# helper function to show an image -# (used in the `plot_classes_preds` function below) -def matplotlib_imshow(img, one_channel=False): - if one_channel: - img = img.mean(dim=0) - img = img / 2 + 0.5 # unnormalize - npimg = img.numpy() - if one_channel: - plt.imshow(npimg, cmap="Greys") - else: - plt.imshow(np.transpose(npimg, (1, 2, 0))) - -``` - -我们将在该教程中定义一个类似的模型架构，仅需进行少量修改即可解决以下事实：图像现在是一个通道而不是三个通道，而图像是`28x28`而不是`32x32`： - -```py -class Net(nn.Module): - def __init__(self): - super(Net, self).__init__() - self.conv1 = nn.Conv2d(1, 6, 5) - self.pool = nn.MaxPool2d(2, 2) - self.conv2 = nn.Conv2d(6, 16, 5) - self.fc1 = nn.Linear(16 * 4 * 4, 120) - self.fc2 = nn.Linear(120, 84) - self.fc3 = nn.Linear(84, 10) - - def forward(self, x): - x = self.pool(F.relu(self.conv1(x))) - x = self.pool(F.relu(self.conv2(x))) - x = x.view(-1, 16 * 4 * 4) - x = F.relu(self.fc1(x)) - x = F.relu(self.fc2(x)) - x = self.fc3(x) - return x - -net = Net() - -``` - -我们将在之前定义相同的`optimizer`和`criterion`： - -```py -criterion = nn.CrossEntropyLoss() -optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) - -``` - -## 1\. TensorBoard 设置 - -现在，我们将设置 TensorBoard，从`torch.utils`导入`tensorboard`并定义`SummaryWriter`，这是将信息写入 TensorBoard 的关键对象。 - -```py -from torch.utils.tensorboard import SummaryWriter - -# default `log_dir` is "runs" - we'll be more specific here -writer = SummaryWriter('runs/fashion_mnist_experiment_1') - -``` - -请注意，仅此行会创建一个`runs/fashion_mnist_experiment_1`文件夹。 - -## 2\. 写入 TensorBoard - -现在，使用[`make_grid`](https://pytorch.org/docs/stable/torchvision/utils.html#torchvision.utils.make_grid)将图像写入到 TensorBoard 中，具体来说就是网格。 - -```py -# get some random training images -dataiter = iter(trainloader) -images, labels = dataiter.next() - -# create grid of images -img_grid = torchvision.utils.make_grid(images) - -# show images -matplotlib_imshow(img_grid, one_channel=True) - -# write to tensorboard -writer.add_image('four_fashion_mnist_images', img_grid) - -``` - -正在运行 - -```py -tensorboard --logdir=runs - -``` - -从命令行，然后导航到`https://localhost:6006`应该显示以下内容。 - -![intermediate/../../_static/img/tensorboard_first_view.png](img/8b09d6361316e495383ceedf9b8407ea.png) - -现在您知道如何使用 TensorBoard 了！ 但是，此示例可以在 Jupyter 笔记本中完成-TensorBoard 真正擅长的地方是创建交互式可视化。 接下来，我们将介绍其中之一，并在本教程结束时介绍更多内容。 - -## 3\. 使用 TensorBoard 检查模型 - -TensorBoard 的优势之一是其可视化复杂模型结构的能力。 让我们可视化我们构建的模型。 - -```py -writer.add_graph(net, images) -writer.close() - -``` - -现在刷新 TensorBoard 后，您应该会看到一个`Graphs`标签，如下所示： - -![intermediate/../../_static/img/tensorboard_model_viz.png](img/8f596b99dbb3c262b61db267d5db2d63.png) - -继续并双击`Net`以展开它，查看构成模型的各个操作的详细视图。 - -TensorBoard 具有非常方便的功能，可在低维空间中可视化高维数据，例如图像数据。 接下来我们将介绍这一点。 - -## 4\. 在 TensorBoard 中添加“投影仪” - -我们可以通过[`add_embedding`](https://pytorch.org/docs/stable/tensorboard.html#torch.utils.tensorboard.writer.SummaryWriter.add_embedding)方法可视化高维数据的低维表示 - -```py -# helper function -def select_n_random(data, labels, n=100): - ''' - Selects n random datapoints and their corresponding labels from a dataset - ''' - assert len(data) == len(labels) - - perm = torch.randperm(len(data)) - return data[perm][:n], labels[perm][:n] - -# select random images and their target indices -images, labels = select_n_random(trainset.data, trainset.targets) - -# get the class labels for each image -class_labels = [classes[lab] for lab in labels] - -# log embeddings -features = images.view(-1, 28 * 28) -writer.add_embedding(features, - metadata=class_labels, - label_img=images.unsqueeze(1)) -writer.close() - -``` - -现在，在 TensorBoard 的“投影仪”选项卡中，您可以看到这 100 张图像-每个图像 784 维-向下投影到三维空间中。 此外，这是交互式的：您可以单击并拖动以旋转三维投影。 最后，一些技巧可以使可视化效果更容易看到：选择左上方的“颜色：标签”，以及启用“夜间模式”，这将使图像更容易看到，因为它们的背景是白色的： - -![intermediate/../../_static/img/tensorboard_projector.png](img/f4990a0920dff7e4647a23cfc1639a8a.png) - -现在我们已经彻底检查了我们的数据，让我们展示了 TensorBoard 如何从训练开始就可以使跟踪模型的训练和评估更加清晰。 - -## 5\. 使用 TensorBoard 跟踪模型训练 - -在前面的示例中，我们仅*每 2000 次迭代*打印该模型的运行损失。 现在，我们将运行损失记录到 TensorBoard 中，并通过`plot_classes_preds`函数查看模型所做的预测。 - -```py -# helper functions - -def images_to_probs(net, images): - ''' - Generates predictions and corresponding probabilities from a trained - network and a list of images - ''' - output = net(images) - # convert output probabilities to predicted class - _, preds_tensor = torch.max(output, 1) - preds = np.squeeze(preds_tensor.numpy()) - return preds, [F.softmax(el, dim=0)[i].item() for i, el in zip(preds, output)] - -def plot_classes_preds(net, images, labels): - ''' - Generates matplotlib Figure using a trained network, along with images - and labels from a batch, that shows the network's top prediction along - with its probability, alongside the actual label, coloring this - information based on whether the prediction was correct or not. - Uses the "images_to_probs" function. - ''' - preds, probs = images_to_probs(net, images) - # plot the images in the batch, along with predicted and true labels - fig = plt.figure(figsize=(12, 48)) - for idx in np.arange(4): - ax = fig.add_subplot(1, 4, idx+1, xticks=[], yticks=[]) - matplotlib_imshow(images[idx], one_channel=True) - ax.set_title("{0}, {1:.1f}%\n(label: {2})".format( - classes[preds[idx]], - probs[idx] * 100.0, - classes[labels[idx]]), - color=("green" if preds[idx]==labels[idx].item() else "red")) - return fig - -``` - -最后，让我们使用与之前教程相同的模型训练代码来训练模型，但是每 1000 批将结果写入 TensorBoard，而不是打印到控制台。 这是通过[`add_scalar`](https://pytorch.org/docs/stable/tensorboard.html#torch.utils.tensorboard.writer.SummaryWriter.add_scalar)函数完成的。 - -此外，在训练过程中，我们将生成一幅图像，显示该批量中包含的四幅图像的模型预测与实际结果。 - -```py -running_loss = 0.0 -for epoch in range(1): # loop over the dataset multiple times - - for i, data in enumerate(trainloader, 0): - - # get the inputs; data is a list of [inputs, labels] - inputs, labels = data - - # zero the parameter gradients - optimizer.zero_grad() - - # forward + backward + optimize - outputs = net(inputs) - loss = criterion(outputs, labels) - loss.backward() - optimizer.step() - - running_loss += loss.item() - if i % 1000 == 999: # every 1000 mini-batches... - - # ...log the running loss - writer.add_scalar('training loss', - running_loss / 1000, - epoch * len(trainloader) + i) - - # ...log a Matplotlib Figure showing the model's predictions on a - # random mini-batch - writer.add_figure('predictions vs. actuals', - plot_classes_preds(net, inputs, labels), - global_step=epoch * len(trainloader) + i) - running_loss = 0.0 -print('Finished Training') - -``` - -现在，您可以查看“标量”选项卡，以查看在 15,000 次训练迭代中绘制的运行损失： - -![intermediate/../../_static/img/tensorboard_scalar_runs.png](img/afda8238ecd1f547d61be4d155844f68.png) - -此外，我们可以查看整个学习过程中模型在任意批量上所做的预测。 查看“图像”选项卡，然后在“预测与实际”可视化条件下向下滚动以查看此内容； 这表明，例如，仅经过 3000 次训练迭代，该模型就已经能够区分出视觉上截然不同的类，例如衬衫，运动鞋和外套，尽管它并没有像后来的训练那样有信心： - -![intermediate/../../_static/img/tensorboard_images.png](img/d5ab1f07cb4a9d9200c2a2d3b238340d.png) - -在之前的教程中，我们研究了模型训练后的每类准确率； 在这里，我们将使用 TensorBoard 绘制每个类别的精确调用曲线（[在这里解释](https://www.scikit-yb.org/en/latest/api/classifier/prcurve.html)）。 - -## 6\. 使用 TensorBoard 评估经过训练的模型 - -```py -# 1\. gets the probability predictions in a test_size x num_classes Tensor -# 2\. gets the preds in a test_size Tensor -# takes ~10 seconds to run -class_probs = [] -class_preds = [] -with torch.no_grad(): - for data in testloader: - images, labels = data - output = net(images) - class_probs_batch = [F.softmax(el, dim=0) for el in output] - _, class_preds_batch = torch.max(output, 1) - - class_probs.append(class_probs_batch) - class_preds.append(class_preds_batch) - -test_probs = torch.cat([torch.stack(batch) for batch in class_probs]) -test_preds = torch.cat(class_preds) - -# helper function -def add_pr_curve_tensorboard(class_index, test_probs, test_preds, global_step=0): - ''' - Takes in a "class_index" from 0 to 9 and plots the corresponding - precision-recall curve - ''' - tensorboard_preds = test_preds == class_index - tensorboard_probs = test_probs[:, class_index] - - writer.add_pr_curve(classes[class_index], - tensorboard_preds, - tensorboard_probs, - global_step=global_step) - writer.close() - -# plot all the pr curves -for i in range(len(classes)): - add_pr_curve_tensorboard(i, test_probs, test_preds) - -``` - -现在，您将看到一个`PR Curves`选项卡，其中包含每个类别的精确调用曲线。 继续四处戳； 您会发现在某些类别中，模型的“曲线下面积”接近 100%，而在另一些类别中，该面积更低： - -![intermediate/../../_static/img/tensorboard_pr_curves.png](img/d15de2be2b754f9a4f46418764232b5e.png) - -这是 TensorBoard 和 PyTorch 与之集成的介绍。 当然，您可以在 Jupyter 笔记本中完成 TensorBoard 的所有操作，但是使用 TensorBoard 时，默认情况下会获得交互式的视觉效果。 \ No newline at end of file diff --git a/pytorch/官方教程/README.md b/pytorch/官方教程/README.md deleted file mode 100644 index cd349818..00000000 --- a/pytorch/官方教程/README.md +++ /dev/null @@ -1,35 +0,0 @@ -# PyTorch 中文官方教程 1.7 - -> 原文：[WELCOME TO PYTORCH TUTORIALS](https://pytorch.org/tutorials/) -> -> 协议：[CC BY-NC-SA 4.0](http://creativecommons.org/licenses/by-nc-sa/4.0/) -> -> 自豪地采用[谷歌翻译](https://translate.google.cn/) -> -> 不要担心自己的形象，只关心如何实现目标。——《原则》，生活原则 2.3.c - -* [在线阅读](https://dl.apachecn.org) -* [ApacheCN 面试求职交流群 724187166](https://jq.qq.com/?_wv=1027&k=54ujcL3) -* [ApacheCN 学习资源](http://www.apachecn.org/) - -## 贡献指南 - -本项目需要校对，欢迎大家提交 Pull Request。 - -> 请您勇敢地去翻译和改进翻译。虽然我们追求卓越，但我们并不要求您做到十全十美，因此请不要担心因为翻译上犯错——在大部分情况下，我们的服务器已经记录所有的翻译，因此您不必担心会因为您的失误遭到无法挽回的破坏。（改编自维基百科） - -## 联系方式 - -### 负责人 - -* [飞龙](https://github.com/wizardforcel): 562826179 - -### 其他 - -* 在我们的 [apachecn/apachecn-tf-zh](https://github.com/apachecn/apachecn-tf-zh) github 上提 issue. -* 发邮件到 Email: `apachecn@163.com`. -* 在我们的 [组织学习交流群](http://www.apachecn.org/organization/348.html) 中联系群主/管理员即可. - -## 赞助我们 - -![](http://data.apachecn.org/img/about/donate.jpg) diff --git a/pytorch/官方教程/book.json b/pytorch/官方教程/book.json deleted file mode 100644 index 2d99e483..00000000 --- a/pytorch/官方教程/book.json +++ /dev/null @@ -1,176 +0,0 @@ -{ - "title" : "Pytorch 中文文档", - "author" : "ApacheCN", - "description" : "Pytorch 中文文档: 教程和文档", - "language" : "zh-hans", - "plugins": [ - "github", - "github-buttons", - "-sharing", - "insert-logo", - "sharing-plus", - "back-to-top-button", - "code", - "copy-code-button", - "katex", - "pageview-count", - "edit-link", - "emphasize", - "alerts", - "auto-scroll-table", - "popup", - "hide-element", - "page-toc-button", - "tbfed-pagefooter", - "sitemap", - "advanced-emoji", - "expandable-chapters", - "splitter", - "search-pro" - ], - "pluginsConfig": { - "github": { - "url": "https://github.com/apachecn/pytorch-doc-zh" - }, - "github-buttons": { - "buttons": [ - { - "user": "apachecn", - "repo": "pytorch-doc-zh", - "type": "star", - "count": true, - "size": "small" - } - ] - }, - "insert-logo": { - "url": "http://data.apachecn.org/img/logo.jpg", - "style": "background: none; max-height: 150px; min-height: 150px" - }, - "hide-element": { - "elements": [".gitbook-link"] - }, - "edit-link": { - "base": "https://github.com/apachecn/pytorch-doc-zh/blob/master/docs/1.7", - "label": "编辑本页" - }, - "sharing": { - "qzone": true, - "weibo": true, - "twitter": false, - "facebook": false, - "google": false, - "qq": false, - "line": false, - "whatsapp": false, - "douban": false, - "all": [ - "qq", "douban", "facebook", "google", "linkedin", "twitter", "weibo", "whatsapp" - ] - }, - "page-toc-button": { - "maxTocDepth": 4, - "minTocSize": 4 - }, - "tbfed-pagefooter": { - "copyright":"Copyright © ibooker.org.cn 2019", - "modify_label": "该文件修订时间： ", - "modify_format": "YYYY-MM-DD HH:mm:ss" - }, - "sitemap": { - "hostname": "http://pytorch.apachecn.org" - } - }, - "my_links" : { - "sidebar" : { - "Home" : "https://www.baidu.com" - } - }, - "my_plugins": [ - "donate", - "todo", - "-lunr", - "-search", - "expandable-chapters-small", - "chapter-fold", - "expandable-chapters", - "expandable-chapters-small", - "back-to-top-button", - "ga", - "baidu", - "sitemap", - "tbfed-pagefooter", - "advanced-emoji", - "sectionx", - "page-treeview", - "simple-page-toc", - "ancre-navigation", - "theme-apachecn@git+https://github.com/apachecn/theme-apachecn#HEAD", - "pagefooter-apachecn@git+https://github.com/apachecn/gitbook-plugin-pagefooter-apachecn#HEAD" - ], - "my_pluginsConfig": { - "github-buttons": { - "buttons": [ - { - "user": "apachecn", - "repo": "pytorch-doc-zh", - "type": "star", - "count": true, - "size": "small" - }, - { - "user": "apachecn", - "width": "160", - "type": "follow", - "count": true, - "size": "small" - } - ] - }, - "ignores": ["node_modules"], - "simple-page-toc": { - "maxDepth": 3, - "skipFirstH1": true - }, - "page-toc-button": { - "maxTocDepth": 2, - "minTocSize": 2 - }, - "page-treeview": { - "copyright": "Copyright © aleen42", - "minHeaderCount": "2", - "minHeaderDeep": "2" - }, - "donate": { - "wechat": "微信收款的二维码URL", - "alipay": "支付宝收款的二维码URL", - "title": "", - "button": "赏", - "alipayText": "支付宝打赏", - "wechatText": "微信打赏" - }, - "page-copyright": { - "description": "modified at", - "signature": "你的签名", - "wisdom": "Designer, Frontend Developer & overall web enthusiast", - "format": "YYYY-MM-dd hh:mm:ss", - "copyright": "Copyright © 你的名字", - "timeColor": "#666", - "copyrightColor": "#666", - "utcOffset": "8", - "style": "normal", - "noPowered": false - }, - "ga": { - "token": "UA-102475051-10" - }, - "baidu": { - "token": "75439e2cbd22bdd813226000e9dcc12f" - }, - "pagefooter-apachecn": { - "copyright":"Copyright © ibooker.org.cn 2019", - "modify_label": "该文件修订时间： ", - "modify_format": "YYYY-MM-DD HH:mm:ss" - } - } -} diff --git a/pytorch/实战/.gitignore b/pytorch/实战/.gitignore new file mode 100644 index 00000000..6320cd24 --- /dev/null +++ b/pytorch/实战/.gitignore @@ -0,0 +1 @@ +data \ No newline at end of file diff --git a/pytorch/实战/1.ipynb b/pytorch/实战/1.ipynb index 4ff48f15..bf237334 100644 --- a/pytorch/实战/1.ipynb +++ b/pytorch/实战/1.ipynb @@ -193,21 +193,197 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 103, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Net(\n (conv1): Conv2d(1, 6, kernel_size=(3, 3), stride=(1, 1))\n (conv2): Conv2d(6, 16, kernel_size=(3, 3), stride=(1, 1))\n (fc1): Linear(in_features=576, out_features=120, bias=True)\n (fc2): Linear(in_features=120, out_features=84, bias=True)\n (fc3): Linear(in_features=84, out_features=10, bias=True)\n)\n10\ntorch.Size([6, 1, 3, 3])\n" + ] + } + ], "source": [ "import torch\n", "import torch.nn as nn\n", - "import torch.nn.functional as f\n", + "import torch.nn.functional as F\n", "\n", "class Net(nn.Module):\n", + "\n", " def __init__(self):\n", + " super(Net,self).__init__()\n", " self.conv1 = nn.Conv2d(1,6,3)\n", " self.conv2 = nn.Conv2d(6,16,3)\n", " self.fc1 = nn.Linear(16*6*6,120)\n", - " self" + " self.fc2 = nn.Linear(120,84)\n", + " self.fc3 = nn.Linear(84,10)\n", + "\n", + " def forward(self,x):\n", + " x = F.max_pool2d(F.relu(self.conv1(x)),(2,2))\n", + " x = F.max_pool2d(F.relu(self.conv2(x)),2)\n", + " x = x.view(-1,self.num_flat_features(x))\n", + " x = F.relu(self.fc1(x))\n", + " x = F.relu(self.fc2(x))\n", + " x = self.fc3(x)\n", + " return x\n", + " \n", + " def num_flat_features(self,x):\n", + " size = x.size()[1:]\n", + " num_features = 1\n", + " for s in size:\n", + " num_features *=s\n", + " return num_features\n", + "\n", + "net = Net()\n", + "print(net)\n", + "params = list(net.parameters())\n", + "print(len(params))\n", + "print(params[0].size())" ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "tensor([[ 0.0492, -0.0594, -0.1026, -0.0511, 0.0224, -0.0672, 0.1048, 0.0772,\n -0.1358, -0.0327]], grad_fn=)\n" + ] + } + ], + "source": [ + "input = torch.randn(1,1,32,32)\n", + "out = net(input)\n", + "print(out)\n", + "\n", + "net.zero_grad()\n", + "out.backward(torch.randn(1,10))" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "tensor([[0.9332, 0.9385],\n [0.5645, 0.9817],\n [0.0998, 0.0800],\n [0.3189, 0.7160],\n [0.4157, 0.3705]])\n" + ] + } + ], + "source": [ + "# tensor,的第一个维度表示数量。第二个维度开始表示数据的格式。如果第一维的维度>1说明存在一个以上的数据条目\n", + "a = torch.rand(2,5)\n", + "# b = np.rand(2,3)\n", + "print(a.T)" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "None\nTrue\ntensor([[-0.8533, -1.8255, 0.1003, -0.2550, 0.0429, -2.4029, -2.1907, -0.3119,\n -0.5956, 0.5517]])\ntensor(1.5207, grad_fn=)\n\n\n\n" + ] + } + ], + "source": [ + "# 定义损失\n", + "print(input.grad)\n", + "print(input.is_leaf)\n", + "output = net(input)\n", + "target = torch.randn(10)\n", + "target = target.view(1,-1)\n", + "print(target)\n", + "criterion = nn.MSELoss()\n", + "loss = criterion(output,target)\n", + "# 输出了反向传播过程中的函数\n", + "print(loss)\n", + "print(loss.grad_fn)\n", + "print(loss.grad_fn.next_functions[0][0])\n", + "print(loss.grad_fn.next_functions[0][0].next_functions[0][0])" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "tensor([0., 0., 0., 0., 0., 0.])\n" + ] + }, + { + "output_type": "error", + "ename": "RuntimeError", + "evalue": "Trying to backward through the graph a second time, but the saved intermediate results have already been freed. Specify retain_graph=True when calling .backward() or autograd.grad() the first time.", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnet\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconv1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbias\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgrad\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mloss\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 8\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnet\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconv1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbias\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgrad\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mC:\\Python\\lib\\site-packages\\torch\\tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[1;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[0;32m 243\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mcreate_graph\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 244\u001b[0m inputs=inputs)\n\u001b[1;32m--> 245\u001b[1;33m \u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 246\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 247\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mC:\\Python\\lib\\site-packages\\torch\\autograd\\__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[1;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[0;32m 143\u001b[0m \u001b[0mretain_graph\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 144\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 145\u001b[1;33m Variable._execution_engine.run_backward(\n\u001b[0m\u001b[0;32m 146\u001b[0m \u001b[0mtensors\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgrad_tensors_\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 147\u001b[0m allow_unreachable=True, accumulate_grad=True) # allow_unreachable flag\n", + "\u001b[1;31mRuntimeError\u001b[0m: Trying to backward through the graph a second time, but the saved intermediate results have already been freed. Specify retain_graph=True when calling .backward() or autograd.grad() the first time." + ] + } + ], + "source": [ + "# 进行反向传播\n", + "net.zero_grad()\n", + "\n", + "print(net.conv1.bias.grad)\n", + "loss.backward()\n", + "\n", + "print(net.conv1.bias.grad)\n", + "# 更新网络权重weight = weight -learning_rate*gradient\n", + "learning_rate = 0.01\n", + "for f in net.parameters():\n", + " f.data.sub_(f.grad.data*learning_rate)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [], + "source": [ + "# 常用的优化器\n", + "import torch.optim as optim\n", + "\n", + "optimizer = optim.SGD(net.parameters(),lr=0.01)\n", + "\n", + "optimizer.zero_grad()\n", + "\n", + "output = net(input)\n", + "loss = criterion(output,target)\n", + "loss.backward()\n", + "optimizer.step()" + ] + }, + { + "source": [ + "### 卷积的计算公式\n", + "$$\n", + "d = (d - kennelsize + 2 * padding) / stride + 1\n", + "$$" + ], + "cell_type": "markdown", + "metadata": {} } ] } \ No newline at end of file diff --git a/pytorch/实战/6.ipynb b/pytorch/实战/6.ipynb new file mode 100644 index 00000000..53dc4ff3 --- /dev/null +++ b/pytorch/实战/6.ipynb @@ -0,0 +1,392 @@ +{ + "metadata": { + "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.8.0-final" + }, + "orig_nbformat": 2, + "kernelspec": { + "name": "python3", + "display_name": "Python 3.8.0 64-bit", + "metadata": { + "interpreter": { + "hash": "38740d3277777e2cd7c6c2cc9d8addf5118fdf3f82b1b39231fd12aeac8aee8b" + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 2, + "cells": [ + { + "source": [ + "## 6 训练分类器" + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Files already downloaded and verified\n", + "Files already downloaded and verified\n" + ] + } + ], + "source": [ + "# 6.1 加载数据。数据预处理。将数据集加载到内存当中。dataloader是加载器。只在调用数据的时候进行惰性加载。\n", + "import torch\n", + "import torchvision\n", + "import torchvision.transforms as transforms\n", + "\n", + "transform = transforms.Compose(\n", + " [transforms.ToTensor(),\n", + " transforms.Normalize((0.5,0.5,0.5),(.5,.5,5))]\n", + ")\n", + "trainset = torchvision.datasets.CIFAR10(root='./data',train=True,download=True,transform=transform)\n", + "\n", + "trainloader = torch.utils.data.DataLoader(trainset,batch_size=4,shuffle=True,num_workers=2)\n", + "\n", + "testset = torchvision.datasets.CIFAR10(root='./data',train=False,download=True,transform=transform)\n", + "\n", + "testloader = torch.utils.data.DataLoader(testset,batch_size=4,num_workers=2)\n", + "\n", + "classes = ('plane', 'car', 'bird', 'cat','deer', 'dog', 'frog', 'horse', 'ship', 'truck')" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/svg+xml": "\r\n\r\n\r\n\r\n \r\n \r\n \r\n \r\n 2021-03-23T13:48:01.381807\r\n image/svg+xml\r\n \r\n \r\n Matplotlib v3.3.2, https://matplotlib.org/\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n\r\n", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "torch.Size([4, 3, 32, 32])\nhorse car frog horse\n" + ] + } + ], + "source": [ + "# 使用迭代器工具，显示一部分图像。\n", + "import matplotlib.pylab as plt\n", + "import numpy as np \n", + "\n", + "def imshow(img):\n", + " img = img/2+0.5\n", + " npimg = img.numpy()\n", + " plt.imshow(np.transpose(npimg,(1,2,0)))\n", + " plt.show()\n", + "\n", + "dataiter = iter(trainloader)\n", + "images,labels = dataiter.next()\n", + "\n", + "imshow(torchvision.utils.make_grid(images))\n", + "print(images.shape)\n", + "print(' '.join('%5s' % classes[labels[j]] for j in range(4)))" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "# 2 定义卷积神经网络\n", + "\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F \n", + "\n", + "class Net(nn.Module):\n", + " def __init__(self):\n", + " super(Net, self).__init__()\n", + " self.conv1 = nn.Conv2d(3, 6, 5)\n", + " self.pool = nn.MaxPool2d(2, 2)\n", + " self.conv2 = nn.Conv2d(6, 16, 5)\n", + " self.fc1 = nn.Linear(16 * 5 * 5, 120)\n", + " self.fc2 = nn.Linear(120, 84)\n", + " self.fc3 = nn.Linear(84, 10)\n", + "\n", + " def forward(self, x):\n", + " x = self.pool(F.relu(self.conv1(x)))\n", + " x = self.pool(F.relu(self.conv2(x)))\n", + " x = x.view(-1, 16 * 5 * 5)\n", + " x = F.relu(self.fc1(x))\n", + " x = F.relu(self.fc2(x))\n", + " x = self.fc3(x)\n", + " return x\n", + "\n", + "net = Net()" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[1, 2000] loss: 2.293\n", + "[1, 4000] loss: 2.053\n", + "[1, 6000] loss: 1.794\n", + "[1, 8000] loss: 1.668\n", + "[1, 10000] loss: 1.593\n", + "[1, 12000] loss: 1.529\n", + "[2, 2000] loss: 1.475\n", + "[2, 4000] loss: 1.415\n", + "[2, 6000] loss: 1.408\n", + "[2, 8000] loss: 1.363\n", + "[2, 10000] loss: 1.338\n", + "[2, 12000] loss: 1.329\n", + "Finished Trainning\n" + ] + } + ], + "source": [ + "# 3 定义损失函数\n", + "import torch.optim as optim\n", + "criterion = nn.CrossEntropyLoss()\n", + "optimizer = optim.SGD(net.parameters(),lr=0.001,momentum=0.9)\n", + "\n", + "# 训练网络\n", + "\n", + "for epoch in range(2):\n", + " running_loss = 0.0\n", + " for i,data in enumerate(trainloader,0):\n", + " inputs,labels = data\n", + " optimizer.zero_grad()\n", + " # forward\n", + " outputs = net(inputs)\n", + " # calculate loss\n", + " loss = criterion(outputs,labels)\n", + " # backward\n", + " loss.backward()\n", + " # optimize\n", + " optimizer.step()\n", + "\n", + " running_loss += loss.item()\n", + " if i%2000 == 1999:\n", + " print('[%d, %5d] loss: %.3f' %(epoch + 1, i + 1, running_loss / 2000))\n", + " running_loss = 0.0\n", + "\n", + "print('Finished Trainning')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "# 保存模型\n", + "path = './cifar_net.pth'\n", + "torch.save(net.state_dict(),path)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/svg+xml": "\r\n\r\n\r\n\r\n \r\n \r\n \r\n \r\n 2021-03-23T13:49:19.410200\r\n image/svg+xml\r\n \r\n \r\n Matplotlib v3.3.2, https://matplotlib.org/\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n\r\n", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "GroundTruth: cat ship ship plane\n" + ] + } + ], + "source": [ + "dataiter = iter(testloader)\n", + "images,labels = dataiter.next()\n", + "\n", + "imshow(torchvision.utils.make_grid(images))\n", + "print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 44 + } + ], + "source": [ + "# 加载模型\n", + "\n", + "net = Net()\n", + "net.load_state_dict(torch.load(path))" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Predicted: cat ship ship ship\n" + ] + } + ], + "source": [ + "# 使用模型进行简单的预测\n", + "outputs = net(images)\n", + "_,predicted = torch.max(outputs,1)\n", + "print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]\n", + " for j in range(4)))" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n" + ] + } + ], + "source": [ + "\n", + "print(classes)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "53.9\n" + ] + } + ], + "source": [ + "# 测试总体的表现。\n", + "correct = 0\n", + "total =0\n", + "\n", + "with torch.no_grad():\n", + " for data in testloader:\n", + " images,labels = data\n", + " outputs = net(images)\n", + " _,predicted = torch.max(outputs.data,1)\n", + " total += labels.size(0)\n", + " correct += (predicted == labels).sum().item()\n", + "print(100*correct/total)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Accuracy of plane : 52 %\nAccuracy of car : 47 %\nAccuracy of bird : 46 %\nAccuracy of cat : 36 %\nAccuracy of deer : 45 %\nAccuracy of dog : 38 %\nAccuracy of frog : 70 %\nAccuracy of horse : 56 %\nAccuracy of ship : 83 %\nAccuracy of truck : 62 %\n" + ] + } + ], + "source": [ + "class_correct = list(0. for i in range(10))\n", + "class_total = list(0. for i in range(10))\n", + "with torch.no_grad():\n", + " for data in testloader:\n", + " images, labels = data\n", + " outputs = net(images)\n", + " _, predicted = torch.max(outputs, 1)\n", + " c = (predicted == labels).squeeze()\n", + " for i in range(4):\n", + " label = labels[i]\n", + " class_correct[label] += c[i].item()\n", + " class_total[label] += 1\n", + "\n", + "for i in range(10):\n", + " print('Accuracy of %5s : %2d %%' % (\n", + " classes[i], 100 * class_correct[i] / class_total[i]))" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "cpu\n" + ] + } + ], + "source": [ + "# 在GPU上进行训练\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else 'cpu')\n", + "\n", + "print(device)\n", + "\n", + "net.to(device)\n", + "\n", + "inputs,labels = data[0].to(device),data[1].to(device)" + ] + } + ] +} \ No newline at end of file diff --git a/pytorch/实战/7.ipynb b/pytorch/实战/7.ipynb new file mode 100644 index 00000000..667a964a --- /dev/null +++ b/pytorch/实战/7.ipynb @@ -0,0 +1,897 @@ +{ + "metadata": { + "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.8.0-final" + }, + "orig_nbformat": 2, + "kernelspec": { + "name": "python3", + "display_name": "Python 3.8.0 64-bit", + "metadata": { + "interpreter": { + "hash": "38740d3277777e2cd7c6c2cc9d8addf5118fdf3f82b1b39231fd12aeac8aee8b" + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 2, + "cells": [ + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "99 2853.9273235396186\n", + "199 1920.1599361735143\n", + "299 1293.9318621259858\n", + "399 873.6293058201031\n", + "499 591.3102531671352\n", + "599 401.51736190288585\n", + "699 273.8164238221197\n", + "799 187.8170665910619\n", + "899 129.8480963577774\n", + "999 90.73635494859597\n", + "1099 64.32191622546065\n", + "1199 46.464885616046026\n", + "1299 34.3805974263392\n", + "1399 26.19431825870059\n", + "1499 20.642763997519296\n", + "1599 16.873875616831352\n", + "1699 14.312402496108426\n", + "1799 12.569591035284114\n", + "1899 11.382455473616632\n", + "1999 10.572905438674582\n", + "-0.03186837476257857 0.8284118475316333 0.005497824938589816 -0.08930083611579144\n" + ] + } + ], + "source": [ + "# 1 使用numpy实现梯度下降神经网络\n", + "\n", + "import numpy as np \n", + "import math \n", + "x = np.linspace(-math.pi,math.pi,2000)\n", + "y = np.sin(x)\n", + "\n", + "a = np.random.randn()\n", + "b = np.random.randn()\n", + "c = np.random.randn()\n", + "d = np.random.randn()\n", + "\n", + "learning_rate = 1e-6\n", + "for t in range(2000):\n", + " # forward\n", + " y_pred = a+b*x+c*x**2+d*x**3\n", + " loss = np.square(y_pred - y).sum()\n", + " if t % 100 ==99:\n", + " print(t,loss)\n", + " \n", + " # backward\n", + " grad_y_pred = 2.0 *(y_pred-y)\n", + " grad_a = grad_y_pred.sum()\n", + " grad_b = (grad_y_pred *x).sum()\n", + " grad_c = (grad_y_pred * x**2).sum()\n", + " grad_d = (grad_y_pred * x ** 3).sum()\n", + "\n", + " # optimizer\n", + " a -= learning_rate * grad_a\n", + " b -= learning_rate * grad_b\n", + " c -= learning_rate * grad_c\n", + " d -= learning_rate * grad_d\n", + "\n", + "print(a,b,c,d)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/svg+xml": "\r\n\r\n\r\n\r\n \r\n \r\n \r\n \r\n 2021-03-23T15:21:39.881860\r\n image/svg+xml\r\n \r\n \r\n Matplotlib v3.3.2, https://matplotlib.org/\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n\r\n", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "def predict_sin(x):\n", + " return a+b*x+c*x**2+d*x**3\n", + "\n", + "import matplotlib.pyplot as plt \n", + "plt.plot(x,y,c='r')\n", + "plt.plot(x,predict_sin(x),c='g')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "99 2079.260498046875\n", + "199 1468.034912109375\n", + "299 1037.5106201171875\n", + "399 734.1796264648438\n", + "499 520.4055786132812\n", + "599 369.7096252441406\n", + "699 263.45355224609375\n", + "799 188.51531982421875\n", + "899 135.653076171875\n", + "999 98.35609436035156\n", + "1099 72.0362319946289\n", + "1199 53.459503173828125\n", + "1299 40.345767974853516\n", + "1399 31.087013244628906\n", + "1499 24.54908561706543\n", + "1599 19.931785583496094\n", + "1699 16.670467376708984\n", + "1799 14.366645812988281\n", + "1899 12.739038467407227\n", + "1999 11.589033126831055\n", + "Result: y = -0.055228542536497116 + 0.8499048948287964 x + 0.009527843445539474 x^2 + -0.09235803782939911 x^3\n" + ] + } + ], + "source": [ + "# 2 使用pytorch张量进行梯度下降\n", + "\n", + "import torch\n", + "import math\n", + "\n", + "dtype = torch.float\n", + "device = torch.device(\"cpu\")\n", + "\n", + "x = torch.linspace(-math.pi,math.pi,2000,device=device,dtype=dtype)\n", + "y = torch.sin(x)\n", + "\n", + "a = torch.randn((),device=device,dtype=dtype)\n", + "b = torch.randn((),device=device,dtype=dtype)\n", + "c = torch.randn((),device=device,dtype=dtype)\n", + "d = torch.randn((),device=device,dtype=dtype)\n", + "\n", + "learning_rate = 1e-6\n", + "\n", + "for t in range(2000):\n", + " y_pred = a+b*x+c*x**2+d*x**3\n", + " loss = (y_pred - y).pow(2).sum().item()\n", + "\n", + " if t % 100 ==99:\n", + " print(t,loss)\n", + " \n", + " # Backprop to compute gradients of a, b, c, d with respect to loss\n", + " grad_y_pred = 2.0 * (y_pred - y)\n", + " grad_a = grad_y_pred.sum()\n", + " grad_b = (grad_y_pred * x).sum()\n", + " grad_c = (grad_y_pred * x ** 2).sum()\n", + " grad_d = (grad_y_pred * x ** 3).sum()\n", + "\n", + " # Update weights using gradient descent\n", + " a -= learning_rate * grad_a\n", + " b -= learning_rate * grad_b\n", + " c -= learning_rate * grad_c\n", + " d -= learning_rate * grad_d\n", + "\n", + "\n", + "print(f'Result: y = {a.item()} + {b.item()} x + {c.item()} x^2 + {d.item()} x^3')" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/svg+xml": "\r\n\r\n\r\n\r\n \r\n \r\n \r\n \r\n 2021-03-23T15:21:40.472282\r\n image/svg+xml\r\n \r\n \r\n Matplotlib v3.3.2, https://matplotlib.org/\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n\r\n", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "def predict_sin2(x):\n", + " return a+b*x+c*x**2+d*x**3\n", + "import matplotlib.pyplot as plt \n", + "plt.plot(x,y,c='r')\n", + "plt.plot(x,predict_sin2(x),c='g')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "99 350.6225280761719\n", + "199 246.3155517578125\n", + "299 173.9889373779297\n", + "399 123.78739929199219\n", + "499 88.9103775024414\n", + "599 64.658447265625\n", + "699 47.779937744140625\n", + "799 36.023372650146484\n", + "899 27.827756881713867\n", + "999 22.110069274902344\n", + "1099 18.118133544921875\n", + "1199 15.329056739807129\n", + "1299 13.379064559936523\n", + "1399 12.014815330505371\n", + "1499 11.059768676757812\n", + "1599 10.390778541564941\n", + "1699 9.921894073486328\n", + "1799 9.5930814743042\n", + "1899 9.362378120422363\n", + "1999 9.200424194335938\n", + "Result: y = 0.019712112843990326 + 0.8508722186088562 x + -0.003400667803362012 x^2 + -0.0924956277012825 x^3\n" + ] + } + ], + "source": [ + "# 3 使用autograd自动梯度计算\n", + "import torch\n", + "import math\n", + "\n", + "dtype = torch.float\n", + "device = torch.device(\"cpu\")\n", + "# device = torch.device(\"cuda:0\") # Uncomment this to run on GPU\n", + "\n", + "# Create Tensors to hold input and outputs.\n", + "# By default, requires_grad=False, which indicates that we do not need to\n", + "# compute gradients with respect to these Tensors during the backward pass.\n", + "x = torch.linspace(-math.pi, math.pi, 2000, device=device, dtype=dtype)\n", + "y = torch.sin(x)\n", + "\n", + "# Create random Tensors for weights. For a third order polynomial, we need\n", + "# 4 weights: y = a + b x + c x^2 + d x^3\n", + "# Setting requires_grad=True indicates that we want to compute gradients with\n", + "# respect to these Tensors during the backward pass.\n", + "a = torch.randn((), device=device, dtype=dtype, requires_grad=True)\n", + "b = torch.randn((), device=device, dtype=dtype, requires_grad=True)\n", + "c = torch.randn((), device=device, dtype=dtype, requires_grad=True)\n", + "d = torch.randn((), device=device, dtype=dtype, requires_grad=True)\n", + "\n", + "learning_rate = 1e-6\n", + "for t in range(2000):\n", + " y_pred = a + b*x +c*x**2+d*x**3\n", + " loss = (y_pred-y).pow(2).sum()\n", + " if t%100 ==99:\n", + " print(t,loss.item())\n", + " \n", + " # 执行自动梯度计算\n", + " loss.backward()\n", + "\n", + " # 进行梯度下降\n", + " with torch.no_grad():\n", + " a -= learning_rate*a.grad \n", + " b -= learning_rate*b.grad \n", + " c -= learning_rate*c.grad \n", + " d -= learning_rate*d.grad \n", + " a.grad = None \n", + " b.grad = None\n", + " c.grad = None \n", + " d.grad = None \n", + "\n", + "print(f'Result: y = {a.item()} + {b.item()} x + {c.item()} x^2 + {d.item()} x^3')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/svg+xml": "\r\n\r\n\r\n\r\n \r\n \r\n \r\n \r\n 2021-03-23T15:22:15.734505\r\n image/svg+xml\r\n \r\n \r\n Matplotlib v3.3.2, https://matplotlib.org/\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n\r\n", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "\n", + "def predict_sin3(x):\n", + " return a+b*x+c*x**2+d*x**3\n", + "\n", + "import matplotlib.pyplot as plt \n", + "plt.plot(x,y,c='r')\n", + "plt.plot(x,(predict_sin3(x).detach().numpy()),c='g')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "99 209.95834350585938\n", + "199 144.66018676757812\n", + "299 100.70249938964844\n", + "399 71.03519439697266\n", + "499 50.97850799560547\n", + "599 37.403133392333984\n", + "699 28.206867218017578\n", + "799 21.973188400268555\n", + "899 17.7457275390625\n", + "999 14.877889633178711\n", + "1099 12.931766510009766\n", + "1199 11.610918045043945\n", + "1299 10.714258193969727\n", + "1399 10.10548210144043\n", + "1499 9.692106246948242\n", + "1599 9.411375045776367\n", + "1699 9.220745086669922\n", + "1799 9.091285705566406\n", + "1899 9.003361701965332\n", + "1999 8.943639755249023\n", + "Result: y = -5.423830273798558e-09 + -2.208526849746704 * P3(1.3320399228078372e-09 + 0.2554861009120941 x)\n" + ] + } + ], + "source": [ + "# 4 重新定义autograd函数，执行梯度计算\n", + "# 将模型定义为y = a + b P[3](c + dx)而不是y = a + bx + cx ^ 2 + dx ^ 3，其中P[3](x) = 1/2 (5x ^ 3 - 3x)是三次的勒让德多项式。\n", + "import torch\n", + "import math \n", + "\n", + "class LegendrePolynomial3(torch.autograd.Function):\n", + " @staticmethod \n", + " def forward(ctx,input):\n", + " ctx.save_for_backward(input)\n", + " return 0.5 * (5*input**3 -3*input)\n", + "\n", + " @staticmethod \n", + " def backward(ctx,grad_output):\n", + " input, = ctx.saved_tensors\n", + " return grad_output*1.5*(5*input**2-1)\n", + " \n", + "\n", + "dtype = torch.float\n", + "device = torch.device(\"cpu\") \n", + "\n", + "x = torch.linspace(-math.pi, math.pi, 2000, device=device, dtype=dtype)\n", + "y = torch.sin(x)\n", + "\n", + "# Create random Tensors for weights. For this example, we need\n", + "# 4 weights: y = a + b * P3(c + d * x), these weights need to be initialized\n", + "# not too far from the correct result to ensure convergence.\n", + "# Setting requires_grad=True indicates that we want to compute gradients with\n", + "# respect to these Tensors during the backward pass.\n", + "a = torch.full((), 0.0, device=device, dtype=dtype, requires_grad=True)\n", + "b = torch.full((), -1.0, device=device, dtype=dtype, requires_grad=True)\n", + "c = torch.full((), 0.0, device=device, dtype=dtype, requires_grad=True)\n", + "d = torch.full((), 0.3, device=device, dtype=dtype, requires_grad=True)\n", + "\n", + "learning_rate = 5e-6\n", + "for t in range(2000):\n", + " # To apply our Function, we use Function.apply method. We alias this as 'P3'.\n", + " P3 = LegendrePolynomial3.apply\n", + "\n", + " # Forward pass: compute predicted y using operations; we compute\n", + " # P3 using our custom autograd operation.\n", + " y_pred = a + b * P3(c + d * x)\n", + "\n", + " # Compute and print loss\n", + " loss = (y_pred - y).pow(2).sum()\n", + " if t % 100 == 99:\n", + " print(t, loss.item())\n", + "\n", + " # Use autograd to compute the backward pass.\n", + " loss.backward()\n", + "\n", + " # Update weights using gradient descent\n", + " with torch.no_grad():\n", + " a -= learning_rate * a.grad\n", + " b -= learning_rate * b.grad\n", + " c -= learning_rate * c.grad\n", + " d -= learning_rate * d.grad\n", + "\n", + " # Manually zero the gradients after updating weights\n", + " a.grad = None\n", + " b.grad = None\n", + " c.grad = None\n", + " d.grad = None\n", + "\n", + "print(f'Result: y = {a.item()} + {b.item()} * P3({c.item()} + {d.item()} x)')" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/svg+xml": "\r\n\r\n\r\n\r\n \r\n \r\n \r\n \r\n 2021-03-23T15:23:32.852120\r\n image/svg+xml\r\n \r\n \r\n Matplotlib v3.3.2, https://matplotlib.org/\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n\r\n", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "\n", + "def predict_sin4(x):\n", + " return a+b*x+c*x**2+d*x**3\n", + "import matplotlib.pyplot as plt \n", + "plt.plot(x,y,c='r')\n", + "plt.plot(x,(predict_sin4(x)).detach().numpy(),c='g')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "99 1063.9005126953125\n", + "199 706.83837890625\n", + "299 470.62939453125\n", + "399 314.3643798828125\n", + "499 210.98336791992188\n", + "599 142.58665466308594\n", + "699 97.33384704589844\n", + "799 67.39220428466797\n", + "899 47.580684661865234\n", + "999 34.47142028808594\n", + "1099 25.796506881713867\n", + "1199 20.05570411682129\n", + "1299 16.25637435913086\n", + "1399 13.741846084594727\n", + "1499 12.0775146484375\n", + "1599 10.975820541381836\n", + "1699 10.246527671813965\n", + "1799 9.763702392578125\n", + "1899 9.444038391113281\n", + "1999 9.232373237609863\n", + "Result: y = 0.003426064969971776 + 0.837184488773346 x + -0.000591053394600749 x^2 + -0.09054866433143616 x^3\n" + ] + } + ], + "source": [ + "# 5 nn 模块。封装计算过程层。构建计算图\n", + "\n", + "import torch \n", + "import math \n", + "\n", + "x = torch.linspace(-math.pi, math.pi, 2000)\n", + "y = torch.sin(x)\n", + "\n", + "p = torch.tensor([1,2,3])\n", + "xx = x.unsqueeze(-1).pow(p)\n", + "\n", + "model = torch.nn.Sequential(\n", + " torch.nn.Linear(3,1),\n", + " torch.nn.Flatten(0,1)\n", + ")\n", + "\n", + "loss_fn = torch.nn.MSELoss(reduction='sum')\n", + "\n", + "learning_rate = 1e-6\n", + "\n", + "for t in range(2000):\n", + " y_pred = model(xx)\n", + "\n", + " loss = loss_fn(y_pred,y)\n", + " if t%100 == 99:\n", + " print(t,loss.item())\n", + " \n", + " model.zero_grad()\n", + "\n", + " loss.backward()\n", + "\n", + " with torch.no_grad():\n", + " for param in model.parameters():\n", + " param -= learning_rate * param.grad\n", + " \n", + "\n", + "linear_layer = model[0]\n", + "print(f'Result: y = {linear_layer.bias.item()} + {linear_layer.weight[:, 0].item()} x + {linear_layer.weight[:, 1].item()} x^2 + {linear_layer.weight[:, 2].item()} x^3')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[ 8.3718449e-01 -5.9105339e-04 -9.0548664e-02]]\n0.837184488773346\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/svg+xml": "\r\n\r\n\r\n\r\n \r\n \r\n \r\n \r\n 2021-03-23T16:04:59.244539\r\n image/svg+xml\r\n \r\n \r\n Matplotlib v3.3.2, https://matplotlib.org/\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n\r\n", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "print(linear_layer.weight.detach().numpy())\n", + "print((linear_layer.weight[0,0]).item())\n", + "def predict_sin5(x):\n", + " return linear_layer.bias.item()+x*linear_layer.weight[0,0].item()+x**2 * linear_layer.weight[0,1].item() + x**3 * linear_layer.weight[0,2].item()\n", + "\n", + "# print(predict_sin5(2))\n", + "import matplotlib.pyplot as plt \n", + "plt.plot(x,y,c='r')\n", + "plt.plot(x,predict_sin5(x),c='g')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "99 494.2001953125\n", + "199 222.24923706054688\n", + "299 131.94528198242188\n", + "399 73.64026641845703\n", + "499 37.08171844482422\n", + "599 18.956501007080078\n", + "699 10.892595291137695\n", + "799 9.057557106018066\n", + "899 8.854501724243164\n", + "999 8.906543731689453\n", + "1099 8.938582420349121\n", + "1199 8.902544975280762\n", + "1299 8.896836280822754\n", + "1399 8.908731460571289\n", + "1499 8.911303520202637\n", + "1599 8.907160758972168\n", + "1699 8.908832550048828\n", + "1799 8.916685104370117\n", + "1899 8.927263259887695\n", + "1999 8.922130584716797\n", + "Result: y = -0.0005175599944777787 + 0.8562414050102234 x + -0.0005175702390260994 x^2 + -0.09382987022399902 x^3\n" + ] + } + ], + "source": [ + "# 6 使用optimizer自动下降计算\n", + "import torch\n", + "import math\n", + "\n", + "# Create Tensors to hold input and outputs.\n", + "x = torch.linspace(-math.pi, math.pi, 2000)\n", + "y = torch.sin(x)\n", + "\n", + "# Prepare the input tensor (x, x^2, x^3).\n", + "p = torch.tensor([1, 2, 3])\n", + "xx = x.unsqueeze(-1).pow(p)\n", + "\n", + "# Use the nn package to define our model and loss function.\n", + "model = torch.nn.Sequential(\n", + " torch.nn.Linear(3, 1),\n", + " torch.nn.Flatten(0, 1)\n", + ")\n", + "loss_fn = torch.nn.MSELoss(reduction='sum')\n", + "\n", + "# Use the optim package to define an Optimizer that will update the weights of\n", + "# the model for us. Here we will use RMSprop; the optim package contains many other\n", + "# optimization algorithms. The first argument to the RMSprop constructor tells the\n", + "# optimizer which Tensors it should update.\n", + "learning_rate = 1e-3\n", + "optimizer = torch.optim.RMSprop(model.parameters(), lr=learning_rate)\n", + "for t in range(2000):\n", + " # Forward pass: compute predicted y by passing x to the model.\n", + " y_pred = model(xx)\n", + "\n", + " # Compute and print loss.\n", + " loss = loss_fn(y_pred, y)\n", + " if t % 100 == 99:\n", + " print(t, loss.item())\n", + "\n", + " # Before the backward pass, use the optimizer object to zero all of the\n", + " # gradients for the variables it will update (which are the learnable\n", + " # weights of the model). This is because by default, gradients are\n", + " # accumulated in buffers( i.e, not overwritten) whenever .backward()\n", + " # is called. Checkout docs of torch.autograd.backward for more details.\n", + " optimizer.zero_grad()\n", + "\n", + " # Backward pass: compute gradient of the loss with respect to model\n", + " # parameters\n", + " loss.backward()\n", + "\n", + " # Calling the step function on an Optimizer makes an update to its\n", + " # parameters\n", + " optimizer.step()\n", + "\n", + "linear_layer = model[0]\n", + "print(f'Result: y = {linear_layer.bias.item()} + {linear_layer.weight[:, 0].item()} x + {linear_layer.weight[:, 1].item()} x^2 + {linear_layer.weight[:, 2].item()} x^3')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/svg+xml": "\r\n\r\n\r\n\r\n \r\n \r\n \r\n \r\n 2021-03-23T16:15:53.888815\r\n image/svg+xml\r\n \r\n \r\n Matplotlib v3.3.2, https://matplotlib.org/\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n\r\n", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "def predict_sin6(x):\n", + " return linear_layer.bias.item()+x*linear_layer.weight[0,0].item()+x**2 * linear_layer.weight[0,1].item() + x**3 * linear_layer.weight[0,2].item()\n", + "\n", + "# print(predict_sin5(2))\n", + "import matplotlib.pyplot as plt \n", + "plt.plot(x,y,c='r')\n", + "plt.plot(x,predict_sin6(x),c='g')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "99 560.31494140625\n", + "199 382.79241943359375\n", + "299 262.6877746582031\n", + "399 181.34494018554688\n", + "499 126.19588470458984\n", + "599 88.7654037475586\n", + "699 63.33283615112305\n", + "799 46.033226013183594\n", + "899 34.252540588378906\n", + "999 26.221017837524414\n", + "1099 20.73921775817871\n", + "1199 16.993431091308594\n", + "1299 14.430941581726074\n", + "1399 12.675918579101562\n", + "1499 11.472537994384766\n", + "1599 10.646467208862305\n", + "1699 10.07874870300293\n", + "1799 9.688159942626953\n", + "1899 9.41912841796875\n", + "1999 9.233620643615723\n", + "y = 0.01773737370967865 + 0.8454191088676453 x + -0.0030599930323660374 x^2 + -0.09171997010707855 x^3\n" + ] + } + ], + "source": [ + "# 7 自定义nn模块。进行forward、backward、optimizer\n", + "import torch\n", + "import math \n", + "\n", + "class Polynomial3(torch.nn.Module):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.a = torch.nn.Parameter(torch.randn(()))\n", + " self.b = torch.nn.Parameter(torch.randn(()))\n", + " self.c = torch.nn.Parameter(torch.randn(()))\n", + " self.d = torch.nn.Parameter(torch.randn(()))\n", + " \n", + " def forward(self,x):\n", + " return self.a+self.b*x+self.c*x**2+self.d*x**3\n", + " \n", + " def string(self):\n", + " return f'y = {self.a.item()} + {self.b.item()} x + {self.c.item()} x^2 + {self.d.item()} x^3'\n", + "\n", + "\n", + "x = torch.linspace(-math.pi, math.pi, 2000)\n", + "y = torch.sin(x)\n", + "\n", + "model = Polynomial3()\n", + "criterion = torch.nn.MSELoss(reduction='sum')\n", + "optimizer = torch.optim.SGD(model.parameters(),lr=1e-6)\n", + "\n", + "for t in range(2000):\n", + " y_pred = model(x)\n", + " loss = criterion(y_pred,y)\n", + " if t % 100 == 99:\n", + " print(t,loss.item())\n", + " \n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + "print(model.string())\n", + "\n", + "# 主要实现了在不同等级上的抽象。本层通过model构建了神经网络模型实现了前向传播、自动梯度计算。使用torch.nn.MSELoss计算了损失。使用了torch.optim.SGD进行梯度下降。 " + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1999 33.18156814575195\n", + "3999 20.196273803710938\n", + "5999 14.039202690124512\n", + "7999 11.19318675994873\n", + "9999 10.00029468536377\n", + "11999 9.34005355834961\n", + "13999 9.059755325317383\n", + "15999 8.731332778930664\n", + "17999 8.888145446777344\n", + "19999 8.854000091552734\n", + "21999 8.832571029663086\n", + "23999 8.844922065734863\n", + "25999 8.65311336517334\n", + "27999 8.838438034057617\n", + "29999 8.85017204284668\n", + "Result: y = -4.497888221521862e-05 + 0.8571422100067139 x + -0.0005409775767475367 x^2 + -0.09365808218717575 x^3 + 0.00013697342365048826 x^4 ? + 0.00013697342365048826 x^5 ?\n" + ] + } + ], + "source": [ + "# 8 控制流和权限共享\n", + "\n", + "# -*- coding: utf-8 -*-\n", + "import random\n", + "import torch\n", + "import math\n", + "\n", + "class DynamicNet(torch.nn.Module):\n", + " def __init__(self):\n", + " \"\"\"\n", + " In the constructor we instantiate five parameters and assign them as members.\n", + " \"\"\"\n", + " super().__init__()\n", + " self.a = torch.nn.Parameter(torch.randn(()))\n", + " self.b = torch.nn.Parameter(torch.randn(()))\n", + " self.c = torch.nn.Parameter(torch.randn(()))\n", + " self.d = torch.nn.Parameter(torch.randn(()))\n", + " self.e = torch.nn.Parameter(torch.randn(()))\n", + "\n", + " # 这里的d,e的样本值是随机的，表示这两个参数锁对应的样本值对模型不会产生正向影响。所以最终结果应该是0\n", + " # 这个实验也说明了，可以在正向和反向传播的任何波分添加任何控制流。甚至可以跳过。也就是说，构建普通神经网络，不需要像构建卷积神经网络那样，以层为单位构建。而是单纯的构建神经元和计算图。\n", + " def forward(self, x):\n", + " \"\"\"\n", + " For the forward pass of the model, we randomly choose either 4, 5\n", + " and reuse the e parameter to compute the contribution of these orders.\n", + "\n", + " Since each forward pass builds a dynamic computation graph, we can use normal\n", + " Python control-flow operators like loops or conditional statements when\n", + " defining the forward pass of the model.\n", + "\n", + " Here we also see that it is perfectly safe to reuse the same parameter many\n", + " times when defining a computational graph.\n", + " \"\"\"\n", + " y = self.a + self.b * x + self.c * x ** 2 + self.d * x ** 3\n", + " for exp in range(4, random.randint(4, 6)):\n", + " y = y + self.e * x ** exp\n", + " return y\n", + "\n", + " def string(self):\n", + " \"\"\"\n", + " Just like any class in Python, you can also define custom method on PyTorch modules\n", + " \"\"\"\n", + " return f'y = {self.a.item()} + {self.b.item()} x + {self.c.item()} x^2 + {self.d.item()} x^3 + {self.e.item()} x^4 ? + {self.e.item()} x^5 ?'\n", + "\n", + "# Create Tensors to hold input and outputs.\n", + "x = torch.linspace(-math.pi, math.pi, 2000)\n", + "y = torch.sin(x)\n", + "\n", + "# Construct our model by instantiating the class defined above\n", + "model = DynamicNet()\n", + "\n", + "# Construct our loss function and an Optimizer. Training this strange model with\n", + "# vanilla stochastic gradient descent is tough, so we use momentum\n", + "criterion = torch.nn.MSELoss(reduction='sum')\n", + "optimizer = torch.optim.SGD(model.parameters(), lr=1e-8, momentum=0.9)\n", + "for t in range(30000):\n", + " # Forward pass: Compute predicted y by passing x to the model\n", + " y_pred = model(x)\n", + "\n", + " # Compute and print loss\n", + " loss = criterion(y_pred, y)\n", + " if t % 2000 == 1999:\n", + " print(t, loss.item())\n", + "\n", + " # Zero gradients, perform a backward pass, and update the weights.\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + "print(f'Result: {model.string()}')\n", + "\n", + "# 主要是用来控制封装好的过程。模型中参数可以自己定义。使用库中的函数，函数的参数会自动参加训练。使用自己的函数，就需要声明自己的参数。" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": "
", + "image/svg+xml": "\r\n\r\n\r\n\r\n \r\n \r\n \r\n \r\n 2021-03-23T17:47:18.760876\r\n image/svg+xml\r\n \r\n \r\n Matplotlib v3.3.2, https://matplotlib.org/\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n\r\n", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "def predict_sin8(x):\n", + " return model.a.item()+x*model.b.item()+x**2 * model.c.item() + x**3 * model.d.item()+x**4 *model.e.item()\n", + "\n", + "# print(predict_sin5(2))\n", + "import matplotlib.pyplot as plt \n", + "plt.plot(x,y,c='r')\n", + "plt.plot(x,predict_sin8(x),c='g')\n", + "plt.show()" + ] + } + ] +} \ No newline at end of file diff --git a/pytorch/实战/cifar_net.pth b/pytorch/实战/cifar_net.pth new file mode 100644 index 0000000000000000000000000000000000000000..e8b5345683868caef5298ab567105c52cdc97217 GIT binary patch literal 251391 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¨c#!r7Ybk@;IY#J9qWa#3zSVL-sNmm7KcDTAfeQzhlm#t)BpO zYj+6kLl!{qVYy@*-vGh;Wb$W!hOt+BPg!(&HGSRW#xqsMLvDQso}OcX2Y(&HF`ces zZ?8?T=ZTc5(pILH%scd|ZvzBv55;)p-TZT|1E0y6EE5htq9!h&pmVlZ80Us<(>wFm zpvw|>eluFFdWh1mg|s)4l576^glGHpx!>0&D!4jW93MA@K8sp#X22xjp7I^mHfQ?u zAO-Uif+;6TVnuwff|8k!sAh(A54iqEX8*b`F84nUo$5B@>b|8F-fvIf9M{n}^kF2u z4C#paJ;&gQ?hg3y>mXctHH^$Brf^)UEq1DIhGQ#ipigfDv@8sO$cc$qr(cW;OQ)ev z)?*=F%Y`G0r8~QuFTN<~4;=?43C_RLh0o_4gi|vH;(x=w$q$%x!;&ZJyngvBF-@AV(Hi-;kWRdVh2esd*y|)XM4)!j_{Bs zj9$WpAO2BvR~1oSsKqTAqba^e7$2Kqhm!VyCoB}u@Z|y;dcutx17_on0voi}*o}9m zJw>ZN>9U(z8+h#Lw{$W{E^){QVxbnGLa%;sA-IW?Y_0g+^>DKPs>HGrM&x!zn{TH& zivB_otTC7T6r<9_Z3|V{K|hT(JI8R^z7Jwcv=xsYsm9yo_SB*)iodKz@qza_QpY(0 zc0@mcN9QH}-MDZ#^*szcek+&zHcjWag|3`mDs>Mpc(ZX(BF}n~#RIygi07VJk+1$j z$gKE6El2yplq)N_sBb2XKDiAVW^KfK+gIZssc(G!l$2-Iy)As%ydKM|9E9N^PX)Ky zWBk*46jIbz^6A)#_G@nD313P$dt7Hq9WV)2UwI)PI8K|++#Je@^%Jo1jh}Q^agLjj1_R7Z%gt1-^OOXM5X8J;f4oIqiTMCt6^V zvN1+<9{}=`=5SEq3@lG}#cb1#4yS%=IMkdCKnuG%eDbXU*1L@cmu^a8Vk4o-o<~qu z*CzR@3VHQ8E%;tnj29&4WB;3;9NB3nm!B4d3nm+5*#SgM}zs6Sh?o4(ErLs2v^L9ZW&UCQ^yYGYdFw-`^8chS_Ahv zC}C*i0r{}2eQ~Lo3Lbi!inkn=Rn(hZr~1u@@zMkragfb0j4=y$XNSKKy$+N?LgFnRaJY(^`;X`aZW)N{!7jl^&e~}@8<`(Vw@a2EbpOf#CQyQ*PR!tEd_(0IfiLjZq7kiV6VuJdzj-PhcmLzr%tlz^B>fEODYG<^v65BV+6NrrBrI2 zz#W4xN*wKHLf8W7+5Q-XmeEJy?ZY^#@1@Bv6<&&Y;ucDu_knUV&d~{nNIJaSUD|<6 zrfZ*9@#63{5>NbwqHL0Rn5(nzmY1-nCW>T-4w2{Y8gcn?fhWfwC-+ex++2AKY7b1p zw)IoUx<-xt9S!J5mIDoptHte;w0PyEIBD-L+3@`B>79)xt_Clz7%lON)!wu1I(OmA zgkP}HKb+;IyZMmS7jF8x6Jw4%LM#{98s3K*zv!HlS3!k2#n4oY_C5p(a#HQyUUmhLX9t@m*#-m@opz`T!c$(Bi2I1y+=lfhTP!|M`25FAu zH$}W-zn4l2(&?R=zWgWT zezGAgNo(`UFOu(Voh4gyIh(HU`U-1Yo$1L#t8JDe``I>ZNugn@r!Cmh}K1=Y~s_}uYZIq~H#_|>)>US&>RSz5nXZ+ZNI`8m|N zThjt4*zC+>XFY-TRyE%F;uIZ{X7_&wrBmd5Kb-xfk#20QqL{$bb`begYoMpRdOg8 z#G17QwBfTJYNrKaR^UWrYvr_1tygX)!Fe{E@OSfo64`GPF@Q%w@UkmJZtRW+yZf5bLg7eVch&X z9p)5{gJa4sWqTgI!O=EV@L`H7j&E6qQ=h+wk;4XAgj1wj!%PU&S?j`cq-` z4GuE&rd`4`UT|&!7f5_2>zlo3hZ2(e)p}|jo=qW5XZUQFCUMed672p-UF7*OJZ;Q- zs%cZjr}^(`%j~r@zj3$_9-NCu=Uf7VW2*Ai4*f(o+uKmmcLxquG6(PT#u&Y906KS_ zjKeSYbI6X7cHB8{r2V;o;T7sIr1G{{WHkcA&YSUkJ&8jyPJy#GC(!J!$N7Ae7O(aJ zHhU)dQ0WMlA5y?`p?3T)N(0YbnFeDoYoNiem*S|-7GnGz6O4bOC0l89npJayT@%HsV zv7^p0iP`K8?dcD|Zj_W?FrLKJX3MYo*}y6FWNv7V=TY+$#kwhK5Z(U*WOh|YSC<)} z-(v->v@C;&NHb2o-Cxv;Jp&aDMR>G88z1?)!u^3WctB4JJo}*mR~`+c_4leFNZ8DWC`$9(y;&*750 z;U8QZevk(m!5cF ziyp2|c>?mxp0uJ_;II}Ap>p9fNNMSc8@Fi5Pk!r4A%D~0uB99Her_nZD&2#S=1-!- z1Ydf2&_edqZ5zfpMS#Aileqlo0*(@!pxRPXV!00E`_3Q5A9g$W^zU+dkkU!odwv!= z#M(2Ap3GC9*>gtXQmkvwr+JzJyPh+bPg&)H*IO-dYjz!Ub_#=m2bT!Fl1)+eutc2G zHHSV=mG-yA8KU*W0UY@kvFNfE_EA%id_}SJFGUlZ!<0euLnlluSVR8;JJ4;1MdV~L z2zLqAs8|vy+}Q-=uN*GSl33W5_WjxXKQDYS-~b(*G*IUA-T|U!9)v~F{`}wAMS{jw zQ=Y%AKabTq1KLxG!Y zu5K$}|M*q(N!n3V?(d1A6=nD&!yjW7&gAi>RdhY5D~xb7gau9ez|cBa_FwxKFz)FH%v-tu`{(qkRQP$6lT)Ou<^XkU zch0~F*US8DqZ#l1ZAbab^Vve`3AEa^;+x2J%$@N7Pka6XoiBr7WZVk~UKE5Gt9N46 zy8TdXBh5Lby<+#?H^jpm7NOG>9e9FABp)qM=NCTs$IAo*N~U0(>PTr%s932{xrpY) z?x4SumGQ5Q7T@eTkWFuta>A56j%yxA{&H!k9y}HQT#JRGe}MBdl~A_+4@j{vJlt_1 z{@YTESG%f^^<-W2PeKefUxxQvw#&D6S&nOUe5rn>rf@IE858f1fOJhO9+syAGjrnL z>cMzWn>Y~DpB#WaF{Y@~#TFlQxGZkyJXDC-E^$-KQpvpNtze+tgO@$%jpx@!3GHgr zskHqV=oK9W$Fa-tx~~%+IhVuRJr?kE>%+K0MG?+Fw*j5ryZC*EH|lzKz}l1$JP`Vr zylrjKcSa&)yMCfGi_VBAwucCgF;3WYJr}m_)Wz{a1h1U9m<@iJ@J{8+&=#^5uYIcq z&t0XoS<{nGY<9=LrB3*LNeAkD+Ji$+ z2yQN;Eu(hhvCAjXP|(7jSL5UcXFcZ1Pq$q)L@1f7nrpjlsS(X=iV z^9DCTkKQ``*X|H)`K5=&6AuWdT4rHh(s%j&B{}^2%{IQ;Hjv6gQ^<2p200Fo!Zv|hE2*Ib>#YF#^{=F)YP^wgNI_UXbt9?xN)rJ4BIG8B!As$oEAh;Y_w zlo+4n1g z_TcTHvAKp0sF-q8*MPW2d}v(xsu{8gHdue)nt95cPmt2 z=d1*nG0cL;`bpW@eY)h6XNa#ZM1q}bHfqXy2|HpHF++b0cxKdrv$q{4I$DTH5i-0%?M}U!7pWBaT-%w@uzYI%y4iX|$ zcVfF|ws6JD6<6PSi|4zRW65i6Y&P}4LiK#Ho9$P-u&f&p^wLgnjsrBf`U^I_8-XEL zOX0BTO!4Qclep~TL!2eCd=%yykVmuycfFv76;};l{MBsP;fi|7wYY`BJyX!-?>^M{ zcO3nXX*htM*wBspC`Hio$;;8o^et@nSLQLJ*2y-v?&Slk zckwqV8+S{3pJ|6>@x%$4RH}NCvW%=bD0?9v{bIt)O)T-Ib9vmv z_mt@+P>)k?oHJ@Jg!;^Z=Hi>O$u|vobFvO!{Lq~P)jokk;#kU>(MsKoN8(G%JdC_| zQPxFU3%{k-BY`!Rzi))q>t4}Ki!sn;mgEpGEN87AnY^LH2Z%CXfX|m_uv7b2zA)(} zWoebty4sDPn5YZyvdU@1&E9CVG?3?i@5{eZcjL5Er9yCEEFN!fle4Q1-UuevIlYey zpFcUXF6^Vw<3S$(9wzmG<%eKV-e7e0ehl|L!ugxD%eXY+0zH@bsTG0h*z(QD{sx@E zkl*=W-LMYl3^@pWO?u*jf`0PeBhE?RJLWKT?F+KjzASYT6S2N_7B(L%!i1C-IPbLt z71wK^TAdnOd{Acp*K_czGz&9b97jd{e0kgYT4Tya= zTq3hHoiBgpxr1I*IpAtzzob$qEe@AdqP#3s&1$b2OS8-ea z3Ak~6D)*eckxiO9aj#cDL9sF(HeVsm$@n97nVreIio0=o+Y5L#<1qEyIE6h1599qm zjM&JzJ2t(YK{|VN;NZ-K5PZ;+Kfd>qr6|idAb$-l^o_;(?_PLdZV&3YeO}DF+THYX zR~;9wn84k}Pp6hKwSui}Bp(`mLU=s3J3Gf7;8}~l!;>0Y$tz)myT*Kjx}GugFtCK; zzeK~)aZR8<)C}Rmb;_JJpNg({)6LUEc)_|`@-3?Evi4^I_}^hQiBH&@HycSz7~MtO zsi`MsI)Rh}l?$&GEk*6lUGduQIe2HAC-~evYHwsECZ^ zepxGAf4d8(*j|*qxuT0-1DDDM-dAPUl>P8kn#1tx9O05~M_#_yljJG+V&$DWYPsb> zs}_6|sO?UOk3rLVC4MFhDYPZ9<_>B8l`#&Ns80#A>-POID% z1OuNM=_RayK?TGaWAG>T+x9 zRI13Cz+vMgXQ$&OVc?%+n47*&-2K!9eVX10hCu_MWVIU(>g|lJsuC+_{SUg67fu~o zo{GL(Z@`TcF(u7}%){qnFkqfQ0}yrHpKxP5v6TaE6ClRhjV9VyGX-=-IL+0YL^MGWS| zF%#M2<#$ke^b?*3599jm-85v%2EHhh?tQ80WV&aR@Mp#ho~JjRwVr(xQl)3?pt=_C zw(L$v8oUtS*u$$o%Q?WKH-sLn0@WQ|_}k^R)EKJ5*F!DQWE|q+w&Q~7y8c-9+6R9$ z#p9EciPW^WKgRUi1?7_OD=b!nYEKu?{-!XvGG`txsH~M7L@BJ7u0xqB3B2cnF08b< zFX;P+aHuu1_FWweKCQtq>x21vX$F(V6FOUV2=X^{W#!xk`p;$>mz!FGLRB7Eet#lg z*3VyPR>`B@zsC#4oxekUx(oP^GDNl8`8c8P9*l}K#Zk(>*x&Jj*wVY7FjMM7xemWi zcb`tcbD47a?5Qv4pJ#)x#O0y*D>0lKZ}k?fYFot7LEXjYr!Rr(3VZMqqc7{ENt){gqdny(!p9v<@f57hG zA24!}4cavuquuwppljyE9m=l@_8-jf%HQp@a{CX#=}8h>YaGC&*Qs=*se)&BUchOh z2M>86z1w0l=&s~-I#gW}2}@lJgn{1r)S5RJP3--^Mmn>FbgvaX2ItZbJW4umTHuXc zSL~Kzjhzpub81#E-n7<4`fNJj>!c72tbYj`ELVW9!9aOpZmy_Qc$;>wT}S6*mcjMF zF&r(vhx*5r@Xh@K{2X@yOx^3Li<23D3;ZK~cQfU2H?GsS;DKU|;7?;t^nghV6(pxj zGkiC<0vB5WNWqmuyJ4Go9NxIN7ZXjR@Or8a zm`w5KQtv|U5bna>zhl_*-wUCB)CF;AUI1&Xyae&5x}ejsll0%6U2JJ_Sy;Q)0z7|Q zgR8!;$Van*tbE;M#&fg4<&Q4kzg|Ssj%$GE-;E#5+DSndoW;63t8m2K8t7{`mSaj( zInj0`9SU&3!)DJw?ePgvw@wumt*?Q+-4&Lt?#M3L8aOkij{3r4y0%}3JJg=1#!nB# zeTz>E1JfHRcd|D)Z95KqJuC&2t1pGD(EyB`L7t?<*L7+(mLtW=U@70PbQIMWd!kJH)S#>GYxFbTCO`VYnZM z*=yg?_T`4`f5wdmRqg_H^=ewK13c;8xeABn?}WbQ6_ntv%`bDuuG(qggJ;$42 zv+{4SFdoRp8Qo~^b6t-7`5Vr5UXHqj5f~Pk0vn>X3u(F%<4tD@mYAN$))h9`z9kuF zxcFkftXS?JZ^~->9p(MYBdBI`2e8R{L$~T2;E8m0x}17Ir0!`n`=lt%tfIuRv481W zPCqac)v)PBJ&o11!mMU9^hypF$M*dOvtca#uuX->_q*fup*x{$iVY8y#!@@QGB~ZK zOHUNeu=Lrp^=V})j4|N-2O0$Lfzx=<>{;-L2jIN30kT9~M1;jd8K}pcw?npt#gD2?Y9BZ`=c;*%5Eq*Ih$`hH-kgo zN2vPy5STaG1k!i^rVYm5Xh_^^vfgo-QjS{Ti(b8@xy@~wWjT*5r4B`9i_|;G>c9)n zU!ySXA{dqOpX~kVXY?a~Ihd`N*qEKAs8;ZHo_HyNTy;LfdZaXO0(0O_3(GgbTk_Oi!OyNq=dd&e9ZnBE_`HzY4(!us6!SQ#9gM= zk>OY|TN9QIyaKB%)Wu@$7L>hSg^SI4!~On)ahRSQo;j)sP5PY-b8#jKGFq3uDJz2$TJ>Q@Al|nwu74^2u#Q~e6<*%Z5$}7Ay z@$QFoVZ75C@*n(=O3x%f>xez#os*9_;7x-xyG)=HZ*}lvMKAQQtE5XmeR*h|F55dQ za@G1QJM zLJU+62Q;>E7gEpKLC(kiC^hM!S??x4_+r5KyBl%g=}ew>$et(3`tfr21ZtnuM4j(@ z@wCE9A>-?7akq`T*zd;!0bczDJ1NuUSgJ^&nyI`lMWj8Y3*g6?6Oa}FQ{DK&KL_mcKo6%$fA0C=51pTHfswao z;=_<|RCChB>P{teVX-s%PaaRBGgs5WyNa0FEbaH!To4xBe+ae~hs0Iy7jebA3&M1h z#i(&}I}D8&hMqmf!K@cH82hC=&$jTyS(B%r-PvgvQCto=ThriU#1Pot^&#!qG=N5y zDZ+8(4)}i83S84!;wInh!jIiOq-;be4GuL#9XD4t_P7FF^it8zcr+VkP2e>bBtG53 zNnG$_B~RJEjsm+$u0~k~m#r(~$AdiCFtZQJPyx-KMe#@TLJA$Qgk6WIi{rHY;krkw zcr8XwEPy z#GgB~K(}G#teeov{f*uE)Q!O`JG+Qi46TM^{lAk+#8b)BdrJEKD&X?8{UDC*MDbg@ z@K2usJbRJ=gX(hW`x9$kxnMo&tV*YZe&IB?*AR5PX#~7*BxzQ*3f-bhMODu*`Cae4 zGqC86uye-@m?_QwpD&N%xk-z-ajq?XxgNj|6p(*!s|NW!FNxPbk(=EobJs!nWZo|I z7rQmk5~Hnr{8fhdqFfI@Epx?L4qbWN>|27-iA1>NzK?R(KM_L5%mv2}YL(VwL^!G_ zF_L~o(Zc?L_{u=FGWgwAxD}EQOD>kf(BVCxEVP+l7jEXPnj<*rb2Np&_9y?GM`rWz;Kg13bXRJ@c5aYwRNywrBh4oZ*JsNX&c0^C3 z9iX&jj$qRoP8u(!!tF|B&h@h4+Lc9EEbUh|4e1KW(@7-%1e&$J77L_7cL)8G7-x4H zKd9GWnT8U)2)F`=9^ZkDu_;)yqpvtN@inBky@pBqdU4LWlk`-19SwMJS?E6A4#%Iq zh*xraG3eb@_-vda_66TGP$_5jROG{M z`*5{YE*@Mp3ym)+VriWrW%3~sr04kNu|E*Jd9zr3K?bW@4$%ewR8Wd90lz+vNoigK zIiJ)dyipFf9_^u9vtx19UR6Qk+hS7f;?4udM1xJfCG~l1jONap@zn-xJl`i56JwPf zwtYN?L(Su$NoNI({Br_-t(q+UJim{`XOauH(j8Mw+$ct?kalGB;K0~Iw3%8hdM)1q z>u(p+_dO@TwlD{en_m(pm~^6^kx3*!Q9yMMqWG?tJKfV)l3Aw@q>(EWFvw~uJ7ztm zckgHL%xVq3KItK~?DwS&wy&u@yf`Oh*^ZJ&-fp6eEvXa?7Vx;_ZfN@R#mVx31=6&D%0w z?D0bQdhRIKYD}RoKNQ%+Yb0&bETr0>?et7%8eClAM~^4G<5|9KP~>6GgKg%~_ig&* z60jS$O*sSq=0xJ2#&bgQ*E3KME9KLM_+W4M9$0d-0*pHs;F|e;@#49@xLr>Ht4EFJ zoIQ#3LgyLePDAWwqW~Ij-NoeaG<39DgOkUMVps99eB`(;sIS zMz!)olo~gTJi^A`eo@#S5KIQPbcs`KFACJbg@mxVGl2xN?Ry2R;eF zx|*T*@V=pN@rf2hr&S6@##-q1rc!#geQEHRaGWl^-?MTPY5lceZe6IzGdx^qkmL^8 zr+WnCbB@rA^Dca^&I~>F6@c{(O?1ps7B<^~FhsEv1==MG)3aa7-is+@I!o&OAGX0o z&waotaSwf7;33VO6sYt_2W*l@g7MuBxZq!^Fg!@gf1XYQi{0^1B=tLXSXhYO|C(W! zTL&C_bpZU`yovglDWd89NO;?;kwW@J!BTk^E$CD%-q%RsV-n+~e7_ggyy+^Y-^#?# zs|CE6<0{S?UW8SBz3_dN9MtcxMdMfh(XtDYBcQGY0zYcg-4};&+;2y$$-Br|y}EJb zw*cOAAXENXXAitHOyzK=AEdhf8C=niAOph$-d}Q?f|Cb`IjVo?wpBD1q`oE6u!L-B ze(h+h%ZDGop{eU6SJI-L{KY7oXKp!#V{6XIijN%S_o8WK;FW9+${c{3e*XvinhJUL zvOHRU*NPW!QG$Tb6VNE-1KW-A>EJR&-t!}l;-xuL@24Z!KR=k;h8w^r)y0_L>ksjU zeevG%^7Q>yr zYWO%z6Ho4npaBs|_~5YyeS7_n<}{4qCx?~zz{24|sQ)P{SCY;P>sR8G7h`x;z#|$z zy$9=@Eh3LpJLnlXlpK{iOAH_xSM79Q70n>1vwtdI+2e+|dZ{CKQN9l`e}?j|bBn27 z*PC^h4iR7Y%J}eShPi?2ENqqfNdd96QO#V!|DKlqzMFI^s0oDVHqzN|FFA|G%i7Fr zxaSr>&e?bww9jvbe##^H-S1m$uv-*e#;UX3!H%q>*PZ@-*a^Kjfps{a?w^R}p~n_* z_xDY7*H6lPWqEO)#9y&bO6RcDNAP~6Ic~pN3HMV|@ncCR%9c0F4_+UNE|Zf;Np%fe z-7pk`Tt?t;MQ{8)btdlUoegfO(KLUR8lE}QLFUrWoJU4U9LS1t(c@7#pO<)dKhCD` zPGKKy=3xBR%b&N;o6H+Kouct$B^JfBrC2@tI6koW1Xo7iDJw2k5v31Q)z8F=; zAM;ZEZlb$65NImJ1sOd=WRlET$D7ehL?7Uxl~F)iJ%w zf#sU3*(h{1u8JIuer+)lGd7aH8btAMl`;6o;jWj@K{wnx1Xf;?l*1;g7o#K2)iSyE0BYqn;PL>p}fzL)+Vi${Mnm*l& zdd~3|kFGn4-@;dbUBeW7Kf(`QuRaVN_DVe zc0Fw%-!K}RrX8Rw)>6;F0?^TEJ3hIl#*rG5BPqUV(*sNCrh8~;r%MW&xihlM|o1We1bmT+c}WO?_Vk? z+WKIPmMNIt?nn~{xbyW70j%3{hW_m7z@{qS!ROpyUcLOYlvy{$zywJ4v15{hRmGz3qfL_;LLF=b3cqJkh-L!IPSXCp<(=p-Qi&g2Ld799g z=SQy&3kcoR;Fpw-T5UU*Pu|(Ye(_)EOXfUqIB)?9j_-zMjUrj|8YAjkYAF0@pTnkK zo(Vn=P&4$Yt2*dwW)4DoUxIIysYdQ|5XNR46)YcqYaIz0-y)}?_sjuMRm~{GB zJ&-d-e4%CueY5n%d>Y#PlZHLhg|tgQ=tffnTpBi>bHh}Guxn%3KJFouHYLN}vESiM z!cdyu-HQW;Ng1Mr9dU}(^!pn=1hdbdh2OIb(V)j*bm`s~^JZQY=8ciE=;~>Z{5X!L zZY`q3d+`vO@jwimR1PuyHUWgmsab3yWrrg$P1+yM`fdzHUA1_y6*3PkgCT>RCC58ZfU^UuP+T|Sujs{txT~QzTsb!x zFZBA|QV2Ilj zvI&b#BCzlz!wq0ntiyV$7ok_t9Q zL2-`~Iu}|1JGAvsn5V&eW-gEiUV9Dq0@55E4IKGJOFfLdF6AF{{uu&rID3)dutr9zJTLU zcWpJP)_sOo6Z`Ukxo<$re7A5(cM|sgs=#iO-T2|V3i>wnmg70~^OSfd9G^O7lK)9l zu01u1E*!PO(!Mj$_J=zzakwEW9_*L%xU;PAWi0gPq za)OY&(T?9=e@T-h&s)z6y1ai^p`bsZ6S=;Y@^{@bNMi(GJ?UZMId$G}yFjr2J)MH` zC2xkeDOJ`sHdl6=Yc0iLDHD2^C8rov*A@EmE z9ggVy^`bWFdIzWfjMKE!sDf^lUta$br zC3RcQ-E5>?*segb^^iOtea7O3;jK_~$s9fxRLV`B{-mYLC*bT}W1-HxH-GBXiM#Z* z;`s%@Pe%C_TW7C>+uQ1)%yljJPPr}?@12cZ+zQ3j--^YP7Z`E|dvS*TE&21VA7H^{ z1-=%>g4dQO()(4H{a;Fc_PJWvbo4fztsIRD0~cc7UrDHYMag;ccvBp;UE;mEC4=+k zK#Om`2KvZs9AIhf94qA@5=pkmO-yy zg>=Z_G3-%OX0yEyfmcUECuw(Ge_0=1zo`+NE(Gvhd7Ak6WGm&5NaVLk>tXkP4><2! zM2BxCz%uFGbvR8Q|ID62Rv}JY-e)o&yfjum=UY5=Y`RR1KDziW^*AI>oWb=56Uk?s zF%OOFiI%HWL1Rk*-Rm<7@6>z%`M5EZz1S7h&Pl#^T-6XkKZCmQ-mtz>rd}00j|(QRH^X_>lL_Q}{}s+IpNNCZrEcB# zm!P_02A3-xL)~W?XjF0<)uhh*3L^_{k6+2(aOy3K-Ny6neu@`n-N@k0YqW8P!+qE{uaZop=jq@*J^J%98NSYx zc3mB+#dSS@fur(nsJ2VuFH2|e$Hha$7Tp}mjP4Gp+R~n;#FEZN)`~lP{?L%~$2sn; z3Tto6;{8Rroc}b2PkZ}8#Q76K^o|&AjdkGPE6)nM{p_HxNe2{i;%L9BB`~r!}@S-P*0lu^Q*8soE^r!S`w`d7(a(=^yZn^Qli$keHmuIr2{tbf4_5(CGA`E+^ zypV_PSHRtQB|<`N1ag~&M4O)|%-efWw*2H2jCkD(ef}mQmuKVSrZqy!zf=x4vLW|p zeth+~BG<=1CxxWeAn_co=4KThHjzX%Nfw*}t4Jw{rq zCd=LKMuNhMQCPA5CfGP?@f)vx(DY#QgMh$;Rn`DFVDQjolQ8;*qXp~hVPqm;=_^~d<4yCq!WfA4FTt z=R=z{**{p~j{4*aEk0fOYRz1ZJwJnbH4K+>Vqc-sAXe%WF5`i} zA?%n5>%WZwivkBqyt*EhLT01u8X0@W457EX1ytI13jM4{q2a!0G+(j`PNc2H`p9l@ zUFHcZyG6mP0d5o-Y0GM*zva7hHsQAcmuU4-6I>Z_4vN*~;5~Oe4vVV;52SB16<4FZZ6R`HqKN_7slFsJk%Xaj$=ToWeg36t{a4gS|KbC!m z3;NpZ<5wm5P#2PFUj?k#^A0RC^I*zU1svxzjb_zbkx|(jP&x7yb}sr!rpspY$}11y zdt(pWt=yejSI>p1;RdkD;xWW;dIW)cz0e^sRs8BXm~X4Uq8=I!`0+=K81N*W=e0__ z)!+}p5!F(-zk8189}heCNTwdM4k6tVNv}#$}3qb z7FF&RKw~|PY%xLiqSw&5R)_r(4pN78e@X4y1mS~1IUiSYh8$ z-I+H<&BDRlCSDUw2Cd>F^2HKQJPmp|WzY+~5ft8I1eah8e`ymKQoZ@va0B{B z+c@p}60!e+MsoX7NtGdC)O*SoSiE%=O|{tp-&aq@>z(`Iza}p{4RNH^&;aohVsU8h zb-Cj!hPW@2@#GXmxLKhGRnnfu#^(uiv+g2gX1cLg*cxe(*nBXy^bQn!D-Ipj2pRcVnkBR;)jziH!e@`d9f1~ZjM8P(9LN6DTLpjBFaqCWCceB?*4r|U3j%x^tic9@aQ}M z8zOXRP2o1~kjU^mOP~GDq{8ow!PvY^A72Ga^Ojek7!|Jv|GBTCWl0h?`H}|y*}5C= zU(|!oL)yW>@B{8nKLY%k`ON*H1*aX-3Um${+TcuFHqwdD);VEXqLkZOeg?+5q>H9{lVmCW%J|p(Dr`0`RjFtv5m)9Z)UR%+a)gK0gM%b(6?+q1a^#qiH7EQZuwD+8+4gmO8$roZzOPRet&l9 zKa_ur_M>NxKGL(+l~ZO8ivXyIYxUgOTUk;Qm1$7@FQ2 z*SPu8&Nf53wEwi|5;2lu9DDJxYmXuDQZ^La(d68e_3Zs+jr{&IJAP(*PB`{JmrwW0 z6_1bU$$d8^!^{rqtX}IxI#H8g;@r#f>RMYVC+v%s``(e3p&6K;zevVkCP<&Hld!|y z4BA<~1TQ_apcUbf;_Kfrxb|nX#G9KW_2|`jVB8UYc)SIQQk?NrSSdaUJBts#OS{5r z5v1D3Lmc}+@&q*-@}q~fGt)(+F49& z=q-DenJ#4aTF1E!MWUr<7R|qXRy^L%AEzou;wyt#fcT@LRnKuwj{gR7P3&G+_pqH- z{2T<|pZil1vPEpW}?Ln!{gY#Uh;^>WPpmD3(ep8jOMMVr*r>~ zia~QHQS+B69KKuyC%kx08AGxlpayZwpimxvdo~uUOvJ1%rywhLpL8Fr6I4G*bAhF4 zG}S#0o}IWZJV~;LpujxR_+o&QPjA5~h0lZ?^4XZX+?>pB+F)^8FO1gf1~Y^pDvFCB z4>Mi*=WoS&^9|r($zL(|VFboydE&5z#$2tmNHEz7_-e&{cwe3eZVBEvKYu#yw>$;y zW9wi-<3_BiULhpci{k1LKJtFoe$ZD<1IeGfke}5i(#s1c$T!#>l@q#Rt>!{}WAdD4 z1`fd7Yrnx`XGKZn=*}?WgE2H&sq^B-WHF~U9BQPTK4 z>!oh!(cyH{PZ^ypk3gZ#1yP9EPnkSbbXmDrUOi`okgjo8?sT9l?wZjErBk25!5b2< zKiLkRbR5LCb7zY6{lhTq+hUlUHUKS*^mwh8J5Icmh=W&Yz{4>`y~b% znd+)M;)gOTW!b~#>8{*t9!gV_(;+1I0+l`;!LPETNVd=sCPl@_e|4NgIc;5djdLCh zUm(rpRz*^1_cvsA<*9H>t%0tZO~y^rYQUA0Ie5J#he@9AOOK3Ez41A?o-CvxZR!|% zGzogTc4HAHL)fq+>RB?1J#*|aJ7p_`sPrU-c~9tAhZEFW|DEt&y6?xBv`}B!Gf*qp zPMgN{;5$3^(N>3GVRV-tVE?BOI<|cfuHjU)_8W*!QijU8LQC4)%%J<7$HLwKPt2ZE zBE)9)hH(jMmrcZOBykWRg?W7gL>)J%liW$il>z49l+p*B=Y#*vU zb01=&yrlQtOHvcnIl99zXx^13`ekp0tt*tM*zPL4=rx8P>W*fk9nQF2!4l_s5jFW7 zfpTp#%sJMH&3b=={X!@?Tm6;z3y*2;G8Ms5vx2a&89p!B0excI1f9(tspAt}cAeA@ zraR2xCkvE$R>m@f_*e8L^EtfRY0dg~%%z@g6CB-mmTqZG#@XH-SW9xbYdU7bk-#$& zv-vVT$nVTP0~2AL#D-GyvBD_3To};apEta}FHRcM1RzH|D88Vtr?a4FXR6bQX9?o9 zUnZ#f-UvMkjCg-|nfT#)CS>eNqmZ#X`RjW_j+=bFWO(C6>Lgf*R~&R%&^rO8d257e z#)_D9EP!U-XqLG|i!{SSy5p6qaJ2V3`tx%HSOQw|298#c{m<*u@>gegy z#T?@PS1^f~2~Njz=u5OM+l=hZPXhI+CS(*3*^>nG#vG9iTD=wS-D#H%y{O4Po*mIv z#gj_x{=lY;;hZ$w4xQSTi$0+*sYq!UhCO@)vx8D4zqm6m4|q-9eJzA>yRF3nYkA4Q zU<kkhgCx;!U(B!)*##Z3-XaN%+pRCUjUQ%b*tei!cxzmzV(iCIJ0{L*2`mvBz- zjxM9-fA>f!cLdIyrq6>Xj>C@?XK|R$?2=tB=jrSoFMi!820OdYg4tIi@WHx{_@}g) zq6G`4Sv^LQc&go`wucM7{X1&4TdrMT-kG}cdv?Usg1{rE$WX|sYN)V%S5 zd;=~FStUNbw+KAyO>y6qF#Hg>n0;)^MTLsPymECuS3b*U`^?jj(;Uh@^cRc&rr42P z*dtQ@^OlN^=Fz*q&nb4Ao-p)R8e~X2&J`vmr2SHre>sh&Ocm)F$n4KH-N*17BXgV_ z*-GR4yK?ZLWL_Qdm)7ULr~f*u^5#Zm%-inGGrt}aV?5GG{H215>lPrqX(Lpy6&+n> z@u8W=#I14<)=IhpmfGF8vdeL{+BI0(ORwhBvli2Z!-r}2WL0>&$&gRH^`~nAhLElw zNfUbI_$R^22GoAi}!LZZ*6om%-6^DOlgVbfJ+#G)c z(#H3PX(9fcu~VP_ZmJg3zpLPX4+3yrQUS&I?#I&HDyTl!AD_jA;?LKe$kgNs1sO_Q z*rG`O+dq+eTpj}BRS@1sccptHuYq$!2JDN`qvI-}TvE~v_Yd8Tj#Dcf<}~i%TSei&iyPeI)<+Jacdwl=wX}0WkmFl#g3T~~Tpf>*|U9mQ!?h5b3 zcildVSABQG>={d_%QZvMX8m^IY0{Za)#iLYG{fI7#u2}PG6go;QSjX3D6js$rAI{`J zc)<^NBVPzBi$_AI=prGPXTt}Bu3VERv2lhL(XHh^{7rKR8%Ctly)V6Cn1`3-XrIC( zZSy$WJBu#sOa1vsTYUN30{$CbE^gZtEwmhz#zxMI(Qe%~&=e8sFrM?<0|mRIcVNS+ zQ^K=F8f;Si8J;Pv1XAqy1bP$yDbKvD{BOVa4 z14dk13?uRbv3g7}4!x8l#+WVSn-e0z?0p*y?z5R@tT;r*sa++O%p~l3>M->FHkda4 zs|UYVuZ1zXx3KwjxXro}~b@hxDj zs*{3-;eT9FwTE2qXmi5taN))B;S}&~92);yDUN)8QP#C&JXW2pg36`mu){EYbO9scILN*E^Iy`NzfL%XEsl*ta^EeSYm+lj)X6AETO0v*`M`^LdvQ2nZOTq;^c9~>F);6a^*_KE&(MzNe zabx8D5+#RTzkOo6#K!6PKAL||G?VtZqj6VU0#7rIgNNmE(x_g=PivZ~hy(b@nHstn zzLEX6CA01qJvNYBL?7LfIPSj`c8oaBL#!sS>T+8=UK~SqcNcTq`3c;1`7jwiSx&`) zF+7S~ar>!$vYhSDAaQyj)I2&wV^>}iHsB>8(ql4p2|6WnT}WVIFqlv7&4DZA%2}E{ z&|ATi>UA2Z>dGpy|Ay1_%4R>^o|g|Ny8aeqk*>V9$(9wDH&H~9H>6+p!cld3w07h% z8q_seuBNpd>Dmu8vV2LKRWvyJbv7F%HG-_icMKYK5D&jU%31XiC+_tsepK&+%@@|f zE#pF(KhBhoE&fElU2UCBHFn^!rf_s=+fEh-El|CWo)FR86VJWyr`~Tn^QA$vQ7+xr zRg>m$UAZ=I)DD#TFbnZzMI7!-oCvCi4p7$JW#E4}hnLx`rGvL)@!dTwvbcPgmSsfo z0Cxv`ns^J!mlV*m0o^$Dhn&ryuELy#y?El!2{HB8HAua&1+R=hfadce(cst}m^0=) zwg1V6-jn|W`PYf4Rb2zd#aG0a4>y9kpPuluIe-jr&!=hSPQvg~>8w6sOU}P<^2eCd zJmdT|;r`;;aJ8=+4!-JvFIMTpQriY$FTcS0#s(hOXv*CtoZ?R(HuA3*zO=`3 zGzNXDhdZ;n@OYJ(;QRNJIJ|E%{@K(BUf#QK1sL3*49`LPdw+oVpz zj7Ou*`ujL#S#PoS^XdJv*5r-2mx;ihpTj8X;I|^GYTH#rbWq7G$DvX zH!ZpNRy>~3MYd*>CEQ!-Pln=FI&J99Y8FSp=jD4b_Ht**4SGYs)kh?6atzE|RZC4q z?zFE|>a9M|2L7cbq=a>(4(}@9y5$7O)#*$dE;~wbZ_>GE+F0n$QGS^tF=LH21 z!0r1^G}iw}Mh*r%J~WFm9U^+}^Q%wS3XOoHtx6=RqbTP_b$ycTCyJmv2=` z^Smw>+I^mh{_7%WZYy46HRmMnV3)!8DeF6y{2PkDuf_{q4xNNP@;dB)MDIIqhCGH{yA9|LYm-2NyyDzVinr=1r%scYgwj{wwBlXf4o%W>~8 zT^v}o7FAR-;7igL>@+rpqpq*u-t~KFL7NPyc?;e-I;sSNn(5QYU!3^bgDilgl z;w*@(F7T~`8>JWThLPHC+>qOel~1kWy{U2h z?&EMc?)IG;l#lV<{8Co`>BfHs=JNjKM(krhijVqAB*h4Ajt-Do)hw?pDM2W(S2X2prl}eMu9*+I_?8pgH|MLN? z9Vla)0e{IjKL8eY=m4KWMTnj)!{diDXoJO1G5l>Zgq2OeU5#BRyCMd<{ve^3lM>#armb0&~%}!x0#LselR+gYjs9AYn4Liu+VmRFDYQWj2QiZs>Z}hjym>mq2Imuug^glKVZ*v~a$lfD< zOh~24J!Zp*&HeZ;S#Ye^DS2eVQMfn$HTjbhU1+gmlZ$i2KNFh-ALaebef2u&6=KJ@A3iW2jcy zD+HhoXIJvh3 z;ggG#Wk1_Agj3JLAVkfdn||1Gzr7-jId+czJUT^o*104`_vGb{O8h)}G0dwt3Gv%k z3Js|#G=D?}HBJn~z8;^b;dO<)#AKx4V>|#ZHtfNis2G%0MBtPOJ$XuU1?0T>C(bK) zOo{UgAw%l`eSNwaWY1>8_R^(P;ocLCbDZd=`xh$f7(l@}cVO49!DxT)Am=zEmqpmJ zZIcxjocc?r`+7<{>wI2!ynr+7N;o{rPBcrJh{hW8KoYUTgK#U{S}MaeZx_)8Y5#a- z!zHp_BX#<=_7j%LH^C+=i8tCly`=1E6s8|v3VsC=d%DYZXy3gTTn`*4xDN%b(PUVufX?WoW1{iL#{1pC`M z;`AF|>E^qByxApEG_`$#^{xi|&qN9B%GQ!;ZJi*NRnfI68!5Wa82pv8nJo?t#^g8g zqWrhSnr$qmerIRNzw8gj7Vl~N&g3Q?DfuRMY`P?Cn%@eYrEGAeU#<|cR1=n7S}ex) zOBcJxsBqnqsl3*rgz^TC;jU*U)B31tI9pvp?&U}11!ceKwxg8S-}RoPi4mly=%Y@| ze`MR5$i7Zv1ou{bSTmp$v=$Cv6QPh37j#Cm7gDAOM)2XCN6BJO5?OE31b@{l@M@m{ z-!^p@dlx3~{$@2eY9$vQmuc~a!R;_0+?bLkZpKMhj?v?H4!BgS9GpySaL}EzV4c2> z3RVxr=L*t(>}D?P2wjH5vH99uJk+tB zYFl!hJYOyaW$DgRx^NEfOqafaH)c^~zawJk#%=Wer6Rsl&7;;l1NJ|6iQ3YdsatIp(*(S>aNBH-$O2K`vfw8lO$1F%}=Ojlhr(9HTS%m~xMb>9ip|K!jniB(}a+Dc-c z{1Rx|BI0vBQ6udjfRuUpdFi0Iy<-&|n6;T=W3>2%>p0rkV=Fft>4vROm&upsEX4lp z+l5b4qsJHTfT<`o?c1qF1bG=u|p4=~h!z+%VNoly$6*&tyO99_T zuE2~86=y-p4t4nu%1-{~vgx@$;M2j=IQZgsp=RO?IQ+JZLTWs5{(x!VG)a|b#LtCs zXBY6`l~%mrb2MGcEfGtVXJW8MZ!~;IpgqqJ`)&_Jt6Kxa8DZ+EHd+sdMofc;lB;cl z^AGZReM9hGIv!WfzXe0?S+o0rP3*UMIR||HDJ=SY5gr(-@&icYT8jd%pSG8W%=}Dy z-0I1CdN@GxESi7s0eu^%z^7h?!P?Bt^rLMUjL(%o7V-`-S-A;PzIJ0Fc_N;lxRQ2j zc%a>d!(_5iq=Cl^MP1LS)SRuxgBt_Hq=dnA+I=kV{q&Z)IPTzB=Pqn-HViK;Rp+;U zZ)u{I1;>1O1X1Zm952nI<3B3!uN5PNf(}QB-0k?2(sr4L#I`y#?>mK5-y_>ZFL3n? z=8Z8!xw?azIB-=w9dwW2)n^LCX?N=>^{x|su-GoPfAz-mVWY7;U@Nt^G-65lLEInQ z2g~Pl;-Q&U)OaY7S}*(&j*V+2RlCVlAAK1rubJ_-7tt(L0fhlpz34y8qx@WfzjVzK zywxwGbL#^%ziPpk^h(LYS`D9NejxqbL982k3Dljw5)8gaHY0b#yF=s9EYC#zb)^_) zlt?bauf1`)7Q)76cqXR6)$C9TTe^u>pZ36K!3VKhlO;cW zeU$co9V1S$FOZdeO@mqSZz2AY4i?{jEbfxnXxpTHM&7YDxIR1|BzJ}6(sRSI0Y{yh zf0an4ItMha4JG&7J~Syfo{CM(D6~Y*yCfE>{_JW&{nII$AY}n+Z8OoKuPUzAlk%41 z;@M4m7#{1Hfr+C(L+JQ!hW&U&R6`VuPmJ_ z4+M^#h8y57*abUrH}@HkdOuCruNQ=+ug;VA)4L@3c!k(fcMh;=qNlgD1f!juF!zAO z=_~8aIxkiW1rJqdNRE`B-&{?8v8{s2tX83`d8?3o^|4_3dAD7v2L3JUx#f0Ldd}WDkqCuNB?*;w*eI#!?D*WBxA;jrqlj%K8R(9Ef{bwDP zG7@gQd;I`za#azUDyyOQ3pp%lNi8W5EV+Ea9`UB$ZTu2hK*N8TVuRXDD0Cdj`EylU0EdOm;4J}rq%52ht}*jt z?F1vkOjEciZa72IQr&_7`kr{#12;#w{Kem#v5EY zT$<^w9Ar+bj?bf|vQH2mK8}06xF@;n!m03LH9?pY$-7|*JiPmYJ_KcgvEduDl z2Zf9Mwqv$Owcwg2vC*CN#cehwIAzWb(EK}y7j-21RuM*5bUV>u#RKp|(HHiO7{u$c zCg4I<2fP+wh70=i!oInQ@Fngy9Q$sKS;k9*Hi;{6>~1F2?>FVA|0>Dz>3L}D^^}IJ zT?f94Ct|}de=zrK7r$zD!BS@(_EG-|CF%uamS%-z3MVMmd@`68_hS365?{<;;=fEu z08=#+p7}2do?eWH5ZxCrzr`0?`slOUY5`+x+F(;=F!z~rjxMX3Qa8ncXzQ-dw@z;0 z(ntGffup0HmkX77@Yc<=Z{bnd_joxso|cuAYC6bOE;rp*P+mDL?q~U z&!LMOilM7s57sdW6t;=8A+V1I&st=|CqnJ$_LN3p#@8R9tfb2a-oFM98!g(tJO!o^wM#f;J?x4_m9WuRm1|F=PNrY|U(eh+inq!5Z)cas(1IYur zuo~jpe?Y~I1PV&xlAZxZ{H5Zapq&$ezgliV(dU(P()%8yN}a`@4|fT-+Ld_O)6wMi zp(7uSQ{c+v5&XQ#hi**&Cof8$%{S9#A6!%L==oqphcq(}Y63uP1l962zyC zilOOI9u42#Ncjp{e6TEv&;3;fv(qmi>QfOswGkn7)(Uvz(i!#N8*p=#GFQ55VoL3N zTw2&2g`Q_AHn1I9_Gsbn6lEOU?-q2HI7&(x{&3m)1C;kkm&wvjLF8|DJ|Sg_nk6=O zuXD*{_+k)lcvB&)&4{3Y$#p`{on=s%=lo)xnygBeX5nh3mbXQQ?%G zye`ZZdpbvvdYCT!{jm$$o`b~lO(k_DV>Z7cv5rGqsMCe7(4pcWq-1AN=VX z$55fQ8UEg8fC*W7!r->?m=cjk>0!EDne|-aIIO|jB~kFO5(E>9_5K26fxO?RN--J$XPhrZ)_# z(!jCB#dLYyVX@Z&9X9==3#Dgu@b)8jQkXVX2#fNBz}j04XQucveGBzad<*>oztf9=1uPqSO2}$`D0HaU z0}gJ8eqCf-oY9%PNIf^@G#$Zh}kYZ1?L237_8%m>iZ_i z@|6C8!E0@7D4Wiz3OVE=jNk>w-_x~~x@5Ypn#LWBaQe~b9()^L134Os}rK%Mc@&`(2MF=h^TJyJjJ2Qvg3(5KmFb3wi2keY6{X80Ja& zlTLR_;OV%Hkf^SLt*(euGJDcwxC52j6wy3q0H2tv#(N?{#HRNvIP%^^iUtQ5*Dsq) zZatF4EVkkV7bVo(tjtBPe^Z>NEBDx%Bkk8?Amh+dDR;Ps&UYTk{c5zZ{J~#(yrdUu zKj_CD-}zBhiaj^C-xrrY)ntxb1|VLUR|4AJG;Qs%iZZ} z+(Wpo)eZIx-6}hwbq*KQuaO*Q1Mte#DC*sLAN(#kz<;SP4J zRN>2Z`Bf15`86EK8HM-r&eF{LJ@MzrqZFJmU1BPKp}EIx*?P_}e)Q213coGK+0T!W zztjQ!H}JLCw^>d2nxce>JBM<K<7+5?zwauIyz_2cYszo_l_ zELI472uB}X6?dGIvaemD;dFvJ+S`=DJPSP|`UFm}IljgYo{0>qWyItrgoRM2D>ddh< zC&_9_C5%;m24=U;i>2pwaf!w?SbjZ|MhBD&&i;}^=%g}kjr)CIpA^yS%2(nfro2Uq)hY|72^GSt zvTqVOnXgDvpr89X43cfkU~=c}Z+X)OoZXcAhH{5>IvK(tr1< z<)f99bq@j8F(ak?j}mph{28((=4JN{-h89(165q>#p-I_d_QLoGY{u{8t_hIhd82FJ-EZ-B7>LI|dacWJcSYOd_6$-55?Va$L|^r7j-+B-KE=b0Io(DI(Qz`{Cui+Zep|Hyk*95RXev!b!dN!?C}u z6udD4tL_hCD@6mWxhn0%pA6^kSCsIhm`A-mBY3Koz%B~a^7C&~srK4yiuvIw%|_Cw z=+g?Y{GJGXuU@3{dn+L$R)fP-g7J@rKtp`INx^_%;=PFwa&sd=gg@v>^Q9b_F6iiJ z@ru|k82V3Q2bUL$KKm}flKh{L=hYwXO_h2k!=m65j^!`kYKaquQ25AQ!j|!VY&;^1 zaLsY*U~eklxUG>Uw&>%nDSwGHHMyhHAe#F1vM_k-F6!Dj8@>g%2}=zxK!o)z^4_zJ z?8k|sTKGxX#q1rFcuS4luHTW(OVYuxq9Q{$6&wO0P zX2Um1{;f@1T{oYUGcttOoD81%U;(Gk^5&lpl<-dUKt8Y62Mv3xfrgo~^M%=x`%H3_ z75v$Pm9QBPeXBsh%aw)yMqt$tEgUv+8%^CIhv%QNq>hL=JkKtM=_?nplfnSH_OvUH zoZkYs4?Z9xl{89-eg znS%|3@TA0tc%7_)8NEJ2#*ph!|7{mVoN5yeob8UOed1{Sl1c##r^0U&9XjtT^%tcM z=wuH|;bqef!6Rg@#QZF$nPJWl8?VjPJ3^_skDA1e^`U-s-O*q21)Bcyqy(jIIOB>B z#6|dt(kKv2bNcXTx8)Ss}*Cl4In2a>Y*3YH#Ir#P7cM^-0rr^-xt`g%Le z>ygFNYoCZSG@HfJ#q-653zv#xokQuQXDZ+MKATm3d-2^B$x;trg%`BkrOl@I>7DLX z@lVzsR=9V8CeHTeg=JqvFRL?jS9`tKC_c|QD$*8h&2LGewD`CRvN-{-vFuNS*d&EeWa zL-KWOq`^_1Jak$CPySLthV+GMIu7MEH&v@f^wDA~om24of4JEsWrjq!7}zpMs_#uITYwa(#cUgP_M(sp--b9C*Bg@JKdWd@)Og(YFgbEWphVSmEQ_hUeguL=8k2D`5!3Yi!px~H-V>mycF_>^rc7X3hdG;NWp+Q^iT0oM5Hh6Q#GSLl@j?${Hb|L*uK7dBH(x`V z>6!D_J;S8Cz)A31X3XUiEbx$`8&7cT&$X*UFzjO^?9O>D9yY55qgrWQ+QD5&I{98a zJVTrEwH2_NN3qz?>8#w%e=GG`w+S{(9mtCc?m>soY8>=q2*3U_g&zb((97ESNQy^b zNVPw_*|Zm8mN!DX#Q^?ze;c8J2VYI}?VO|-CGO3$~Rpp?Ne}4O#KtXF62j4UTOA)R0k4fg_&6{eZq`@Wq>q%Hlcg`Y}>&~|&v_pTr^E6eVwe zFcM3bJ%O6`JbHJ3Ehrr6LhbfL#7~Qo#6FJ`>F%dlc>nYZ_%~(-zVU9QK(h+ibU2U} z1RRA0F&e0Bq=XTcZ)xJj9YW<+BMeI(je6yKsh4e{mchk zj7=f5_CB24IFuJp$beR(Y+61(oT7i`QQgsE>LT$|5C59M-OH-QD2YY(QaXF)$yE6K z?*ie3$6pxWpH7BOAEbVq7C)5y`*g^K7S-v)=27C>VJi-N^6%6OGT2Ukr;H_2a7w6z*mjHsgLia`|b za~h`1TTk%~(VVN6MNKo-%Tguh{lxp%ggtjnxbV^^aGO*K59MyWAs+eOEg#yK{f8E9 z4VPU$r;lAjyu^jM(z&%`JPhl%jGR}AzF;fQ5Fv`LkikUvv|)g$|2Lg!w%Q{9AWjRRoDBWK>
EnxuSdy4VogCYs>*x;n;>1OHx5OgK{-(v35}U+y&Y}}nRWR*| z7H0c|fT`IoNcz17LktsS?~FUpU0o}j`R*TOWmePEi;?){S|2vPxtCsAca$&x=}bbf zzcArv5|yhd@x571klrs`9B}rxn66?8Q=25W%d8&6LnrW{J$ckT-;Y}Y^@PsNvpB@A zP|AUX^1-beW>*O^8M1-ov;uY^Tl?{6*icD1G0p*?Y{SS0EVQD^Vx ze<>w=E|)%W5Y1=ll2(}#-gEZB3v*RzVSt$f9sX}NU7X;Gi%!IW|CElr zHs`o-!FKIpwu-wMC%ks@vq_IVZsDwJdi(xYtQIb z%H!`))=G6jXR1D1s_mi#(;`?B`%W0~tQ)rWxdk?#3#eCd0>|m^6!(m_pak!y^eEp1 z|0%d}Om#m|vC_csNC-MfjYt28-^!$!?!Qvlp`S_jUv46o>`q+eyG^e4Y5*-X zxd~qPs)aWi3H)!8CoTK^p01}m@+7TO5c|4}7M(vq?ul1uXv=GGZ1NTXpiYeX@)w8W8SFX@tL>aT^-8P$Mj_DPRE4U*3U3B-3piSMRK21 zDvl2wj{UAX!1ab~Qk@+Nq2dr|sFfUs5QOo0hsopMSo-R%By9igf@hsK!yT2qR5Sr?>w#YaK(p%ItWY7bwuBzxq@)q z4%4M|DTkGFA#)O9LtPC(`6U8KBrEt|)8M73!qd}HP;cwwjm zW>Stzd6_i}%Q|qh-zQ3PW+DFFIS=~_5&YoKaPi@c0@y6QD}4(4!=WfO_Bz@i&V8i8 zirs8!q=gFId3^xh23)0YnO(8|bd3CLl?IPkU_ra~uNAi!N;!^aTkx{I0{-*cFBa{H z!}~VBz0UoW#-A1Wr1e#aXVIUVgG^}Bs59b<9fN6^D9wFr4#Cwf7HqTT zyD<7-4#o|iNeh!l@{7c?aL~k>vp)vO<~KRL~#M%-(ke@(=Wh@`plee$+2um!-k%hz?!eVA{|Ng`&&ZZ1CqNG;xftKMj82wkQrfg|oL1Tg7mkwNn{_d~ zbkcLUH`@)JN|&>vXvBCnkK*57fv%3#vf0O1h;@;AI4Ca|yRFrwuRCUO?a#MVt^XG$ z?QIfNu6Xg3Rni^4?*%ya@Cl8&V#W0z1f1vh7yLD(J4@qVI6AjfTq!u=xa&T+^_V?d zNsNFK8RgKSBoLcVsN<03w<+7N2u7WlEzXKAhAY>u%3oLvlV=usfNPimKe(>~iq~!U zljb{6F&aTWelI~@JDtie`m^~)RrK+T#r`i`(S7c9S|=?+FB*)-t_!bMcKWN!!=r6L z7FiD)c2D46X7lLI6=^STYb&T2*o4iBos}+h z5tVTLJzX(qPCPoz)1{XORZ!b)B=_}*=fNlM3y*Ka@TXA?)J^Kwed+l^oRJs?efyt> zd5%})D@?W7PID@FJEl;dQ(Z{Ac_M$ZHb>`iE9j2f7O^$vzPSIn7fy)HpqLTu!p6H- zV6ICzc5Jd^YiZ9>elduBk0!9){2%h7eo`L(yfiDlngb65kJ8sOM!f308@8x#=PlnQ z{^a6~lrwD^3|c-6yUZNGhvm2E@T}o5>#DsFxZw#rSYgS*j~k%=d!xMJHq*?151`HW zAr#bof*f%z{LW9J&1(wbpJEv9TR0J_b#rLrU}GLSdjdc5jiXxO8(lqU#qp8fVdMIB zG`IU2eskM`-^K0`8jg3M^UL@1%vLK{Ho*_le2VDRg|4_=Vge3$RSYvOY{PXSXW@ym zy|{SBIq{FrB%W1chF3M`2uVx#;jtc*#3{YkK&Kw6Ja4fts=V0-M>{lv>e}hh{h*Xt zU$_a5Jwd!|tI0}d`Xe7mA@SK@EL|K2g=#mUUFv&KAwzJr&o7 zrg6}wKn`)!WK)lGqWQq}Y=0vGN~FKDt>O^+Wf{?_FP&LEj2mZBc^-g-!sZSKms$ydmvPnOtlVKPnm zby%Ey-9+l_*}-Q+Q(7=V`n~Krh_{_8aru*Ocs4fxT3w9LboqU8!-y7aI;jC!y9>k- z^HQl(X`;}n#E)~cv&9t(@njX>89j80P+30(D)uGPGa7~my3L|r`vI@c*hGEjgyFPd zd9dS`2^KU*v)SlxFn&o7EP14j-^aX#5oLSXcAz^tWxk||OLN8Z8zn}9mlNIJdX?fI z@H`*#wyN*$5?gUVsw zW)n7^7Q!xKU%VGP4g)6*<6)1tgM6`c#~yP=P;iqBo-bp;(7_GQjf$dT&-Fa$L>DUV za~>L_hGTHneVW>!0}l>tWL`BN`@5OZir*EqS@AawKdAzL$4`LMd=E}NJ4t60i(tm6 zFkJTjxe&3-6rMW;pmj|=UJTofw)VGaK#&smtU1J?rUV-|@8+XxI`OF4n|PO2Kbec; zV$nAHHT{m3d`oA{*{SR-IHuOhXB>SCJya&+fM473N6=0o{OWLCC0FI)yUp3+)I)e8 zF%cf_L*7!emOYF8gq+ugxZ#mIjjU5v^HV0)XUJz4xlja znb_K_5BVPyaN@{7^481)t%>&7E3gNcAFm=Khkp`hOA(iN_2vGxp8Rdt4jOc5BKw${ z;5c~=X!#tLKZ`mf`}IbLf*c0%uz#Jg!Av9tONmt?W&oyiC8zb8thh)4tzORIV<)sJ z-d>eIKj;QJ53Tvkg#}ErR#6L922SMnVYB);FV7n~*5?u6dbEIKP3&Z{@jZ7D-+ zRiVRaCtUGa%y16dZ{-oaWFYQ~>xvp5yCVPo2+O@BC%OB6aq!+P&~Q5p!#6R^Xs#A- zJk6(5;oF2EabLuH7YumwfCcbJu?vT#h9Qjd5sM#AloyuD_=3h%zBVZaW}!aDj!2@= zs1@vZ^fl##uM<5=E%{^pGg$R|6Ads(0NK(={J!2CaZN00UL1i-J6;3N+p%~dX{}h4 zV~buN{KO?=V#V)Io9U8`8r>Y8O>fU0r-gwjl^Kh6K<>hH@@VxEcKgQA)xKM~_oi&# z^Xi6ymm2(#p;= zc=HYeSY>^QUPcYz=%=r#qjU$+ALh@uRZi2D)%Bv|5HC@Cfpib~5y6h@Ch<;hHU8$* zgZ&S9ut)3(kz8*JdZ!(wd9)!G@3*5vHQ^XPG#Oe{9Po8v7p@42fyF(ZLW|)iO&xlO99z1M=Rni}07m2A|#_))|o{-|#lgE~> zA!}7|TCVbJd8O+O{)Bb&md~r}SIPEPI zUglgE9&YGKJMuGWuk0t--tfe||Jn0Xi7#RExdpn$-j#aMTHJiX3b!0u4==pxsG>#s z{--iDFZx@)_u84 z15!SSsmWhp;Tt)IEFfntazi64HEtRx9Y3!;2 zeB;Xit}pGzzg;Z&YneCvTG5Zaw^%buE?;f^MNkv_nJ#@s3OFr*`-dl#=Ql#SubT1B z*IOxTU@@hw_#qnXb|Qt7Q()810>QP_jb|?%j!N70_?mSoY5lk??zB+D&r=+E*Io^N zy|7Ju@?#?R{TIz97mDe(afG1?*oLK|6Q2a{l`><~#A@HeWf&6@*HaO&xB$j#16;3LQ zgYSn9(k^^V&bOb_8Cpj^cDbxNGX_->@>DAvt?Ed>LuOG^)=da|RYqMtRSF||_vh;_pFOT9xXB|WPEzd0d+?|Aym;63 z9-W=lO!$j4Md%1U^lWO`hm1Np4v!WyCe9@j+gRpuP)J_XTQmGO`dq*sSywT8j6~o zTyQ*C@Wq<*LUhP*u)QpkIU3bbpQCSt!^grX#>gA4b*>lpdTMc0oH<3<`_KZzu@EQC zSwYO>{oBL?oR)cxJjcZSnTy z`8I{{$G;CQcFUD_`!)j9mR41!s}~A3JO-zn?N9HeGxWEj#Q!_ci}Kb;vszPMoV!<= zk9>5)mCqgT-J9fnr%8En3uy*u&TEIvr^AK|Ak#&cf4{y4 z`gW3^#&0H1RcjD#l_>C=#4+%sd^u*gX!5ZgtNHXwTb#3cFREDm6Jk?iNWt_uRgN~{ zXOf#QRXG_?j!s6GcOM1!KEJ8Yt|}?pG!wknXye3)N>bgM#cQ@t5I^}JrQt*7a@Y3R zBvaVO&m6Y$kKNN*&9^`4y1R45WJ~@zDW1D0j1_VYdxMi!J>^%Y!}N;Y+_Nf%gQum@ z_xw4+i!V)d>;5U2yY{pAYvngutYpTAYYccw>`a<(uw8!Ol7;Yfq6_PZL%Hl`IG3It z3(dPHL2H@@4k&sqK6r#|=8iBH^E-DN4}C7uVJ z-G|}o=iWGT%T9PNx5N35ilA=NG6+gEL&J?0IJf6u{;%l}jaD9rZvR$b&aFz=G-5Jp zmVJiR)2`$Bzq$DPfkTbv*`oDRSUg5iFd7X;k(!a7diQqqX<&qm(F~{HTO) zWUu2e`(1qD(0o1<(uK``Az!_D8ZYRsz=5k%AnHp`aql)Y!K*jndxzWq&nLiv$%)W= zb5|Olz6Vm*6hNuZ2s|G!UGQ*OL3c|$Y2@%I3?C8%VF9}cJqFRk-w`mUJcVWR=7YPI zG3RyZ%Wb+nxM%cF@_W{c2M4M1G1bX9a<~HT?6ZMKEnCZBIm6jUNe&8CqqsR^78L|n zicuY9n7f*=*D4F4(^EsXIPZ*Iq;GzL1L5$7PF!h!75+9Jgp<CA z4-ac#an=sj7E^fijzE5O&WWv-O0%|en|bAcdg?!I806mc=93QQG&C-h`WdG3swpSA z!etuoee{I>WL1lX0jq>tc6WK|onV%`oAb*75;G@I^1wV$0OS82!|ly$>FfF*R9%q4 z`B$PO9>-WN_Nd_rt7mYm;}jyumyBD-+nysxd|sw?Yo`$;S84KfVPf>HEkKs!dnpiS;*W$F3CWbwD7s>M7jZmc`bEx#U}t z56i^U;`SC9hdx!rv%wqrP<0%i3P^@9Sb^JLdvcLV7XMs0m&V8JpxDAeF#hWR7@CwP zR{RL%oa<69bKf+uEE37j^X?+`LJ0*oj(VsU}nc!*~F)}a7s@n+$dLt zm5WAlf7ea4df^eW+^_+M6kditr_um_ZGhoM`{C8)OR#+tQ}r@^=-#3(Oq-S_KlLF7 zybk}RLGt++P`*y=zP~5SN{fNIMq^&mDH@d10UV?`?5#5)+(k$r!w5HVxyC=5wz!Z_ zM{eTrGtGEvQxzx`PUVV@*=#U3ot;WAf*1+n+bKS{eZqW}T{*{5JNobvB^&Pg!2|D< z<;y&Njc0R*wS3ArgCBP=pop2bxbDVwen0oOEM!*(X&g7C(bu~0+a24u=!AyEN-lu| z&rt}Jcq$6Lzf*IcY}le(PL4T$g*emx*lDO1mdriP|CNT(Q=5)xwNZwx#$w0jiwEbcpVMq%QA71(p7QgOLgqv879_!9teq=B)A|g3`yQKQ=oK z<>9xT$t5XO82fW|rSmrh-ZHTjB1>B2A+bfE|IH2mL|hiOIXGjR{wJ`KIw-p)?%;ig z45hPV2$x!GaFOJih>h#Y-&`(%W{WGh-1p+Fog3(@y)SB?-jAmn|B9E6NO_db<#-`_ zE)IWV=vm}FN8-(l!PD2K2>S9Q+?CuH1urumqgcp)9*FSzP*1)HEvVDH63 z#Ra2JV5>L~?;B}wuGMV1BlUUOGmo>8o;R;oT*n3DEqIB&oc?_|$4{o5;OB9Ngg4rs zK+~~V{$$`4A+}3A_y1*tsJFz@aL4cw+r6Q*vT0#8`$V?2jFSlcxU)G$@6=L zD!&ZDc%@8=kwgMd?#^e|XKj3|++Wyc6UqHFC-E`aRB7%h;%=>G;iFl)cu+V?(N8sD zVDv+w|Evs53f+KHM>tSiXD4cz-UxAer{Hc*5Uo1*O>FygjhrBdt=;l@yRrw(n)y*& z;(nBBZA)3(>K`e(r_08MY-H^zN;KoaJp6E^1%!959ARHgXH(zPw(5IW-(@YYUUX0L zU-?0{@>pJLvK&`_T*#(*llZn{DFl}{LFuafWPRf!e;*qRj~+jQW4-nXgXUOcC)*tE zIwDkb@_GvG%OnQitZ*LsD2pzSyULAG^%NfB#+h#``F3I|S-lYW@$Pvr>sbp7n`X>` z8ZtCGn}H6)?D6VuLtHYu3|hvTW7QxF%sny_ySDele;YqT@97FvJ^SZVe%5~8T$jcT zBewGO_J_D(*nYUUD24X;Hp9RVHn{ZZAevEUja$nX$qbIa6bw(zz)JyIRPSZULw4%Y z%3sZ}q<$sknydw_{AHN)u?o!R>_OKD>tWb>Gwk7a0e|#PLAwS8&j&@v(B5hYRgZf{ zzrrGT(al(4Wt}A^oKK*V4@>yz>K3B3(KNl{0qESC0Kf7S(OxGQgg!@T>L6`!+V)D~ zqU+$x&rWekeIEdb92ezR5W#XQ!Dik zuga!Dqc~=t6D3T_VS|G=VdrQUZtmJjKW85%X$v9oQj>7>^*gk7X%NmYe1q?LZ^8ZR zp5cILR|V^5yQTedG@fy|j+c5&^4!>_i31;OgPRF=L23IlINhj^Fl+^0vKhkH?##g< zexaB?FOSM@1##7YC$bc?5Axt2Ct%<}J7}1b1ycsihwkQkghRQFf-a`fu1~vQc~B3u zw+W&NVQQDp;3gHFMCbxXdi z^FgNCRgb&hPa~h0r?lgS8%$C+f{kkeVC9Z@PB#oht8WQ#)%rcHa{f#kgR;dX_mrVf zC4lG5oXKiedXe_9EE(MU1BaYeQmLhM7hPB(rgj-X_j6Q)S2 z%MJ{MYxnf{l$sODa_@s;iZYvp4~Eh;SA`h`eX-<}m6-Qkl}Ej|;7)?M#JCs--NX9v z6sJSW;AklM#As+wYjz$Dou(-*)AP2{ZZdoe&|zJW%oiOpwo8KZY&t`v|L* z)yepfHn-3JLVCK1v^W-^SI=5FSG8Dd_t%!SYxl?fF=l+LNf|@R_lhQ!DKO&wJ1TjT z47*B|aNfT>aYM>Bnshpt98_y%?&^|5XJkKVH<=3>ws%CMm)Ggl;l9{;^j4s>B3K>k z$&H!3y5qL*D`?pk zWV6$D`0>{?D4Q?2?#9-M>r~yjtjvg=#%jQ>e*b~m;cK+)&J{ZUeJlC;pA$3o>u-UW+Cu+@M&H630MPeO>#LfUQVmzD13tVm#Dg>ObhO=MR((~7yxXA{1 z@v{yXbt#z&e0GxWq&MUpQZ2mR(*^(A+nd8nbvQQdxsZP5HTD0#9zG<6!^@g3tgW9y zEAzX;#5pneD=?O;{cYGeF_gC^Hi)IC)$md5L+EbOo0Xh3d4NI0QbN;bQVs_qnd1YM<1)f_(U+-1HtX}GYI57ncNL5NHIVYM zCp56jAlRNvRP$;r<&E!v4^@r`-V1x8ZNN=gop&1*DkckczPrf2wpHwZzZSL|bOKc) zcho&{7XmhD)4t?Sbl$rkcW*o_XnSRf9>zN$+OiiHoaxE_K6ByIk0OXa(o3wDuLb#0 zD^#Dko=RAidSxbyGooI@s{BA4_oORUv<={wLHfAQ33TR@>V<)G;~@UTNIu!3 zj1k9`UZb~`F!_11=cv?ViMd zJHVX_4jxlJD&zZ==6qsCIhm^UK=+2p(Anyy(Dvjz{5LQf-=`1ZVLoac`QLp?T4@XU zu0ecc-C-CP(hKipiPXh30{8uM<*4)O1c!4;VV4db)Y=H@<$75Cu_ODh8i_@#^5INN zrug{aS25%Ic=o(&fP;n3`1HCjk2+LDbNXI|uNm|4r$G|l^D)914hiTgakdp)BB;)I z3+d%(Qd;8`(z)YA>-Z~0{dM47Mj2$(p;XG^T_j5bd%V;=PgvCJFCDl34Kx0^aZpk- z)yQ>OW_yDwO)ZIs>;b#Sr^MS%!{~8drf}!bRPkR(Mdc(rMLu{xn8T{4(W9jU`SIvi zP^H!x2P*ZG3qS7Bd3{rCk1;2|%ud{CbRujD?m(8sWuSiPmUO0`g!EH7Lh@5fNRd39 zDZ$!OUak=QBNpQDrITJ=f1yN2!t&y&NF zW>TmslzsF3Lh7v5G&#xNLa;0Ej6Ih*^8DjNaD=5RX7=;P`aBm{ z^u8Bcb>9r;qk3V~psg6T%NsV_8;5Tut;HtorFbMg9~62i;=hplw150op>wYYGFLhY zmp>>9Uz3#4++Kry9$HZkw^B-Za*kZX@+o%JPkLwU$3jjA)@}2LK$h-9OM64j>^4ff z(M4GK;2nIddqU24<)mR-4s*|jQSBKmo;KtX)au1Uuzjjv-nmrh(M^?t*7fAIzTfCZ z`F_D|&?LHSuuc9T+L5=@*!`l;IvsW z#I|+ia;@&rTdV~?jbi9^&xB{U*znn;H?V7}A{&WLI3`;cJXh?XI~@>^h1!b#H+;$29RyO#`U}0=y9pfN!i7|2z{azC6+aK24S0g}L2OUpo}(sVWvY z?S!(ID`cLz?o?~G8Y9gG?(^*m9oupR!t;A`c90_Iee6y>qAj5^ay)y*_rc4CajgGo zAio^9hDVG!PD7l!u|tI^{XMdXsFA2b$_UgPALcRbo)_Yy093{4^8EDSILCesWLT{i zH#K-cjjjo*rS_mvu6As9X$_bwErbo~&&8USdU`%=1g$pJ#ToaNA>KC~k5tydDrFB` zQ~m^$Jk+6ZxD2b;@28XrW6*PImhk$4Hym3b`2@rTBuwfpyzQXFKNG^q)kPV?ydv3P zyb~YZ-$ow8#!&uKOCHJJ<=Zn=`Hw;yX%;?#TaV1K%a0oHE&oB+?-QgN>O#i*UJ!P| zhf6M);Q9Jhcu&V#Xbhi=QMtNY{^2vt&Ml#TAC};H-%WD(=!eN#52$glE&lh;0xjxo zIs0@3@6ZMEc-xzkpD9z<>S^N5I%6!fOBQAy(Bjo;rfBQ;5q{qICgm)))3Xs)9QVh8 zl&9^Z2e00UstP{X)b9wk@0}v`vz+j=GD>!LgESaq&9P$QntP>I1pDdI0HKIdiwRF|<{hFR9LX301`w>|tsq ztlngToo)5`#;XakdZW`ccGn)EtD+;G1*Q*f}taTF(sSbC>?}=(W2QWaZy!sg4Lo_kSk+fV=QCSRYq)dPR-n zpUURV4&|W9yWvDkTjiW+Us(1`4P53`!O-lJp!cK@Ubn}hPNO=m^_0nUHO<)SaI5fX zZ6$n2@ zm{9uA4r1y4cA@<9M$y14i+ac95?5TOvJFSz`w}mlQqu-W1%YUM_#5aCw*iMgdOV%= z+2_<3GGARK^I5f>8vLd0r%_J`pCk&u;u>M}G>J=p@-QguDx*Ao89uvY&q|R39baR{ zmA1WDo_LPtNo?l4`~@(fEQlUVPKTjq2XKsb4NMgWaCY`D(ENKElq+4S;oT)+X4p^4 z|9gP`^S0!&mQD0h(-|h-dq-bh2&mk$hDVLRO|J|`qw}{=%y^MZY0;B;uhwR|IloDs z7SxlC?JRhdavWSQ%oB>P7;(TVM4w4IEL(Cybo35}!SBY4OTq(a!Rh^EVkB|0%I=7d zu54kemP-`UcN5iq@}!byX|Q-`3#?l50S4R;k$gg3U`y+6T764}2mef^+4L$|HxVesQr@JQCfYv-<0p>bbw-lafwk^^+?yEY2ps)%WLiCHfPH6?HL-suZ?*7T8}{7!Npz1hge{a(o|hlXH7MGn-@ z@xVQG{_>sYhv6t}lpp=@oVxXU0xb?VAV``qOxn|zUrIdwn9DC<-WN^DnYNotzc4AA zNi2TX0_c?N#xqwG^^uXZP)(GwT*hfQ|Keb#H zk~Kmh@{I$A%-;_~d}rbruf^m(vryK#$4lD2t_W%jO7H+AlZ#Ld>K&)iz4x9t&3843 zLsh6Ibg0*GBrIu-;iyMjD7%9p_Z*x@Cf$$IYU?%BrFA;D2fc#Wj*sYdu|GcAEiuCE-MM~N z39N|L;6*N@xk<|K;JIbu(-KP#v(b~-0ros9bEjOU87$vvHjbUl2V%dzQm3P8A#H9@ z=E&$tP_b|(6-OI$?AR=@h;k(2?=W%47IMDY6BqPc!hIyxYGcDTjNU2TqneF5Yx#KI zC$!SK4rg(wi`9iB3YG{;E@~>g2(Xog| z{Pc5QZa#psUKpaqrOm?Pg11z9A^~kwt_TYsJqEv3yP;oLGF5#!1_6(TlgD-)>gMSS zflEt;hoj8#Xv7>e58R0N2ei?D&Rc2zmuw1LWW*nwX0uMmX!g7@g}WFgvDzUiXVFp0 zZ#`eb9&-tr5-2hrUwOMJ1A$~KQA@JWtbb!*~ep(%9-hM_CmaEa9 z`%;H+{uuD|)Ni;$2%5u{F79ibO9C(OL0&VDf z2y%wHpx�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 literal 0 HcmV?d00001