-
-而在本节中我们会将PyTorch训练好的模型转换为ONNX 格式，然后使用ONNX Runtime运行它进行推理。通过本节课的学习，你将收获：
-
-1. 模型部署的整体流程
-2. 使用torch.onnx进行模型格式的转化
-3. 使用ONNX Runtime进行模型推理
-4. 完整的官方代码解释
-
-## 9.1.1 ONNX和ONNX Runtime简介
-
-### 9.1.1.1 ONNX简介
-
-- ONNX官网：https://onnx.ai/
-- ONNX GitHub：https://github.com/onnx/onnx
-
-**ONNX( Open Neural Network Exchange)** 是 Facebook (现Meta) 和微软在2017年共同发布的，用于标准描述计算图的一种格式。ONNX通过定义一组与环境和平台无关的标准格式，使AI模型可以在不同框架和环境下交互使用，ONNX可以看作深度学习框架和部署端的桥梁，就像编译器的中间语言一样。由于各框架兼容性不一，我们通常只用 ONNX 表示更容易部署的静态图。硬件和软件厂商只需要基于ONNX标准优化模型性能，让所有兼容ONNX标准的框架受益。目前，ONNX主要关注在模型预测方面，使用不同框架训练的模型，转化为ONNX格式后，可以很容易的部署在兼容ONNX的运行环境中。目前，在微软，亚马逊 ，Facebook(现Meta) 和 IBM 等公司和众多开源贡献的共同维护下，ONNX 已经对接了下图的多种深度学习框架和多种推理引擎。
-
-
-
-### 9.1.1.2 ONNX Runtime简介
-
-- ONNX Runtime官网：https://www.onnxruntime.ai/
-- ONNX Runtime GitHub：https://github.com/microsoft/onnxruntime
-
-**ONNX Runtime** 是由微软维护的一个跨平台机器学习推理加速器，它直接对接ONNX，可以直接读取.onnx文件并实现推理，不需要再把 .onnx 格式的文件转换成其他格式的文件。PyTorch借助ONNX Runtime也完成了部署的最后一公里，构建了 PyTorch --> ONNX --> ONNX Runtime 部署流水线，我们只需要将模型转换为 .onnx 文件，并在 ONNX Runtime 上运行模型即可。
-
-### 9.1.1.3 ONNX和ONNX Runtime的安装
-
-ONNX和ONNX Runtime作为python的一个包与其他包的安装方法相同，我们可以选择使用conda或者pip进行安装，只需要输入以下命令即可：
-
-```shell
-# 激活虚拟环境
-conda activate env_name # env_name换成环境名称
-# 安装onnx
-pip install onnx
-# 安装onnx runtime
-pip install onnxruntime # 使用CPU进行推理
-# pip install onnxruntime-gpu # 使用GPU进行推理
-```
-
-除此之外，我们还需要注意ONNX和ONNX Runtime之间的适配关系。我们可以访问ONNX Runtime的Github进行查看，链接地址如下：
-
-ONNX和ONNX Runtime的适配关系：https://github.com/microsoft/onnxruntime/blob/master/docs/Versioning.md
-
-当我们想使用GPU进行推理时，我们需要先将安装的onnxruntime卸载，再安装onnxruntime-gpu，同时我们还需要考虑ONNX Runtime与CUDA之间的适配关系，我们可以参考以下链接进行查看：
-
-ONNX Runtime和CUDA之间的适配关系：https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html
-
-## 9.1.2 模型导出为ONNX
-
-### 9.1.2.1 模型转换为ONNX格式
-
-在接下来的部分，我们将使用`torch.onnx.export()`把模型转换成 ONNX 格式的函数。模型导成onnx格式前，我们必须调用`model.eval()`或者`model.train(False)`以确保我们的模型处在推理模式下，避免因为`dropout`或`batchnorm`等运算符在推理和训练模式下的不同产生错误。（因为本课程偏向实战，对于ONNX的内部流程不做过多赘述，有兴趣的同学可以进行更深一步了解）
-
-```python
-import torch.onnx
-# 转换的onnx格式的名称，文件后缀需为.onnx
-onnx_file_name = "xxxxxx.onnx"
-# 我们需要转换的模型，将torch_model设置为自己的模型
-model = torch_model
-# 加载权重，将model.pth转换为自己的模型权重
-# 如果模型的权重是使用多卡训练出来，我们需要去除权重中多的module. 具体操作可以见5.4节
-model = model.load_state_dict(torch.load("model.pth"))
-# 导出模型前，必须调用model.eval()或者model.train(False)
-model.eval()
-# dummy_input就是一个输入的实例，仅提供输入shape、type等信息
-batch_size = 1 # 随机的取值，当设置dynamic_axes后影响不大
-dummy_input = torch.randn(batch_size, 1, 224, 224, requires_grad=True)
-# 这组输入对应的模型输出
-output = model(dummy_input)
-# 导出模型
-torch.onnx.export(model, # 模型的名称
- dummy_input, # 一组实例化输入
- onnx_file_name, # 文件保存路径/名称
- export_params=True, # 如果指定为True或默认, 参数也会被导出. 如果你要导出一个没训练过的就设为 False.
- opset_version=10, # ONNX 算子集的版本，当前已更新到15
- do_constant_folding=True, # 是否执行常量折叠优化
- input_names = ['input'], # 输入模型的张量的名称
- output_names = ['output'], # 输出模型的张量的名称
- # dynamic_axes将batch_size的维度指定为动态，
- # 后续进行推理的数据可以与导出的dummy_input的batch_size不同
- dynamic_axes={'input' : {0 : 'batch_size'},
- 'output' : {0 : 'batch_size'}})
-
-```
-
-### 9.1.2.2 ONNX模型的检验
-
-当上述代码运行成功后，我们会得到一个ONNX 模型文件。我们需要检测下我们的模型文件是否可用，我们将通过`onnx.checker.check_model()`进行检验，具体方法如下：
-
-```python
-import onnx
-# 我们可以使用异常处理的方法进行检验
-try:
- # 当我们的模型不可用时，将会报出异常
- onnx.checker.check_model(self.onnx_model)
-except onnx.checker.ValidationError as e:
- print("The model is invalid: %s"%e)
-else:
- # 模型可用时，将不会报出异常，并会输出“The model is valid!”
- print("The model is valid!")
-```
-
-### 9.1.2.3 ONNX可视化
-
-在将模型导出为onnx格式后，我们希望有个工具可以像Tensorboard一样可视化模型来观察每个节点的属性特征。随着`Netron`的出现，我们也可以实现onnx的可视化。
-- Netron下载网址：https://github.com/lutzroeder/netron
-
-
-使用Netron进行可视化后，我们不仅能看到整体模型的架构，还能看到每一个节点的信息。在接下来的内容中我们将以Netron官方提供的[squeezenet](https://netron.app/?url=https://media.githubusercontent.com/media/onnx/models/main/vision/classification/squeezenet/model/squeezenet1.0-3.onnx)为例进行介绍。下面第一幅图截取自squeezenet网络，我们可以看到网络的整体流程和输入。
-
-
-
-第二幅图显示了第一个Conv的信息包括kernel_size，strides，input，output等信息，同理当我们点击其他节点时也可以显示该节点的信息。
-
-
-
-## 9.1.3 使用ONNX Runtime进行推理
-
-通过以上的操作，我们已经完成了PyTorch的模型到ONNX模型的转换，并通过Netron可视化和`onnx.checker.check_model()`检查了模型的正确性。在这一步，我们将使用ONNX Runtime运行一下转化后的模型，看一下推理后的结果。
-
-```python
-# 导入onnxruntime
-import onnxruntime
-# 需要进行推理的onnx模型文件名称
-onnx_file_name = "xxxxxx.onnx"
-
-# onnxruntime.InferenceSession用于获取一个 ONNX Runtime 推理器
-ort_session = onnxruntime.InferenceSession(onnx_file_name)
-
-# 构建字典的输入数据，字典的key需要与我们构建onnx模型时的input_names相同
-# 输入的input_img 也需要改变为ndarray格式
-ort_inputs = {'input': input_img}
-# 我们更建议使用下面这种方法,因为避免了手动输入key
-# ort_inputs = {ort_session.get_inputs()[0].name:input_img}
-
-# run是进行模型的推理，第一个参数为输出张量名的列表，一般情况可以设置为None
-# 第二个参数为构建的输入值的字典
-# 由于返回的结果被列表嵌套，因此我们需要进行[0]的索引
-ort_output = ort_session.run(None,ort_inputs)[0]
-# output = {ort_session.get_outputs()[0].name}
-# ort_output = ort_session.run([output], ort_inputs)[0]
-
-```
-
-在上述的步骤中，我们有几个需要注意的点：
-
-1. PyTorch模型的输入为tensor，而ONNX的输入为array，因此我们需要对张量进行变换或者直接将数据读取为array格式，我们可以实现下面的方式进行张量到array的转化。
-
-```python
-def to_numpy(tensor):
- return tensor.detach().cpu().numpy() if tensor.requires_grad else tensor.cpu().numpy()
-```
-
-2. 输入的array的shape应该和我们导出模型的`dummy_input`的shape相同，如果图片大小不一样，我们应该先进行resize操作。
-3. run的结果是一个列表，我们需要进行索引操作才能获得array格式的结果。
-4. 在构建输入的字典时，我们需要注意字典的key应与导出ONNX格式设置的input_name相同，因此我们更建议使用上述的第二种方法构建输入的字典。
-
-## 9.1.4 代码实战
-
-本部分代码选自PyTorch官网示例代码，访问链接可点击下方推荐阅读2进行查看和使用官网提供的Colab对onnx导出进行进一步理解。*如有侵权，可立即删除*
-
-### 1. 定义超分辨模型
-
-```python
-# 导入相关包
-import io
-import numpy as np
-from torch import nn
-import torch.utils.model_zoo as model_zoo
-import torch.onnx
-import torch.nn as nn
-import torch.nn.init as init
-
-# 定义超分辨网络
-class SuperResolutionNet(nn.Module):
- def __init__(self, upscale_factor, inplace=False):
- super(SuperResolutionNet, self).__init__()
-
- self.relu = nn.ReLU(inplace=inplace)
- self.conv1 = nn.Conv2d(1, 64, (5, 5), (1, 1), (2, 2))
- self.conv2 = nn.Conv2d(64, 64, (3, 3), (1, 1), (1, 1))
- self.conv3 = nn.Conv2d(64, 32, (3, 3), (1, 1), (1, 1))
- self.conv4 = nn.Conv2d(32, upscale_factor ** 2, (3, 3), (1, 1), (1, 1))
- self.pixel_shuffle = nn.PixelShuffle(upscale_factor)
-
- self._initialize_weights()
-
- def forward(self, x):
- x = self.relu(self.conv1(x))
- x = self.relu(self.conv2(x))
- x = self.relu(self.conv3(x))
- x = self.pixel_shuffle(self.conv4(x))
- return x
-
- # 模型初始化
- def _initialize_weights(self):
- init.orthogonal_(self.conv1.weight, init.calculate_gain('relu'))
- init.orthogonal_(self.conv2.weight, init.calculate_gain('relu'))
- init.orthogonal_(self.conv3.weight, init.calculate_gain('relu'))
- init.orthogonal_(self.conv4.weight)
-
-# 实例化模型
-torch_model = SuperResolutionNet(upscale_factor=3)
-```
-
-### 2. 模型导出为ONNX格式
-
-```python
-model_url = 'https://s3.amazonaws.com/pytorch/test_data/export/superres_epoch100-44c6958e.pth'
-batch_size = 1 # just a random number
-# 加载预训练得到权重
-map_location = lambda storage, loc: storage
-if torch.cuda.is_available():
- map_location = None
-torch_model.load_state_dict(model_zoo.load_url(model_url, map_location=map_location))
-
-# 将模型设置为推理模式
-torch_model.eval()
-# Input to the model
-x = torch.randn(batch_size, 1, 224, 224, requires_grad=True)
-torch_out = torch_model(x)
-
-# 导出模型
-torch.onnx.export(torch_model, # model being run
- x, # model input (or a tuple for multiple inputs)
- "super_resolution.onnx", # where to save the model (can be a file or file-like object)
- export_params=True, # store the trained parameter weights inside the model file
- opset_version=10, # the ONNX version to export the model to
- do_constant_folding=True, # whether to execute constant folding for optimization
- input_names = ['input'], # the model's input names
- output_names = ['output'], # the model's output names
- # variable length axes
- dynamic_axes={'input' : {0 : 'batch_size'},
- 'output' : {0 : 'batch_size'}})
-```
-
-### 3. 检验ONNX模型
-
-```python
-import onnx
-# 我们可以使用异常处理的方法进行检验
-try:
- # 当我们的模型不可用时，将会报出异常
- onnx.checker.check_model("super_resolution.onnx")
-except onnx.checker.ValidationError as e:
- print("The model is invalid: %s"%e)
-else:
- # 模型可用时，将不会报出异常，并会输出“The model is valid!”
- print("The model is valid!")
-```
-
-### 4. 使用ONNX Runtime进行推理
-
-```python
-import onnxruntime
-
-ort_session = onnxruntime.InferenceSession("super_resolution.onnx")
-
-# 将张量转化为ndarray格式
-def to_numpy(tensor):
- return tensor.detach().cpu().numpy() if tensor.requires_grad else tensor.cpu().numpy()
-
-# 构建输入的字典和计算输出结果
-ort_inputs = {ort_session.get_inputs()[0].name: to_numpy(x)}
-ort_outs = ort_session.run(None, ort_inputs)
-
-# 比较使用PyTorch和ONNX Runtime得出的精度
-np.testing.assert_allclose(to_numpy(torch_out), ort_outs[0], rtol=1e-03, atol=1e-05)
-
-print("Exported model has been tested with ONNXRuntime, and the result looks good!")
-```
-
-### 5. 进行实际预测并可视化
-
-```python
-from PIL import Image
-import torchvision.transforms as transforms
-
-# 读取图片
-img = Image.open("/cat_224x224.jpg")
-# 对图片进行resize操作
-resize = transforms.Resize([224, 224])
-img = resize(img)
-
-img_ycbcr = img.convert('YCbCr')
-img_y, img_cb, img_cr = img_ycbcr.split()
-
-to_tensor = transforms.ToTensor()
-img_y = to_tensor(img_y)
-img_y.unsqueeze_(0)
-# 构建输入的字典并将value转换位array格式
-ort_inputs = {ort_session.get_inputs()[0].name: to_numpy(img_y)}
-ort_outs = ort_session.run(None, ort_inputs)
-img_out_y = ort_outs[0]
-img_out_y = Image.fromarray(np.uint8((img_out_y[0] * 255.0).clip(0, 255)[0]), mode='L')
-
-# 保存最后得到的图片
-final_img = Image.merge(
- "YCbCr", [
- img_out_y,
- img_cb.resize(img_out_y.size, Image.BICUBIC),
- img_cr.resize(img_out_y.size, Image.BICUBIC),
- ]).convert("RGB")
-
-final_img.save("/cat_superres_with_ort.jpg")
-```
-
-## 参考资料
-
-1. [miscroft-将 PyTorch 训练模型转换为 ONNX](https://docs.microsoft.com/zh-cn/windows/ai/windows-ml/tutorials/pytorch-convert-model)
-2. [pytorch- EXPORTING A MODEL FROM PYTORCH TO ONNX AND RUNNING IT USING ONNX RUNTIME](https://pytorch.org/tutorials/advanced/super_resolution_with_onnxruntime.html)
-3. [ONNX tutorials](https://github.com/onnx/tutorials#converting-to-onnx-format)
-
diff --git "a/docs/_sources/\347\254\254\344\271\235\347\253\240/9.1 \345\233\276\345\203\217\345\210\206\347\261\273.md.txt" "b/docs/_sources/\347\254\254\344\271\235\347\253\240/9.1 \345\233\276\345\203\217\345\210\206\347\261\273.md.txt"
deleted file mode 100644
index 94444adf6..000000000
--- "a/docs/_sources/\347\254\254\344\271\235\347\253\240/9.1 \345\233\276\345\203\217\345\210\206\347\261\273.md.txt"
+++ /dev/null
@@ -1 +0,0 @@
-# 9.1 图像分类（补充中）
\ No newline at end of file
diff --git "a/docs/_sources/\347\254\254\344\271\235\347\253\240/9.2 \347\233\256\346\240\207\346\243\200\346\265\213.md.txt" "b/docs/_sources/\347\254\254\344\271\235\347\253\240/9.2 \347\233\256\346\240\207\346\243\200\346\265\213.md.txt"
deleted file mode 100644
index 8d02e7c4e..000000000
--- "a/docs/_sources/\347\254\254\344\271\235\347\253\240/9.2 \347\233\256\346\240\207\346\243\200\346\265\213.md.txt"
+++ /dev/null
@@ -1,23 +0,0 @@
-# 目标检测
-## 目标检测概述
-目标检测是计算机视觉的一个重要任务，根据整张图像内容进行描述，并结合目标物体的特征信息，确定该物体的类别与位置。不同于图像分类任务中我们只需要输出图像中主要物体对象的类标，在目标检测任务中，一张图像里往往含有多个物体对象，我们不仅需要输出这些物体的类标，同时还需要输出这些物体的位置，在表示位置时，我们一般采用目标检测边缘框bounding box进行表示，bounding box是一组坐标值，常见形式为（x1,y1,x2,y2），其中x1代表物体左上x坐标，y1代表左上y坐标，x2代表物体右下x坐标，y2代表物体右下y坐标。
-## 目标检测应用
-目标检测技术不同于图像分类单一输出物体的种类，它将物体的位置和种类一起输出，这使得目标检测在一些领域有着重要的作用，目标检测常用于人脸检测、智慧交通、机器人、无人驾驶、遥感目标检测、安防领域检测异常、行人计数、安全系统等各大领域。
-## 目标检测数据集
-目标检测的数据集通常来说比图片分类的数据集小很多，因为每一张图片的标注的成本很高，相较于图片分类的常见标注方法是给定一个CSV文件（图片与标号一一对应）或者是给定一个文件夹（每个类对应一个子文件夹，对应标号的图片放在子文件夹下），但是对于目标检测来说因为一张图片中可能存在多个类，所以我们就不能放在子文件夹中，所以通常来说目标检测的数据集的标号需要额外存储，常见的存储格式有PASCAL VOC的格式和COCO的标注格式。假设使用文本文件存储的话，每一行表示一个物体，每一行分别由图片文件名（因为一张图片中可能有多个物体，所以同一个文件名可能会出现多次）、物体类别（标号）、边缘框（图片中物体的位置）组成，每一行一共有6（1+1+4）个值
-目标检测常用的数据集有PASCAL VOC2007, MS COCO
-### COCO数据集
-目标检测中比较常见的数据集，类似于Imagenet在图片分类中的地位
-访问地址：https://cocodataset.org/#home
-COCO数据集中有 80 个类别，330k 图片，1.5M 物体（每张图片中有多个物体）
-
-## 目标检测常用算法
-随着算力的发展和深度学习的发展，目标检测经历了从基于手工设计特征的方法到基于深度学习提取特征的阶段。在早期，目标检测技术往往采用手工设计特征（Haar特征、梯度直方图HOG）加分类器（SVM、AdaBoost）的方法实现。随着卷积神经网络的发展，目标检测出现了一系列的基于卷积神经网络的目标检测技术，包括R-CNN系列,SSD系列,YOLO系列等。随着Transformer在自然语言处理和计算机视觉的发展，也出现了基于Transformer的目标检测技术，代表工作有DETR系列。在本部分，我们主要介绍基于深度学习的目标检测技术并进行部分代码的解读。
-我们可以将基于深度学习的目标检测技术按照有无使用锚点框分为基于锚点框的目标检测方法（Anchor-based），无锚点框的目标检测方法（Anchor-free）和端到端的目标检测方法（Anchor-free）。其中端到端的目标检测技术也是属于特殊的无锚点框的目标检测方法。
-我们可以将基于锚点框的目标检测方法分为单阶段目标检测方法（One-Stage）和两阶段目标检测方法（Two-Stage），其中单阶段目标检测方法代表作有YOLO (You Only Look Once)和SSD (Single Shot Detector)，两阶段目标检测方法的代表作有R-CNN（R-CNN，Fast RCNN,Faster RCNN，Mask RCNN，Cascade RCNN，SPPNet）系列。一般而言，两阶段目标检测具有较高的检测精度，而单阶段目标检测方法具有更高的精度。
-同样，我们可以将无锚点框的目标检测方法分为基于目标点的目标检测方法和基于内部点的目标检测方法。
-端到端的目标检测方法
-
-
-
-
diff --git "a/docs/_sources/\347\254\254\344\271\235\347\253\240/index.md.txt" "b/docs/_sources/\347\254\254\344\271\235\347\253\240/index.md.txt"
deleted file mode 100644
index 1eae3e7a5..000000000
--- "a/docs/_sources/\347\254\254\344\271\235\347\253\240/index.md.txt"
+++ /dev/null
@@ -1,5 +0,0 @@
-# 第九章：PyTorch的模型部署
-```{toctree}
-:maxdepth: 2
-9.1 使用ONNX进行部署并推理
-```
\ No newline at end of file
diff --git "a/docs/_sources/\347\254\254\344\272\214\347\253\240/2.1 \345\274\240\351\207\217.md.txt" "b/docs/_sources/\347\254\254\344\272\214\347\253\240/2.1 \345\274\240\351\207\217.md.txt"
deleted file mode 100644
index b9e127682..000000000
--- "a/docs/_sources/\347\254\254\344\272\214\347\253\240/2.1 \345\274\240\351\207\217.md.txt"
+++ /dev/null
@@ -1,252 +0,0 @@
-# 2.1 张量
-
-从本章开始，我们将开始介绍PyTorch基础知识，本章我们将介绍张量，以帮助大家建立起对数据的描述，随后我们再介绍张量的运算，最后再讲PyTorch中所有神经网络的核心包 `autograd `，也就是自动微分，了解完这些内容我们就可以较好地理解PyTorch代码了。在深度学习中，我们通常将数据以张量的形式进行表示，比如我们用三维张量表示一个RGB图像，四维张量表示视频。
-
-经过本节的学习，你将收获：
-
-- 张量的简介
-- PyTorch如何创建张量
-- PyTorch中张量的操作
-- PyTorch中张量的广播机制
-
-## 2.1.1 简介
-
-几何代数中定义的张量是基于向量和矩阵的推广，比如我们可以将标量视为零阶张量，矢量可以视为一阶张量，矩阵就是二阶张量。
-|张量维度|代表含义|
-|---|---|
-| 0维张量 | 代表的是标量（数字） |
-| 1维张量 | 代表的是向量|
-| 2维张量 |代表的是矩阵|
-|3维张量 |时间序列数据 股价 文本数据 单张彩色图片(**RGB**)|
-
-张量是现代机器学习的基础。它的核心是一个数据容器，多数情况下，它包含数字，有时候它也包含字符串，但这种情况比较少。因此可以把它想象成一个数字的水桶。
-
-这里有一些存储在各种类型张量的公用数据集类型：
-
-- **3维 = 时间序列**
-- **4维 = 图像**
-- **5维 = 视频**
-
-例子：一个图像可以用三个字段表示：
-
-```
-(width, height, channel) = 3D
-```
-
-但是，在机器学习工作中，我们经常要处理不止一张图片或一篇文档——我们要处理一个集合。我们可能有10,000张郁金香的图片，这意味着，我们将用到4D张量：
-
-```
-(batch_size, width, height, channel) = 4D
-```
-
-在PyTorch中， `torch.Tensor` 是存储和变换数据的主要工具。如果你之前用过`NumPy`，你会发现 `Tensor` 和NumPy的多维数组非常类似。然而，`Tensor` 提供GPU计算和自动求梯度等更多功能，这些使 `Tensor` 这一数据类型更加适合深度学习。
-
-
-## 2.1.2 创建tensor
-在接下来的内容中，我们将介绍几种常见的创建`tensor`的方法。
-
-1. 随机初始化矩阵
-我们可以通过`torch.rand()`的方法，构造一个随机初始化的矩阵：
-
-```python
-
-import torch
-x = torch.rand(4, 3)
-print(x)
-```
-```python
-tensor([[0.7569, 0.4281, 0.4722],
- [0.9513, 0.5168, 0.1659],
- [0.4493, 0.2846, 0.4363],
- [0.5043, 0.9637, 0.1469]])
-```
-2. 全0矩阵的构建
-我们可以通过`torch.zeros()`构造一个矩阵全为 0，并且通过`dtype`设置数据类型为 long。除此以外，我们还可以通过torch.zero_()和torch.zeros_like()将现有矩阵转换为全0矩阵.
-
-```python
-import torch
-x = torch.zeros(4, 3, dtype=torch.long)
-print(x)
-```
-```python
-tensor([[0, 0, 0],
- [0, 0, 0],
- [0, 0, 0],
- [0, 0, 0]])
-```
-3. 张量的构建
- 我们可以通过`torch.tensor()`直接使用数据，构造一个张量：
-```python
-import torch
-x = torch.tensor([5.5, 3])
-print(x)
-```
-```python
-tensor([5.5000, 3.0000])
-```
-4. 基于已经存在的 tensor，创建一个 tensor ：
-
-```python
-x = x.new_ones(4, 3, dtype=torch.double)
-# 创建一个新的全1矩阵tensor，返回的tensor默认具有相同的torch.dtype和torch.device
-# 也可以像之前的写法 x = torch.ones(4, 3, dtype=torch.double)
-print(x)
-x = torch.randn_like(x, dtype=torch.float)
-# 重置数据类型
-print(x)
-# 结果会有一样的size
-# 获取它的维度信息
-print(x.size())
-print(x.shape)
-```
-```python
-tensor([[1., 1., 1.],
- [1., 1., 1.],
- [1., 1., 1.],
- [1., 1., 1.]], dtype=torch.float64)
-tensor([[ 2.7311, -0.0720, 0.2497],
- [-2.3141, 0.0666, -0.5934],
- [ 1.5253, 1.0336, 1.3859],
- [ 1.3806, -0.6965, -1.2255]])
-torch.Size([4, 3])
-torch.Size([4, 3])
-```
-返回的torch.Size其实是一个tuple，⽀持所有tuple的操作。我们可以使用索引操作取得张量的长、宽等数据维度。
-
-5. 常见的构造Tensor的方法：
-
-| 函数 | 功能 |
-| --------------------: | --------------------------------------------------- |
-| Tensor(sizes) | 基础构造函数 |
-| tensor(data) | 类似于np.array |
-| ones(sizes) | 全1 |
-| zeros(sizes) | 全0 |
-| eye(sizes) | 对角为1，其余为0 |
-| arange(s,e,step) | 从s到e，步长为step |
-| linspace(s,e,steps) | 从s到e，均匀分成step份 |
-| rand/randn(sizes) | rand是[0,1)均匀分布；randn是服从N(0，1)的正态分布 |
-| normal(mean,std) | 正态分布(均值为mean，标准差是std) |
-| randperm(m) | 随机排列 |
-
-## 2.1.3 张量的操作
-在接下来的内容中，我们将介绍几种常见的张量的操作方法：
-1. 加法操作：
-```python
-import torch
-# 方式1
-y = torch.rand(4, 3)
-print(x + y)
-
-# 方式2
-print(torch.add(x, y))
-
-# 方式3 in-place，原值修改
-y.add_(x)
-print(y)
-```
-```python
-tensor([[ 2.8977, 0.6581, 0.5856],
- [-1.3604, 0.1656, -0.0823],
- [ 2.1387, 1.7959, 1.5275],
- [ 2.2427, -0.3100, -0.4826]])
-tensor([[ 2.8977, 0.6581, 0.5856],
- [-1.3604, 0.1656, -0.0823],
- [ 2.1387, 1.7959, 1.5275],
- [ 2.2427, -0.3100, -0.4826]])
-tensor([[ 2.8977, 0.6581, 0.5856],
- [-1.3604, 0.1656, -0.0823],
- [ 2.1387, 1.7959, 1.5275],
- [ 2.2427, -0.3100, -0.4826]])
-
-```
-2. 索引操作：(类似于numpy)
-
-**需要注意的是：索引出来的结果与原数据共享内存，修改一个，另一个会跟着修改。如果不想修改，可以考虑使用copy()等方法**
-
-```python
-import torch
-x = torch.rand(4,3)
-# 取第二列
-print(x[:, 1])
-```
-```python
-tensor([-0.0720, 0.0666, 1.0336, -0.6965])
-```
-
-```python
-y = x[0,:]
-y += 1
-print(y)
-print(x[0, :]) # 源tensor也被改了了
-```
-```python
-tensor([3.7311, 0.9280, 1.2497])
-tensor([3.7311, 0.9280, 1.2497])
-```
-3. 维度变换
-张量的维度变换常见的方法有`torch.view()`和`torch.reshape()`，下面我们将介绍第一中方法`torch.view()`：
-
-```python
-x = torch.randn(4, 4)
-y = x.view(16)
-z = x.view(-1, 8) # -1是指这一维的维数由其他维度决定
-print(x.size(), y.size(), z.size())
-```
-```python
-torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])
-```
-注: `torch.view()` 返回的新`tensor`与源`tensor`共享内存(其实是同一个`tensor`)，更改其中的一个，另外一个也会跟着改变。(顾名思义，view()仅仅是改变了对这个张量的观察角度)
-
-```python
-x += 1
-print(x)
-print(y) # 也加了了1
-```
-```python
-tensor([[ 1.3019, 0.3762, 1.2397, 1.3998],
- [ 0.6891, 1.3651, 1.1891, -0.6744],
- [ 0.3490, 1.8377, 1.6456, 0.8403],
- [-0.8259, 2.5454, 1.2474, 0.7884]])
-tensor([ 1.3019, 0.3762, 1.2397, 1.3998, 0.6891, 1.3651, 1.1891, -0.6744,
- 0.3490, 1.8377, 1.6456, 0.8403, -0.8259, 2.5454, 1.2474, 0.7884])
-```
-上面我们说过torch.view()会改变原始张量，但是很多情况下，我们希望原始张量和变换后的张量互相不影响。为为了使创建的张量和原始张量不共享内存，我们需要使用第二种方法`torch.reshape()`， 同样可以改变张量的形状，但是此函数并不能保证返回的是其拷贝值，所以官方不推荐使用。推荐的方法是我们先用 `clone()` 创造一个张量副本然后再使用 `torch.view()`进行函数维度变换 。
-
-注：使用 `clone()` 还有一个好处是会被记录在计算图中，即梯度回传到副本时也会传到源 Tensor 。
-3. 取值操作
-如果我们有一个元素 `tensor` ，我们可以使用 `.item()` 来获得这个 `value`，而不获得其他性质：
-
-```python
-import torch
-x = torch.randn(1)
-print(type(x))
-print(type(x.item()))
-```
-```python
-
-
-上图：In-datacenter performance analysis of a tensor processing unit，figure 1
-
-由上图可见，整个TPU中最重要的计算单元是右上角黄色的矩阵乘单元“Matrix Multiply Unit”，它包含256x256个MAC部件，每一个能够执行有符号或者无符号的8位乘加操作。它的输入为权重数据队列FIFO和统一缓冲Unified Buffer，即图中指向它的两个蓝色部分。在计算结束后，16位结果被收集并传递到位于矩阵单元下方的4MiB 32位蓝色累加器Accumulators中，之后由黄色的激活单元在累加后执行非线性函数，并最终将数据返回给统一缓冲。
-
-Matrix Multiply Unit矩阵处理器作为TPU的核心部分，它可以在单个时钟周期内处理数十万次矩阵（Matrix）运算。MMU有着与传统CPU、GPU截然不同的架构，称为脉动阵列（systolic array）。之所以叫“脉动”，是因为在这种结构中，数据一波一波地流过芯片，与心脏跳动供血的方式类似。而如下图所示，CPU和GPU在每次运算中都需要从多个寄存器（register）中进行存取，而TPU的脉动阵列将多个运算逻辑单元（ALU）串联在一起，复用从一个寄存器中读取的结果。每个ALU单元结构简单，一般只包含乘法器、加法器以及寄存器三部分，适合大量堆砌。
-
-
-
-但是，在极大增加数据复用、降低内存带宽压力的同时，脉动阵列也有两个缺点，即数据重排和规模适配。第一，脉动矩阵主要实现向量/矩阵乘法。以CNN计算为例，CNN数据进入脉动阵列需要调整好形式，并且严格遵循时钟节拍和空间顺序输入。数据重排的额外操作增加了复杂性。第二，在数据流经整个阵列后，才能输出结果。当计算的向量中元素过少，脉动阵列规模过大时，不仅难以将阵列中的每个单元都利用起来，数据的导入和导出延时也随着尺寸扩大而增加，降低了计算效率。因此在确定脉动阵列的规模时，在考虑面积、能耗、峰值计算能力的同时，还要考虑典型应用下的效率。
-
-### 技术特点
-
-#### AI加速专用
-
-TPU的架构属于Domain-specific Architecture，也就是特定领域架构。它的定位准确，架构简单，单线程控制，定制指令集使得它在深度学习运算方面效率极高，且容易扩展。相比之下，传统诸如CPU、GPU等通用处理器必须考虑灵活性和兼容性，有太重的包袱。但TPU这种特点也决定它只能被限制用于深度学习加速场景。
-
-#### 脉动阵列设计
-
-TPU采用了与传统CPU和GPU截然不同的脉动阵列（systolic array）结构来加速AI运算，脉动阵列能够在一个时钟周期内处理数十万次矩阵运算，在每次运算过程中，TPU能够将多个运算逻辑单元（ALU）串联在一起，并复用从一个寄存器中取得的结果。这种设计，不仅能够将数据复用实现最大化，减少芯片在运算过程中的内存访问次数，提高AI计算效率，同时也降低了内存带宽压力，进而降低内存访问的能耗。
-
-MMU的脉动阵列包含256 × 256 = 65,536个ALU，也就是说TPU每个周期可以处理65,536次8位整数的乘法和加法。
-
-TPU以700兆赫兹的功率运行，也就是说，它每秒可以运行65,536 × 700,000,000 = 46 × 1012次乘法和加法运算，或每秒92万亿（92 × 1012）次矩阵单元中的运算。
-
-
-
-上图：In-datacenter performance analysis of a tensor processing unit，figure 4
-
-#### 确定性功能和大规模片上内存
-
-如图是TPU的平面设计简图，黄色为MMU运算单元，蓝色是统一缓存和累加器等数据单元，绿色是I/O，红色是逻辑控制单元。
-
-
-
-上图：In-datacenter performance analysis of a tensor processing unit，figure 2
-
-传统GPU由于片上内存较少，因此在运行过程中需要不断地去访问片外动态随机存取存储器（DRAM），从而在一定程度上浪费了不必要的能耗。与CPU和GPU相比，TPU的控制单元更小，更容易设计，面积只占了整个冲模的2%，给片上存储器和运算单元留下了更大的空间。如上图所示的TPU一代架构中，总共设计了占总芯片面积35%的内存，其中包括24MB的局部内存、4MB的累加器内存，以及用于与主控处理器对接的内存。这一比例大大超出了GPU等通用处理器，节约了大量片外数据访存能耗，使得TPU计算的能效比大大提高。从TPU二代开始采用HBM片上高带宽内存，虽然和最新一代GPU片上内存技术相同，但是TPU芯片的面积要远远小于GPU。硅片越小，成本越低，良品率也越高。
-
-另外，由于TPU是一个单用途芯片，不需要考虑缓存、分支预测、多道处理等问题。这就意味着TPU的功能是单一且确定的。因此，我们可以使用TPU轻易的预测运行一个神经网络需要多长时间，这样我们就能让芯片以吞吐量接近峰值的状态运行，同时严格控制延迟。
-
-## 2.4.2 NPU
-
-NPU即Neural-network Processing Unit，中文名为神经网络处理器，它采用“数据驱动并行计算”的架构，特别擅长处理视频、图像类的海量多媒体数据。
-
-长期以来，应用需求一直牵动着嵌入式技术的发展方向。随着深度学习神经网络的兴起，人工智能、大数据时代的来临，CPU和GPU渐渐难以满足深度学习的需要，面对日渐旺盛的需求和广大的预期市场，设计一款专门用于神经网络深度学习的高效智能处理器显得十分必要，因此NPU应运而生。
-
-从技术角度看，深度学习实际上是一类多层大规模人工神经网络。它模仿生物神经网络而构建，由若干人工神经元结点互联而成。神经元之间通过突触两两连接，突触记录了神经元间联系的权值强弱。由于深度学习的基本操作是神经元和突触的处理，神经网络中存储和处理是一体化的，都是通过突触权重来体现，而冯·诺伊曼结构中，存储和处理是分离的，分别由存储器和运算器来实现，二者之间存在巨大的差异。当用现有的基于冯·诺伊曼结构的经典计算机(如X86处理器和英伟达GPU)运行神经网络应用时，就不可避免地受到存储和处理分离式结构的制约，因而影响效率。因此，专门针对人工智能的专业芯片NPU更有研发的必要和需求。
-
-在NPU的设计上，中国走在了世界前列。下面我们将以寒武纪的DianNao系列架构为例，来简要介绍NPU。
-
-### DianNao
-
-
-
-
-
-上图：DianNao: a small-footprint high-throughput accelerator for ubiquitous machine-learning，figure 9
-
-基于神经网络的人工智能算法，是模拟人类大脑内部神经元的结构。上图中的neuron代表的就是单个神经元，synapse代表神经元的突触。这个模型的工作模式，就要结合高中生物课的知识了。
-
-一个神经元，有许多突触，给别的神经元传递信息。同样，这个神经元，也会接收来自许多其他神经元的信息。这个神经元所有接受到的信息累加，会有一个强烈程度，在生物上是以化学成分的形式存在，当这些信息达到一定的强烈程度，就会使整个神经元处于兴奋状态（激活），否则就是不兴奋（不激活）。如果兴奋了，就给其他神经元传递信息，如果不兴奋，就不传递。这就是单独一个神经元的工作模式。那么有成千上万个这样的神经元组合起来，就是一个神经网络模型。
-
-那么DianNao是如何模拟神经元进行工作的呢，我们可以看看它的内部结构图：
-
-
-
-上图：DianNao: a small-footprint high-throughput accelerator for ubiquitous machine-learning，figure 11
-
-如图所示，上图中浅蓝色的部分就是用硬件逻辑模拟的神经网络架构，称为NFU（Neural Functional Units）。它可以被细分为三个部分，即途中的NFU-1，NFU-2，和NFU-3。
-
-NFU-1是乘法单元，它采用16bit定点数乘法器，1位符号位，5位整数位，10位小数位。该部分总计有256个乘法器。这些乘法器的计算是同时的，也就是说，在一个周期内可以执行256次乘法。
-
-NFU-2是加法树，总计16个，每一个加法树都是8-4-2-1这样的组成结构，即就是每一个加法树中都有15个加法器。
-
-NFU-3是非线性激活函数，该部分由分段线性近似实现非线性函数，根据前面两个单元计算得到的刺激量，从而判断是否需要激活操作。
-
-当需要实现向量相乘和卷积运算时，使用NFU-1完成对应位置元素相乘，NFU-2完成相乘结果相加，最后由NFU-3完成激活函数映射。完成池化运算时，使用NFU-2完成多个元素取最大值或取平均值运算。由此分析，尽管该运算模块非常简单，也覆盖了神经网络所需要的大部分运算。
-
-### DaDianNao
-
-作为DianNao的多核升级版本，DaDianNao的运算单元NFU与DianNao基本相同，最大的区别是为了完成训练任务多加了几条数据通路，且配置更加灵活。NFU的尺寸为16x16，即16个输出神经元，每个输出神经元有16个输入（输入端需要一次提供256个数据）。同时，NFU可以可选的跳过一些步骤以达到灵活可配置的功能。DaDianNao的NFU结构如下所示：
-
-
-
-上图：DaDianNao: A Machine-Learning Supercomputer，figure 6
-
-### ShiDianNao
-
-ShiDianNao是机器视觉专用加速器，集成了视频处理的部分，它也是DianNao系列中唯一一个考虑运算单元级数据重用的加速器，也是唯一使用二维运算阵列的加速器，其加速器的运算阵列结构如下所示：
-
-
-
-上图：ShiDianNao: Shifting vision processing closer to the sensor，figure 5
-
-ShiDianNao的运算阵列为2D格点结构，对于每一个运算单元（节点）而言，运算所使用的参数统一来源于Kernel，而参与运算的数据则可能来自于：数据缓存NBin，下方的节点，右侧的节点。
-
-下图为每个运算单元的结构：
-
-
-
-
-
-上图：ShiDianNao: Shifting vision processing closer to the sensor，figure 6
-
-该计算节点的功能包括转发数据和进行计算：
-
-转发数据：每个数据可来源于右侧节点，下方节点和NBin，根据控制信号选择其中一个存储到输入寄存器中，且根据控制信号可选的将其存储到FIFO-H和FIFO-V中。同时根据控制信号选择FIFO-H和FIFO-V中的信号从FIFO output端口输出
-
-进行计算：根据控制信号进行计算，包括相加，累加，乘加和比较等，并将结果存储到输出寄存器中，并根据控制信号选择寄存器或计算结果输出到PE output端口。
-
-对于计算功能，根据上文的结构图，可以发现，PE支持的运算有：kernel和输入数据相乘并与输出寄存器数据相加（乘加），输入数据与输出寄存器数据取最大或最小（应用于池化），kernel与输入数据相加（向量加法），输入数据与输出寄存器数据相加（累加）等。
-
-### PuDianNao
-
-作为DianNao系列的收山之作，PuDianNao的运算单元是电脑系列中唯一一个异构的，除了有MLU（机器学习单元）外，还有一个ALU用于处理通用运算和MLU无法处理的运算，其运算单元（上）和MLU（下）结构如下图所示：
-
-
-
-上图：PuDianNao: A Polyvalent Machine Learning Accelerator，figure 11&12
-
-该MLU共分为6层：
-
-计数层/比较层：这一层的处理为两个数按位与或比较大小，结果将被累加，这一层可以单独输出且可以被bypass
-
-加法层：这一层为两个输入对应相加，这一层可以单独输出且可以被bypass
-
-乘法层：这一层为两个输入或上一层（加法层）结果对应位置相乘，可以单独输出
-
-加法树层：将乘法层的结果累加
-
-累加层：将上一层（加法树层）的结果累加，可以单独输出
-
-特殊处理层：由一个分段线性逼近实现的非线性函数和k排序器（输出上一层输出中最小的输出）组成
-
-该运算单元是DianNao系列中功能最多的单元，配置非常灵活。例如实现向量相乘（对应位置相乘后累加）时，弃用计数层，加法层，将数据从乘法层，加法树层和累加层流过即可实现。
-
-PuDianNao支持7种机器学习算法：神经网络，线性模型，支持向量机，决策树，朴素贝叶斯，K临近和K类聚，所需要支持的运算较多，因此PuDianNao的运算分析主要集中在存储方面，其运算核心的设计中说明PuDianNao支持的运算主要有：向量点乘，距离计算，计数，排序和非线性函数。其他未覆盖的计算使用ALU实现。
-
-
-
-## 参考资料：
-
-[In-datacenter performance analysis of a tensor processing unit](https://ieeexplore.ieee.org/abstract/document/8192463)
-
-[Neural Network Processor](https://www.freepatentsonline.com/y2017/0103313.html)
-
-[DianNao: a small-footprint high-throughput accelerator for ubiquitous machine-learning](https://dl.acm.org/doi/abs/10.1145/2654822.2541967)
-
-[DaDianNao: A Machine-Learning Supercomputer](https://ieeexplore.ieee.org/document/7011421)
-
-[ShiDianNao: Shifting vision processing closer to the sensor](https://ieeexplore.ieee.org/document/7284058)
-
-[PuDianNao: A Polyvalent Machine Learning Accelerator](https://dl.acm.org/doi/abs/10.1145/2775054.2694358)
diff --git "a/docs/_sources/\347\254\254\344\272\214\347\253\240/2.4 \345\205\266\344\273\226\345\212\240\351\200\237\350\256\276\345\244\207.md.txt" "b/docs/_sources/\347\254\254\344\272\214\347\253\240/2.4 \345\205\266\344\273\226\345\212\240\351\200\237\350\256\276\345\244\207.md.txt"
deleted file mode 100644
index 02514c20b..000000000
--- "a/docs/_sources/\347\254\254\344\272\214\347\253\240/2.4 \345\205\266\344\273\226\345\212\240\351\200\237\350\256\276\345\244\207.md.txt"
+++ /dev/null
@@ -1,155 +0,0 @@
-# AI硬件加速设备
-
-在进行模型部署和训练时，我们有时会受限于CPU和GPU的性能。这时，专用的AI芯片就显得尤为重要。
-
-经过本节的学习，你将收获：
-
-- 什么是TPU
-- 什么是NPU
-
-## 2.4.1 TPU
-
-TPU即Tensor Processing Unit，中文名为张量处理器。2006年，谷歌开始计划为神经网络构建一个专用的集成电路（ASIC）。随着计算需求和数据量的不断上涨，这个需求在2013年开始变得尤为紧迫。于是，谷歌在2015年6月的IO开发者大会上推出了为优化自身的TensorFlow框架而设计打造的一款计算神经网络专用芯片。它主要用于进行搜索，图像，语音等模型和技术的处理。
-
-截至目前，谷歌已经发行了四代TPU芯片。
-
-### 芯片架构设计
-
-TPU的设计架构如下图
-
-
-
-由上图可见，整个TPU中最重要的计算单元是右上角黄色的矩阵乘单元“Matrix Multiply Unit”，它包含256x256个MAC部件，每一个能够执行有符号或者无符号的8位乘加操作。它的输入为权重数据队列FIFO和统一缓冲Unified Buffer，即图中指向它的两个蓝色部分。在计算结束后，16位结果被收集并传递到位于矩阵单元下方的4MiB 32位蓝色累加器Accumulators中，之后由黄色的激活单元在累加后执行非线性函数，并最终将数据返回给统一缓冲。
-
-Matrix Multiply Unit矩阵处理器作为TPU的核心部分，它可以在单个时钟周期内处理数十万次矩阵（Matrix）运算。MMU有着与传统CPU、GPU截然不同的架构，称为脉动阵列（systolic array）。之所以叫“脉动”，是因为在这种结构中，数据一波一波地流过芯片，与心脏跳动供血的方式类似。而如下图所示，CPU和GPU在每次运算中都需要从多个寄存器（register）中进行存取，而TPU的脉动阵列将多个运算逻辑单元（ALU）串联在一起，复用从一个寄存器中读取的结果。每个ALU单元结构简单，一般只包含乘法器、加法器以及寄存器三部分，适合大量堆砌。
-
-
-
-但是，在极大增加数据复用、降低内存带宽压力的同时，脉动阵列也有两个缺点，即数据重排和规模适配。第一，脉动矩阵主要实现向量/矩阵乘法。以CNN计算为例，CNN数据进入脉动阵列需要调整好形式，并且严格遵循时钟节拍和空间顺序输入。数据重排的额外操作增加了复杂性。第二，在数据流经整个阵列后，才能输出结果。当计算的向量中元素过少，脉动阵列规模过大时，不仅难以将阵列中的每个单元都利用起来，数据的导入和导出延时也随着尺寸扩大而增加，降低了计算效率。因此在确定脉动阵列的规模时，在考虑面积、能耗、峰值计算能力的同时，还要考虑典型应用下的效率。
-
-### 技术特点
-
-#### AI加速专用
-
-TPU的架构属于Domain-specific Architecture，定位准确，架构简单，单线程控制，定制指令集，架构在深度学习运算方面效率极高，且容易扩展。相比之下，传统诸如CPU、GPU等通用处理器必须考虑灵活性和兼容性，有太重的包袱。但TPU这种特点也决定它只能被限制用于深度学习加速场景。
-
-#### 脉动阵列设计
-
-TPU采用了与传统CPU和GPU截然不同的脉动阵列（systolic array）结构来加速AI运算，脉动阵列能够在一个时钟周期内处理数十万次矩阵运算，在每次运算过程中，TPU能够将多个运算逻辑单元（ALU）串联在一起，并复用从一个寄存器中取得的结果。这种设计，不仅能够将数据复用实现最大化，减少芯片在运算过程中的内存访问次数，提高AI计算效率，同时也降低了内存带宽压力，进而降低内存访问的能耗。
-
-MMU的脉动阵列包含256 × 256 = 65,536个ALU，也就是说TPU每个周期可以处理65,536次8位整数的乘法和加法。
-
-TPU以700兆赫兹的功率运行，也就是说，它每秒可以运行65,536 × 700,000,000 = 46 × 1012次乘法和加法运算，或每秒92万亿（92 × 1012）次矩阵单元中的运算。
-
-
-
-#### 确定性功能和大规模片上内存
-
-如图是TPU的平面设计简图，黄色为MMU运算单元，蓝色是统一缓存和累加器等数据单元，绿色是I/O，红色是逻辑控制单元。
-
-
-
-传统GPU由于片上内存较少，因此在运行过程中需要不断地去访问片外动态随机存取存储器（DRAM），从而在一定程度上浪费了不必要的能耗。与CPU和GPU相比，TPU的控制单元更小，更容易设计，面积只占了整个冲模的2%，给片上存储器和运算单元留下了更大的空间。如上图所示的TPU一代架构中，总共设计了占总芯片面积35%的内存，其中包括24MB的局部内存、4MB的累加器内存，以及用于与主控处理器对接的内存。这一比例大大超出了GPU等通用处理器，节约了大量片外数据访存能耗，使得TPU计算的能效比大大提高。从TPU二代开始采用HBM片上高带宽内存，虽然和最新一代GPU片上内存技术相同，但是TPU芯片的面积要远远小于GPU。硅片越小，成本越低，良品率也越高。
-
-另外，由于TPU是一个单用途芯片，不需要考虑缓存、分支预测、多道处理等问题。这就意味着TPU的功能是单一且确定的。因此，我们可以使用TPU轻易的预测运行一个神经网络需要多长时间，这样我们就能让芯片以吞吐量接近峰值的状态运行，同时严格控制延迟。
-
-## 2.4.2 NPU
-
-NPU即Neural-network Processing Unit，中文名为神经网络处理器，它采用“数据驱动并行计算”的架构，特别擅长处理视频、图像类的海量多媒体数据。
-
-长期以来，应用需求一直牵动着嵌入式技术的发展方向。随着深度学习神经网络的兴起，人工智能、大数据时代的来临，CPU和GPU渐渐难以满足深度学习的需要，面对日渐旺盛的需求和广大的预期市场，设计一款专门用于神经网络深度学习的高效智能处理器显得十分必要，因此NPU应运而生。
-从技术角度看，深度学习实际上是一类多层大规模人工神经网络。它模仿生物神经网络而构建，由若干人工神经元结点互联而成。神经元之间通过突触两两连接，突触记录了神经元间联系的权值强弱。由于深度学习的基本操作是神经元和突触的处理，神经网络中存储和处理是一体化的，都是通过突触权重来体现，而冯·诺伊曼结构中，存储和处理是分离的，分别由存储器和运算器来实现，二者之间存在巨大的差异。当用现有的基于冯·诺伊曼结构的经典计算机(如X86处理器和英伟达GPU)运行神经网络应用时，就不可避免地受到存储和处理分离式结构的制约，因而影响效率。因此，专门针对人工智能的专业芯片NPU更有研发的必要和需求。
-
-在NPU的设计上，中国走在了世界前列。下面我们将以寒武纪的DianNao系列架构为例，来简要介绍NPU。
-
-### DianNao
-
-
-
-
-
-基于神经网络的人工智能算法，是模拟人类大脑内部神经元的结构。上图中的neuron代表的就是单个神经元，synapse代表神经元的突触。这个模型的工作模式，就要结合高中生物课的知识了。
-
-一个神经元，有许多突触，给别的神经元传递信息。同样，这个神经元，也会接收来自许多其他神经元的信息。这个神经元所有接受到的信息累加，会有一个强烈程度，在生物上是以化学成分的形式存在，当这些信息达到一定的强烈程度，就会使整个神经元处于兴奋状态（激活），否则就是不兴奋（不激活）。如果兴奋了，就给其他神经元传递信息，如果不兴奋，就不传递。这就是单独一个神经元的工作模式。那么有成千上万个这样的神经元组合起来，就是一个神经网络模型。
-
-那么DianNao是如何模拟神经元进行工作的呢，我们可以看看它的内部结构图：
-
-
-
-如图所示，上图中浅蓝色的部分就是用硬件逻辑模拟的神经网络架构，称为NFU（Neural Functional Units）。它可以被细分为三个部分，即途中的NFU-1，NFU-2，和NFU-3。
-
-NFU-1是乘法单元，它采用16bit定点数乘法器，1位符号位，5位整数位，10位小数位。该部分总计有256个乘法器。这些乘法器的计算是同时的，也就是说，在一个周期内可以执行256次乘法。
-
-NFU-2是加法树，总计16个，每一个加法树都是8-4-2-1这样的组成结构，即就是每一个加法树中都有15个加法器。
-
-NFU-3是非线性激活函数，该部分由分段线性近似实现非线性函数，根据前面两个单元计算得到的刺激量，从而判断是否需要激活操作。
-
-当需要实现向量相乘和卷积运算时，使用NFU-1完成对应位置元素相乘，NFU-2完成相乘结果相加，最后由NFU-3完成激活函数映射。完成池化运算时，使用NFU-2完成多个元素取最大值或取平均值运算。由此分析，尽管该运算模块非常简单，也覆盖了神经网络所需要的大部分运算。
-
-### DaDianNao
-
-作为DianNao的多核升级版本，DaDianNao的运算单元NFU与DianNao基本相同，最大的区别是为了完成训练任务多加了几条数据通路，且配置更加灵活。NFU的尺寸为16x16，即16个输出神经元，每个输出神经元有16个输入（输入端需要一次提供256个数据）。同时，NFU可以可选的跳过一些步骤以达到灵活可配置的功能。DaDianNao的NFU结构如下所示：
-
-
-
-### ShiDianNao
-
-ShiDianNao是机器视觉专用加速器，集成了视频处理的部分，它也是DianNao系列中唯一一个考虑运算单元级数据重用的加速器，也是唯一使用二维运算阵列的加速器，其加速器的运算阵列结构如下所示：
-
-
-
-ShiDianNao的运算阵列为2D格点结构，对于每一个运算单元（节点）而言，运算所使用的参数统一来源于Kernel，而参与运算的数据则可能来自于：数据缓存NBin，下方的节点，右侧的节点。
-
-下图为每个运算单元的结构：
-
-
-
-
-
-该计算节点的功能包括转发数据和进行计算：
-
-转发数据：每个数据可来源于右侧节点，下方节点和NBin，根据控制信号选择其中一个存储到输入寄存器中，且根据控制信号可选的将其存储到FIFO-H和FIFO-V中。同时根据控制信号选择FIFO-H和FIFO-V中的信号从FIFO output端口输出
-
-进行计算：根据控制信号进行计算，包括相加，累加，乘加和比较等，并将结果存储到输出寄存器中，并根据控制信号选择寄存器或计算结果输出到PE output端口。
-
-对于计算功能，根据上文的结构图，可以发现，PE支持的运算有：kernel和输入数据相乘并与输出寄存器数据相加（乘加），输入数据与输出寄存器数据取最大或最小（应用于池化），kernel与输入数据相加（向量加法），输入数据与输出寄存器数据相加（累加）等。
-
-### DuDianNao
-
-作为DianNao系列的收山之作，PuDianNao的运算单元是电脑系列中唯一一个异构的，除了有MLU（机器学习单元）外，还有一个ALU用于处理通用运算和MLU无法处理的运算，其运算单元（左）和MLU（右）结构如下图所示：
-
-
-
-MLU共分为6层：
-
-计数层/比较层：这一层的处理为两个数按位与或比较大小，结果将被累加，这一层可以单独输出且可以被bypass
-
-加法层：这一层为两个输入对应相加，这一层可以单独输出且可以被bypass
-
-乘法层：这一层为两个输入或上一层（加法层）结果对应位置相乘，可以单独输出
-
-加法树层：将乘法层的结果累加
-
-累加层：将上一层（加法树层）的结果累加，可以单独输出
-
-特殊处理层：由一个分段线性逼近实现的非线性函数和k排序器（输出上一层输出中最小的输出）组成
-
-该运算单元是DianNao系列中功能最多的单元，配置非常灵活。例如实现向量相乘（对应位置相乘后累加）时，弃用计数层，加法层，将数据从乘法层，加法树层和累加层流过即可实现。
-
-PuDianNao支持7种机器学习算法：神经网络，线性模型，支持向量机，决策树，朴素贝叶斯，K临近和K类聚，所需要支持的运算较多，因此PuDianNao的运算分析主要集中在存储方面，其运算核心的设计中说明PuDianNao支持的运算主要有：向量点乘，距离计算，计数，排序和非线性函数。其他未覆盖的计算使用ALU实现。
-
-
-
-## 参考资料：
-
-[In-datacenter performance analysis of a tensor processing unit](https://ieeexplore.ieee.org/abstract/document/8192463)
-
-[Neural Network Processor](https://www.freepatentsonline.com/y2017/0103313.html)
-
-[DianNao: a small-footprint high-throughput accelerator for ubiquitous machine-learning](https://dl.acm.org/doi/abs/10.1145/2654822.2541967)
-
-[DaDianNao: A Machine-Learning Supercomputer](https://ieeexplore.ieee.org/document/7011421)
-
-[ShiDianNao: Shifting vision processing closer to the sensor](https://ieeexplore.ieee.org/document/7284058)
-
-[PuDianNao: A Polyvalent Machine Learning Accelerator](https://dl.acm.org/doi/abs/10.1145/2775054.2694358)
diff --git "a/docs/_sources/\347\254\254\344\272\214\347\253\240/index.md.txt" "b/docs/_sources/\347\254\254\344\272\214\347\253\240/index.md.txt"
deleted file mode 100644
index 0976d0804..000000000
--- "a/docs/_sources/\347\254\254\344\272\214\347\253\240/index.md.txt"
+++ /dev/null
@@ -1,8 +0,0 @@
-# 第二章：PyTorch基础知识
-```{toctree}
-:maxdepth: 2
-2.1 张量
-2.2 自动求导
-2.3 并行计算简介
-2.4 AI硬件加速设备
-```
\ No newline at end of file
diff --git "a/docs/_sources/\347\254\254\344\272\224\347\253\240/5.1 PyTorch\346\250\241\345\236\213\345\256\232\344\271\211\347\232\204\346\226\271\345\274\217.md.txt" "b/docs/_sources/\347\254\254\344\272\224\347\253\240/5.1 PyTorch\346\250\241\345\236\213\345\256\232\344\271\211\347\232\204\346\226\271\345\274\217.md.txt"
deleted file mode 100644
index e96da231b..000000000
--- "a/docs/_sources/\347\254\254\344\272\224\347\253\240/5.1 PyTorch\346\250\241\345\236\213\345\256\232\344\271\211\347\232\204\346\226\271\345\274\217.md.txt"
+++ /dev/null
@@ -1,181 +0,0 @@
-# 5.1 PyTorch模型定义的方式
-
-模型在深度学习中扮演着重要的角色，好的模型极大地促进了深度学习的发展进步，比如CNN的提出解决了图像、视频处理中的诸多问题，RNN/LSTM模型解决了序列数据处理的问题，GNN在图模型上发挥着重要的作用。当我们在向他人介绍一项深度学习工作的时候，对方可能首先要问的就是使用了哪些模型。因此，在PyTorch进阶操作的第一部分中，我们首先来学习PyTorch模型相关的内容。
-
-在第一部分课程的第三章中，我们已经学习了模型中的“层“是如何定义的，以及基础的模型是如何构建的。这里我们来更为系统地学习PyTorch中模型定义的方式，本节的学习将为后续灵活构建自己的模型打下坚实的基础。
-
-经过本节的学习，你将收获*：
-
-- 熟悉PyTorch中模型定义的三种方式
-- 读懂GitHub上千奇百怪的写法
-- 自己根据需要灵活选取模型定义方式
-
-[^*]: 进阶部分内容剑指实战，通过”你将收获“部分帮助大家有针对性地学习
-
-
-
-## 5.1.1 必要的知识回顾
-
-- `Module` 类是 `torch.nn` 模块里提供的一个模型构造类 (`nn.Module`)，是所有神经⽹网络模块的基类，我们可以继承它来定义我们想要的模型；
-- PyTorch模型定义应包括两个主要部分：各个部分的初始化（`__init__`）；数据流向定义（`forward`）
-
-基于`nn.Module`，我们可以通过`Sequential`，`ModuleList`和`ModuleDict`三种方式定义PyTorch模型。
-
-下面我们就来逐个探索这三种模型定义方式。
-
-
-
-## 5.1.2 Sequential
-
-对应模块为`nn.Sequential()`。
-
-当模型的前向计算为简单串联各个层的计算时， `Sequential` 类可以通过更加简单的方式定义模型。它可以接收一个子模块的有序字典(OrderedDict) 或者一系列子模块作为参数来逐一添加 `Module` 的实例，⽽模型的前向计算就是将这些实例按添加的顺序逐⼀计算。我们结合`Sequential`和定义方式加以理解：
-
-```python
-from collections import OrderedDict
-class MySequential(nn.Module):
- def __init__(self, *args):
- super(MySequential, self).__init__()
- if len(args) == 1 and isinstance(args[0], OrderedDict): # 如果传入的是一个OrderedDict
- for key, module in args[0].items():
- self.add_module(key, module)
- # add_module方法会将module添加进self._modules(一个OrderedDict)
- else: # 传入的是一些Module
- for idx, module in enumerate(args):
- self.add_module(str(idx), module)
- def forward(self, input):
- # self._modules返回一个 OrderedDict，保证会按照成员添加时的顺序遍历成
- for module in self._modules.values():
- input = module(input)
- return input
-```
-
-下面来看下如何使用`Sequential`来定义模型。只需要将模型的层按序排列起来即可，根据层名的不同，排列的时候有两种方式：
-
-- 直接排列
-
-```python
-import torch.nn as nn
-net = nn.Sequential(
- nn.Linear(784, 256),
- nn.ReLU(),
- nn.Linear(256, 10),
- )
-print(net)
-```
-
-```
-Sequential(
- (0): Linear(in_features=784, out_features=256, bias=True)
- (1): ReLU()
- (2): Linear(in_features=256, out_features=10, bias=True)
-)
-```
-
-- 使用OrderedDict：
-
-```python
-import collections
-import torch.nn as nn
-net2 = nn.Sequential(collections.OrderedDict([
- ('fc1', nn.Linear(784, 256)),
- ('relu1', nn.ReLU()),
- ('fc2', nn.Linear(256, 10))
- ]))
-print(net2)
-```
-
-```
-Sequential(
- (fc1): Linear(in_features=784, out_features=256, bias=True)
- (relu1): ReLU()
- (fc2): Linear(in_features=256, out_features=10, bias=True)
-)
-```
-
-可以看到，使用`Sequential`定义模型的好处在于简单、易读，同时使用`Sequential`定义的模型不需要再写`forward`，因为顺序已经定义好了。但使用`Sequential`也会使得模型定义丧失灵活性，比如需要在模型中间加入一个外部输入时就不适合用`Sequential`的方式实现。使用时需根据实际需求加以选择。
-
-
-
-## 5.1.3 ModuleList
-
-对应模块为`nn.ModuleList()`。
-
-`ModuleList` 接收一个子模块（或层，需属于`nn.Module`类）的列表作为输入，然后也可以类似`List`那样进行append和extend操作。同时，子模块或层的权重也会自动添加到网络中来。
-
-```python
-net = nn.ModuleList([nn.Linear(784, 256), nn.ReLU()])
-net.append(nn.Linear(256, 10)) # # 类似List的append操作
-print(net[-1]) # 类似List的索引访问
-print(net)
-```
-
-```
-Linear(in_features=256, out_features=10, bias=True)
-ModuleList(
- (0): Linear(in_features=784, out_features=256, bias=True)
- (1): ReLU()
- (2): Linear(in_features=256, out_features=10, bias=True)
-)
-```
-
-要特别注意的是，`nn.ModuleList` 并没有定义一个网络，它只是将不同的模块储存在一起。`ModuleList`中元素的先后顺序并不代表其在网络中的真实位置顺序，需要经过forward函数指定各个层的先后顺序后才算完成了模型的定义。具体实现时用for循环即可完成：
-
-```python
-class model(nn.Module):
- def __init__(self, ...):
- super().__init__()
- self.modulelist = ...
- ...
-
- def forward(self, x):
- for layer in self.modulelist:
- x = layer(x)
- return x
-```
-
-
-
-## 5.1.4 ModuleDict
-
-对应模块为`nn.ModuleDict()`。
-
-`ModuleDict`和`ModuleList`的作用类似，只是`ModuleDict`能够更方便地为神经网络的层添加名称。
-
-```python
-net = nn.ModuleDict({
- 'linear': nn.Linear(784, 256),
- 'act': nn.ReLU(),
-})
-net['output'] = nn.Linear(256, 10) # 添加
-print(net['linear']) # 访问
-print(net.output)
-print(net)
-```
-
-```
-Linear(in_features=784, out_features=256, bias=True)
-Linear(in_features=256, out_features=10, bias=True)
-ModuleDict(
- (act): ReLU()
- (linear): Linear(in_features=784, out_features=256, bias=True)
- (output): Linear(in_features=256, out_features=10, bias=True)
-)
-```
-
-
-
-## 5.1.5 三种方法的比较与适用场景
-
-`Sequential`适用于快速验证结果，因为已经明确了要用哪些层，直接写一下就好了，不需要同时写`__init__`和`forward`；
-
-ModuleList和ModuleDict在某个完全相同的层需要重复出现多次时，非常方便实现，可以”一行顶多行“；
-
-当我们需要之前层的信息的时候，比如 ResNets 中的残差计算，当前层的结果需要和之前层中的结果进行融合，一般使用 ModuleList/ModuleDict 比较方便。
-
-
-
-## 本节参考
-
-【1】https://zhuanlan.zhihu.com/p/64990232
-
diff --git "a/docs/_sources/\347\254\254\344\272\224\347\253\240/5.2 \345\210\251\347\224\250\346\250\241\345\236\213\345\235\227\345\277\253\351\200\237\346\220\255\345\273\272\345\244\215\346\235\202\347\275\221\347\273\234.md.txt" "b/docs/_sources/\347\254\254\344\272\224\347\253\240/5.2 \345\210\251\347\224\250\346\250\241\345\236\213\345\235\227\345\277\253\351\200\237\346\220\255\345\273\272\345\244\215\346\235\202\347\275\221\347\273\234.md.txt"
deleted file mode 100644
index 91f7daffc..000000000
--- "a/docs/_sources/\347\254\254\344\272\224\347\253\240/5.2 \345\210\251\347\224\250\346\250\241\345\236\213\345\235\227\345\277\253\351\200\237\346\220\255\345\273\272\345\244\215\346\235\202\347\275\221\347\273\234.md.txt"
+++ /dev/null
@@ -1,179 +0,0 @@
-# 5.2 利用模型块快速搭建复杂网络
-
-上一节中我们介绍了怎样定义PyTorch的模型，其中给出的示例都是用`torch.nn`中的层来完成的。这种定义方式易于理解，在实际场景下不一定利于使用。当模型的深度非常大时候，使用`Sequential`定义模型结构需要向其中添加几百行代码，使用起来不甚方便。
-
-对于大部分模型结构（比如ResNet、DenseNet等），我们仔细观察就会发现，虽然模型有很多层， 但是其中有很多重复出现的结构。考虑到每一层有其输入和输出，若干层串联成的”模块“也有其输入和输出，如果我们能将这些重复出现的层定义为一个”模块“，每次只需要向网络中添加对应的模块来构建模型，这样将会极大便利模型构建的过程。
-
-本节我们将以U-Net为例，介绍如何构建模型块，以及如何利用模型块快速搭建复杂模型。
-
-经过本节的学习，你将收获：
-
-- 利用上一节学到的知识，将简单层构建成具有特定功能的模型块
-- 利用模型块构建复杂网络
-
-
-
-## 5.2.1 U-Net简介
-
-U-Net是分割 (Segmentation) 模型的杰作，在以医学影像为代表的诸多领域有着广泛的应用。U-Net模型结构如下图所示，通过残差连接结构解决了模型学习中的退化问题，使得神经网络的深度能够不断扩展。
-
-
-
-
-
-## 5.2.2 U-Net模型块分析
-
-结合上图，不难发现U-Net模型具有非常好的对称性。模型从上到下分为若干层，每层由左侧和右侧两个模型块组成，每侧的模型块与其上下模型块之间有连接；同时位于同一层左右两侧的模型块之间也有连接，称为“Skip-connection”。此外还有输入和输出处理等其他组成部分。由于模型的形状非常像英文字母的“U”，因此被命名为“U-Net”。
-
-组成U-Net的模型块主要有如下几个部分：
-
-- 每个子块内部的两次卷积（Double Convolution）
-
-- 左侧模型块之间的下采样连接，即最大池化（Max pooling）
-
-- 右侧模型块之间的上采样连接（Up sampling）
-
-- 输出层的处理
-
-除模型块外，还有模型块之间的横向连接，输入和U-Net底部的连接等计算，这些单独的操作可以通过forward函数来实现。
-
-下面我们用PyTorch先实现上述的模型块，然后再利用定义好的模型块构建U-Net模型。
-
-
-
-## 5.2.3 U-Net模型块实现
-
-在使用PyTorch实现U-Net模型时，我们不必把每一层按序排列显式写出，这样太麻烦且不宜读，一种比较好的方法是先定义好模型块，再定义模型块之间的连接顺序和计算方式。就好比装配零件一样，我们先装配好一些基础的部件，之后再用这些可以复用的部件得到整个装配体。
-
-这里的基础部件对应上一节分析的四个模型块，根据功能我们将其命名为：`DoubleConv`, `Down`, `Up`, `OutConv`。下面给出U-Net中模型块的PyTorch 实现：
-
-```python
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-```
-
-```python
-class DoubleConv(nn.Module):
- """(convolution => [BN] => ReLU) * 2"""
-
- def __init__(self, in_channels, out_channels, mid_channels=None):
- super().__init__()
- if not mid_channels:
- mid_channels = out_channels
- self.double_conv = nn.Sequential(
- nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False),
- nn.BatchNorm2d(mid_channels),
- nn.ReLU(inplace=True),
- nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),
- nn.BatchNorm2d(out_channels),
- nn.ReLU(inplace=True)
- )
-
- def forward(self, x):
- return self.double_conv(x)
-
-```
-
-```python
-class Down(nn.Module):
- """Downscaling with maxpool then double conv"""
-
- def __init__(self, in_channels, out_channels):
- super().__init__()
- self.maxpool_conv = nn.Sequential(
- nn.MaxPool2d(2),
- DoubleConv(in_channels, out_channels)
- )
-
- def forward(self, x):
- return self.maxpool_conv(x)
-
-```
-
-```python
-class Up(nn.Module):
- """Upscaling then double conv"""
-
- def __init__(self, in_channels, out_channels, bilinear=False):
- super().__init__()
-
- # if bilinear, use the normal convolutions to reduce the number of channels
- if bilinear:
- self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
- self.conv = DoubleConv(in_channels, out_channels, in_channels // 2)
- else:
- self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, stride=2)
- self.conv = DoubleConv(in_channels, out_channels)
-
- def forward(self, x1, x2):
- x1 = self.up(x1)
- # input is CHW
- diffY = x2.size()[2] - x1.size()[2]
- diffX = x2.size()[3] - x1.size()[3]
-
- x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2,
- diffY // 2, diffY - diffY // 2])
- # if you have padding issues, see
- # https://github.com/HaiyongJiang/U-Net-Pytorch-Unstructured-Buggy/commit/0e854509c2cea854e247a9c615f175f76fbb2e3a
- # https://github.com/xiaopeng-liao/Pytorch-UNet/commit/8ebac70e633bac59fc22bb5195e513d5832fb3bd
- x = torch.cat([x2, x1], dim=1)
- return self.conv(x)
-
-```
-
-```python
-class OutConv(nn.Module):
- def __init__(self, in_channels, out_channels):
- super(OutConv, self).__init__()
- self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)
-
- def forward(self, x):
- return self.conv(x)
-```
-
-
-
-## 5.2.4 利用模型块组装U-Net
-
-使用上面我们定义好的模型块，我们就可以非常方便地组装U-Net模型。可以看到，通过模型块的方式实现了代码复用，整个模型结构定义所需的代码总行数明显减少，代码可读性也得到了提升。
-
-```python
-class UNet(nn.Module):
- def __init__(self, n_channels, n_classes, bilinear=False):
- super(UNet, self).__init__()
- self.n_channels = n_channels
- self.n_classes = n_classes
- self.bilinear = bilinear
-
- self.inc = DoubleConv(n_channels, 64)
- self.down1 = Down(64, 128)
- self.down2 = Down(128, 256)
- self.down3 = Down(256, 512)
- factor = 2 if bilinear else 1
- self.down4 = Down(512, 1024 // factor)
- self.up1 = Up(1024, 512 // factor, bilinear)
- self.up2 = Up(512, 256 // factor, bilinear)
- self.up3 = Up(256, 128 // factor, bilinear)
- self.up4 = Up(128, 64, bilinear)
- self.outc = OutConv(64, n_classes)
-
- def forward(self, x):
- x1 = self.inc(x)
- x2 = self.down1(x1)
- x3 = self.down2(x2)
- x4 = self.down3(x3)
- x5 = self.down4(x4)
- x = self.up1(x5, x4)
- x = self.up2(x, x3)
- x = self.up3(x, x2)
- x = self.up4(x, x1)
- logits = self.outc(x)
- return logits
-```
-
-
-
-## 参考资料
-
-1. https://github.com/milesial/Pytorch-UNet
diff --git "a/docs/_sources/\347\254\254\344\272\224\347\253\240/5.3 PyTorch\344\277\256\346\224\271\346\250\241\345\236\213.md.txt" "b/docs/_sources/\347\254\254\344\272\224\347\253\240/5.3 PyTorch\344\277\256\346\224\271\346\250\241\345\236\213.md.txt"
deleted file mode 100644
index 4067614f4..000000000
--- "a/docs/_sources/\347\254\254\344\272\224\347\253\240/5.3 PyTorch\344\277\256\346\224\271\346\250\241\345\236\213.md.txt"
+++ /dev/null
@@ -1,154 +0,0 @@
-# 5.3 PyTorch修改模型
-
-除了自己构建PyTorch模型外，还有另一种应用场景：我们已经有一个现成的模型，但该模型中的部分结构不符合我们的要求，为了使用模型，我们需要对模型结构进行必要的修改。随着深度学习的发展和PyTorch越来越广泛的使用，有越来越多的开源模型可以供我们使用，很多时候我们也不必从头开始构建模型。因此，掌握如何修改PyTorch模型就显得尤为重要。
-
-本节我们就来探索这一问题。经过本节的学习，你将收获：
-
-- 如何在已有模型的基础上：
- - 修改模型若干层
- - 添加额外输入
- - 添加额外输出
-
-
-
-## 5.3.1 修改模型层
-
-我们这里以PyTorch官方视觉库torchvision预定义好的模型ResNet50为例，探索如何修改模型的某一层或者某几层。我们先看看模型的定义是怎样的：
-
-```python
-# 导入必要的package
-import torch
-import torch.nn as nn
-from collections import OrderedDict
-import torchvision.models as models
-net = models.resnet50()
-print(net)
-```
-
-```
-ResNet(
- (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
- (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
- (relu): ReLU(inplace=True)
- (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
- (layer1): Sequential(
- (0): Bottleneck(
- (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
- (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
- (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
- (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
- (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
- (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
- (relu): ReLU(inplace=True)
- (downsample): Sequential(
- (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
- (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
- )
- )
-..............
- (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
- (fc): Linear(in_features=2048, out_features=1000, bias=True)
-)
-
-```
-
-这里模型结构是为了适配ImageNet预训练的权重，因此最后全连接层（fc）的输出节点数是1000。
-
-假设我们要用这个resnet模型去做一个10分类的问题，就应该修改模型的fc层，将其输出节点数替换为10。另外，我们觉得一层全连接层可能太少了，想再加一层。可以做如下修改：
-
-```python
-classifier = nn.Sequential(OrderedDict([('fc1', nn.Linear(2048, 128)),
- ('relu1', nn.ReLU()),
- ('dropout1',nn.Dropout(0.5)),
- ('fc2', nn.Linear(128, 10)),
- ('output', nn.Softmax(dim=1))
- ]))
-
-net.fc = classifier
-```
-
-这里的操作相当于将模型（net）最后名称为“fc”的层替换成了名称为“classifier”的结构，该结构是我们自己定义的。这里使用了第一节介绍的Sequential+OrderedDict的模型定义方式。至此，我们就完成了模型的修改，现在的模型就可以去做10分类任务了。
-
-
-
-## 5.3.2 添加外部输入
-
-有时候在模型训练中，除了已有模型的输入之外，还需要输入额外的信息。比如在CNN网络中，我们除了输入图像，还需要同时输入图像对应的其他信息，这时候就需要在已有的CNN网络中添加额外的输入变量。基本思路是：将原模型添加输入位置前的部分作为一个整体，同时在forward中定义好原模型不变的部分、添加的输入和后续层之间的连接关系，从而完成模型的修改。
-
-我们以torchvision的resnet50模型为基础，任务还是10分类任务。不同点在于，我们希望利用已有的模型结构，在倒数第二层增加一个额外的输入变量add_variable来辅助预测。具体实现如下：
-
-```python
-class Model(nn.Module):
- def __init__(self, net):
- super(Model, self).__init__()
- self.net = net
- self.relu = nn.ReLU()
- self.dropout = nn.Dropout(0.5)
- self.fc_add = nn.Linear(1001, 10, bias=True)
- self.output = nn.Softmax(dim=1)
-
- def forward(self, x, add_variable):
- x = self.net(x)
- x = torch.cat((self.dropout(self.relu(x)), add_variable.unsqueeze(1)),1)
- x = self.fc_add(x)
- x = self.output(x)
- return x
-```
-
-这里的实现要点是通过torch.cat实现了tensor的拼接。torchvision中的resnet50输出是一个1000维的tensor，我们通过修改forward函数（配套定义一些层），先将1000维的tensor通过激活函数层和dropout层，再和外部输入变量"add_variable"拼接，最后通过全连接层映射到指定的输出维度10。
-
-另外这里对外部输入变量"add_variable"进行unsqueeze操作是为了和net输出的tensor保持维度一致，常用于add_variable是单一数值 (scalar) 的情况，此时add_variable的维度是 (batch_size, )，需要在第二维补充维数1，从而可以和tensor进行torch.cat操作。对于unsqueeze操作可以复习下2.1节的内容和配套代码。
-
-之后对我们修改好的模型结构进行实例化，就可以使用了：
-
-```python
-net = models.resnet50()
-model = Model(net).cuda()
-```
-
-另外别忘了，训练中在输入数据的时候要给两个inputs：
-
-```python
-outputs = model(inputs, add_var)
-```
-
-
-
-## 5.3.3 添加额外输出
-
-有时候在模型训练中，除了模型最后的输出外，我们需要输出模型某一中间层的结果，以施加额外的监督，获得更好的中间层结果。基本的思路是修改模型定义中forward函数的return变量。
-
-我们依然以resnet50做10分类任务为例，在已经定义好的模型结构上，同时输出1000维的倒数第二层和10维的最后一层结果。具体实现如下：
-
-```python
-class Model(nn.Module):
- def __init__(self, net):
- super(Model, self).__init__()
- self.net = net
- self.relu = nn.ReLU()
- self.dropout = nn.Dropout(0.5)
- self.fc1 = nn.Linear(1000, 10, bias=True)
- self.output = nn.Softmax(dim=1)
-
- def forward(self, x, add_variable):
- x1000 = self.net(x)
- x10 = self.dropout(self.relu(x1000))
- x10 = self.fc1(x10)
- x10 = self.output(x10)
- return x10, x1000
-```
-
-之后对我们修改好的模型结构进行实例化，就可以使用了：
-
-```python
-import torchvision.models as models
-net = models.resnet50()
-model = Model(net).cuda()
-```
-
-另外别忘了，训练中在输入数据后会有两个outputs：
-
-```python
-out10, out1000 = model(inputs, add_var)
-```
-
diff --git "a/docs/_sources/\347\254\254\344\272\224\347\253\240/5.4 PyTorh\346\250\241\345\236\213\344\277\235\345\255\230\344\270\216\350\257\273\345\217\226.md.txt" "b/docs/_sources/\347\254\254\344\272\224\347\253\240/5.4 PyTorh\346\250\241\345\236\213\344\277\235\345\255\230\344\270\216\350\257\273\345\217\226.md.txt"
deleted file mode 100644
index 24f045e1c..000000000
--- "a/docs/_sources/\347\254\254\344\272\224\347\253\240/5.4 PyTorh\346\250\241\345\236\213\344\277\235\345\255\230\344\270\216\350\257\273\345\217\226.md.txt"
+++ /dev/null
@@ -1,292 +0,0 @@
-# 5.4 PyTorch模型保存与读取
-
-在前面几节的内容中，我们介绍了如何构建和修改PyTorch模型。本节我们来讨论PyTorch如何保存和读取训练好的模型和参数。
-
-另外，在很多场景下我们都会使用多GPU训练。这种情况下，模型会分布于各个GPU上（参加2.3节分布数据式训练，这里暂不考虑分布模型式训练），模型的保存和读取与单GPU训练情景下是否有所不同？
-
-经过本节的学习，你将收获：
-
-- PyTorch的模型的存储格式
-- PyTorch如何存储模型
-- 单卡与多卡训练下模型的保存与加载方法
-- 优化器模型参数的保存
-
-
-## 5.4.1 模型存储格式
-
-PyTorch存储模型主要采用pkl，pt，pth三种格式。就使用层面来说没有区别，这里不做具体的讨论。本节最后的参考内容中列出了查阅到的一些资料，感兴趣的读者可以进一步研究，欢迎留言讨论。
-
-
-## 5.4.2 模型存储内容
-
-一个PyTorch模型主要包含两个部分：模型结构和权重。其中模型是继承nn.Module的类，权重的数据结构是一个字典（key是层名，value是权重向量）。存储也由此分为两种形式：存储整个模型（包括结构和权重），和只存储模型权重。
-
-```python
-from torchvision import models
-model = models.resnet152(pretrained=True)
-save_dir = './resnet152.pth'
-
-# 保存整个模型
-torch.save(model, save_dir)
-# 保存模型权重
-torch.save(model.state_dict, save_dir)
-```
-
-对于PyTorch而言，pt, pth和pkl**三种数据格式均支持模型权重和整个模型的存储**，因此使用上没有差别。
-
-
-
-## 5.4.3 单卡和多卡模型存储的区别
-
-PyTorch中将模型和数据放到GPU上有两种方式——`.cuda()`和`.to(device)`，本节后续内容针对前一种方式进行讨论。如果要使用多卡训练的话，需要对模型使用`torch.nn.DataParallel`。示例如下：
-
-```python
-import os
-os.environ['CUDA_VISIBLE_DEVICES'] = '0' # 如果是多卡改成类似0,1,2
-model = model.cuda() # 单卡
-model = torch.nn.DataParallel(model).cuda() # 多卡
-```
-
-之后我们把`model`对应的`layer`名称打印出来看一下，可以观察到差别在于多卡并行的模型每层的名称前多了一个“module”。
-
-- 单卡模型的层名：
-
-
-
-- 多卡模型的层名：
-
-
-
-这种模型表示的不同可能会导致模型保存和加载过程中需要处理一些矛盾点，下面对各种可能的情况做分类讨论。
-
-
-## 5.4.4 单卡/多卡情况分类讨论
-
-由于训练和测试所使用的硬件条件不同，在模型的保存和加载过程中可能因为单GPU和多GPU环境的不同带来模型不匹配等问题。这里对PyTorch框架下单卡/多卡下模型的保存和加载问题进行排列组合（=4），样例模型是torchvision中预训练模型resnet152，不尽之处欢迎大家补充。
-
-- **单卡保存+单卡加载**
-
-在使用os.envision命令指定使用的GPU后，即可进行模型保存和读取操作。注意这里即便保存和读取时使用的GPU不同也无妨。
-
-```python
-import os
-import torch
-from torchvision import models
-
-os.environ['CUDA_VISIBLE_DEVICES'] = '0' #这里替换成希望使用的GPU编号
-model = models.resnet152(pretrained=True)
-model.cuda()
-
-save_dir = 'resnet152.pt' #保存路径
-
-# 保存+读取整个模型
-torch.save(model, save_dir)
-loaded_model = torch.load(save_dir)
-loaded_model.cuda()
-
-# 保存+读取模型权重
-torch.save(model.state_dict(), save_dir)
-loaded_model = models.resnet152() #注意这里需要对模型结构有定义
-loaded_model.load_state_dict(torch.load(save_dir))
-loaded_model.cuda()
-```
-
-- **单卡保存+多卡加载**
-
-这种情况的处理比较简单，读取单卡保存的模型后，使用`nn.DataParallel`函数进行分布式训练设置即可（相当于3.1代码中.cuda()替换一下）：
-
-```python
-import os
-import torch
-from torchvision import models
-
-os.environ['CUDA_VISIBLE_DEVICES'] = '0' #这里替换成希望使用的GPU编号
-model = models.resnet152(pretrained=True)
-model.cuda()
-
-# 保存+读取整个模型
-torch.save(model, save_dir)
-
-os.environ['CUDA_VISIBLE_DEVICES'] = '1,2' #这里替换成希望使用的GPU编号
-loaded_model = torch.load(save_dir)
-loaded_model = nn.DataParallel(loaded_model).cuda()
-
-# 保存+读取模型权重
-torch.save(model.state_dict(), save_dir)
-
-os.environ['CUDA_VISIBLE_DEVICES'] = '1,2' #这里替换成希望使用的GPU编号
-loaded_model = models.resnet152() #注意这里需要对模型结构有定义
-loaded_model.load_state_dict(torch.load(save_dir))
-loaded_model = nn.DataParallel(loaded_model).cuda()
-```
-
-- **多卡保存+单卡加载**
-
-这种情况下的核心问题是：如何去掉权重字典键名中的"module"，以保证模型的统一性。
-
-对于加载整个模型，直接提取模型的module属性即可：
-
-```python
-import os
-import torch
-from torchvision import models
-
-os.environ['CUDA_VISIBLE_DEVICES'] = '1,2' #这里替换成希望使用的GPU编号
-
-model = models.resnet152(pretrained=True)
-model = nn.DataParallel(model).cuda()
-
-# 保存+读取整个模型
-torch.save(model, save_dir)
-
-os.environ['CUDA_VISIBLE_DEVICES'] = '0' #这里替换成希望使用的GPU编号
-loaded_model = torch.load(save_dir).module
-```
-
-对于加载模型权重，有以下几种思路：
-**保存模型时保存模型的module属性对应的权重**
-```python
-import os
-os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,2' #这里替换成希望使用的GPU编号
-import torch
-from torchvision import models
-
-save_dir = 'resnet152.pth' #保存路径
-model = models.resnet152(pretrained=True)
-model = nn.DataParallel(model).cuda()
-
-# 保存权重
-torch.save(model.module.state_dict(), save_dir)
-```
-这样保存下来的模型参数就和单卡保存的模型参数一样了，可以直接加载。也是比较推荐的一种方法。
-**去除字典里的module麻烦，往model里添加module简单**
-
-```python
-import os
-os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,2' #这里替换成希望使用的GPU编号
-import torch
-from torchvision import models
-
-model = models.resnet152(pretrained=True)
-model = nn.DataParallel(model).cuda()
-
-# 保存+读取模型权重
-torch.save(model.state_dict(), save_dir)
-
-os.environ['CUDA_VISIBLE_DEVICES'] = '0' #这里替换成希望使用的GPU编号
-loaded_model = models.resnet152() #注意这里需要对模型结构有定义
-loaded_model.load_state_dict(torch.load(save_dir))
-loaded_model = nn.DataParallel(loaded_model).cuda()
-loaded_model.state_dict = loaded_dict
-```
-
-这样即便是单卡，也可以开始训练了（相当于分布到单卡上）
-
-**遍历字典去除module**
-
-```python
-from collections import OrderedDict
-os.environ['CUDA_VISIBLE_DEVICES'] = '0' #这里替换成希望使用的GPU编号
-
-loaded_dict = torch.load(save_dir)
-
-new_state_dict = OrderedDict()
-for k, v in loaded_dict.items():
- name = k[7:] # module字段在最前面，从第7个字符开始就可以去掉module
- new_state_dict[name] = v #新字典的key值对应的value一一对应
-
-loaded_model = models.resnet152() #注意这里需要对模型结构有定义
-loaded_model.state_dict = new_state_dict
-loaded_model = loaded_model.cuda()
-```
-
-**使用replace操作去除module**
-
-```python
-loaded_model = models.resnet152()
-loaded_dict = torch.load(save_dir)
-loaded_model.load_state_dict({k.replace('module.', ''): v for k, v in loaded_dict.items()})
-```
-
-
-
-- **多卡保存+多卡加载**
-
-由于是模型保存和加载都使用的是多卡，因此不存在模型层名前缀不同的问题。但多卡状态下存在一个device（使用的GPU）匹配的问题，即**保存整个模型**时会同时保存所使用的GPU id等信息，读取时若这些信息和当前使用的GPU信息不符则可能会报错或者程序不按预定状态运行。具体表现为以下两点：
-
-**读取整个模型再使用nn.DataParallel进行分布式训练设置**
-
-这种情况很可能会造成保存的整个模型中GPU id和读取环境下设置的GPU id不符，训练时数据所在device和模型所在device不一致而报错。
-
-**读取整个模型而不使用nn.DataParallel进行分布式训练设置**
-
-这种情况可能不会报错，测试中发现程序会自动使用设备的前n个GPU进行训练（n是保存的模型使用的GPU个数）。此时如果指定的GPU个数少于n，则会报错。在这种情况下，只有保存模型时环境的device id和读取模型时环境的device id一致，程序才会按照预期在指定的GPU上进行分布式训练。
-
-相比之下，读取模型权重，之后再使用nn.DataParallel进行分布式训练设置则没有问题。因此**多卡模式下建议使用权重的方式存储和读取模型**：
-
-```python
-import os
-import torch
-from torchvision import models
-
-os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,2' #这里替换成希望使用的GPU编号
-
-model = models.resnet152(pretrained=True)
-model = nn.DataParallel(model).cuda()
-
-# 保存+读取模型权重，强烈建议！！
-torch.save(model.state_dict(), save_dir)
-loaded_model = models.resnet152() #注意这里需要对模型结构有定义
-loaded_model.load_state_dict(torch.load(save_dir)))
-loaded_model = nn.DataParallel(loaded_model).cuda()
-```
-
-如果只有保存的整个模型，也可以采用提取权重的方式构建新的模型：
-
-```python
-# 读取整个模型
-loaded_whole_model = torch.load(save_dir)
-loaded_model = models.resnet152() #注意这里需要对模型结构有定义
-loaded_model.state_dict = loaded_whole_model.state_dict
-loaded_model = nn.DataParallel(loaded_model).cuda()
-```
-
-另外，上面所有对于loaded_model修改权重字典的形式都是通过赋值来实现的，在PyTorch中还可以通过"load_state_dict"函数来实现。因此在上面的所有示例中，我们使用了两种实现方式。
-
-```python
-loaded_model.load_state_dict(loaded_dict)
-```
-
-## 5.4.5 其他参数的保存和读取
-在深度学习项目里，有时候我们不仅仅需要保存模型的权重，还需要保存一些其他的参数，比如训练的epoch数、训练的loss，优化器的参数，动态调整学习策略的参数等等。这些参数可以通过字典的形式保存在一个文件里，然后在读取模型时一起读取。这里我们以下方代码为例：
-```python
-torch.save({
- 'model': model.state_dict(),
- 'optimizer': optimizer.state_dict(),
- 'lr_scheduler': lr_scheduler.state_dict(),
- 'epoch': epoch,
- 'args': args,
- }, checkpoint_path)
-```
-这些参数的读取方式也是类似的：
-```python
-checkpoint = torch.load(checkpoint_path)
-model.load_state_dict(checkpoint['model'])
-optimizer.load_state_dict(checkpoint['optimizer'])
-lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
-epoch = checkpoint['epoch']
-args = checkpoint['args']
-```
-
-## 附：测试环境
-
-OS: Ubuntu 20.04 LTS GPU: GeForce RTX 2080 Ti (x3)
-
-
-
-## 参考资料
-
-本章内容同时发布于[知乎](https://zhuanlan.zhihu.com/p/371090724)和[CSDN](https://blog.csdn.net/goodljq/article/details/117258032)
-
-1. [pytorch 中pkl和pth的区别？](https://www.zhihu.com/question/274533811)
-2. [What is the difference between .pt, .pth and .pwf extentions in PyTorch?](https://stackoverflow.com/questions/59095824/what-is-the-difference-between-pt-pth-and-pwf-extentions-in-pytorch)
diff --git "a/docs/_sources/\347\254\254\344\272\224\347\253\240/index.md.txt" "b/docs/_sources/\347\254\254\344\272\224\347\253\240/index.md.txt"
deleted file mode 100644
index 876329df3..000000000
--- "a/docs/_sources/\347\254\254\344\272\224\347\253\240/index.md.txt"
+++ /dev/null
@@ -1,8 +0,0 @@
-# 第五章：PyTorch模型定义
-```{toctree}
-:maxdepth: 2
-5.1 PyTorch模型定义的方式
-5.2 利用模型块快速搭建复杂网络
-5.3 PyTorch修改模型
-5.4 PyTorh模型保存与读取
-```
\ No newline at end of file
diff --git "a/docs/_sources/\347\254\254\345\205\253\347\253\240/8.1 \346\234\254\347\253\240\347\256\200\344\273\213.md.txt" "b/docs/_sources/\347\254\254\345\205\253\347\253\240/8.1 \346\234\254\347\253\240\347\256\200\344\273\213.md.txt"
deleted file mode 100644
index 3fe148462..000000000
--- "a/docs/_sources/\347\254\254\345\205\253\347\253\240/8.1 \346\234\254\347\253\240\347\256\200\344\273\213.md.txt"
+++ /dev/null
@@ -1,16 +0,0 @@
-# 8.1 本章简介
-
-恭喜你，经过前面七章内容的学习，你已经逐步熟悉了PyTorch的使用，能够定义和修改自己的模型，学会了常用的训练技巧，并通过可视化辅助PyTorch的使用。
-
-PyTorch的强大并不仅局限于自身的易用性，更在于开源社区围绕PyTorch所产生的一系列工具包（一般是Python package）和程序，这些优秀的工具包极大地方便了PyTorch在特定领域的使用。比如对于计算机视觉，有TorchVision、TorchVideo等用于图片和视频处理；对于自然语言处理，有torchtext；对于图卷积网络，有PyTorch Geometric ······。这里只是举例，每个领域还有很多优秀的工具包供社区使用。这些工具包共同构成了PyTorch的生态（EcoSystem）。
-
-PyTorch生态很大程度助力了PyTorch的推广与成功。在特定领域使用PyTorch生态中的工具包，能够极大地降低入门门槛，方便复现已有的工作。比如我们在讨论模型修改时候就用到了torchvision中预定义的resnet结构，而不需要自己重新编写。同时，PyTorch生态有助于社区力量的加入，共同为社区提供更有价值的内容和程序，这也是开源理念所坚持的价值。
-
-在后面的内容中，我们会逐步介绍PyTorch生态在图像、视频、文本等领域中的发展，针对某个领域我们选择其中有代表性的一个工具包进行详细介绍，主要包括工具包的作者或其所在机构、数据预处理工具（这块可能再引入第三方工具包）、数据扩增、常用模型结构的预定义、预训练模型权重、常用损失函数、常用评测指标、封装好的训练&测试模块，以及可视化工具。这些内容也是我们在使用对应工具包时会用到的。读者可以根据自身需要重点学习，对于自己研究所不涉及的工具包，可以只做了解，需要使用时再来学习。
-
-
-
-**注：**
-
-本章内容会不断更新，欢迎大家在issue中提出宝贵建议，或者直接pull request~
-
diff --git "a/docs/_sources/\347\254\254\345\205\253\347\253\240/8.2 \345\233\276\345\203\217 - torchvision.md.txt" "b/docs/_sources/\347\254\254\345\205\253\347\253\240/8.2 \345\233\276\345\203\217 - torchvision.md.txt"
deleted file mode 100644
index a6b762858..000000000
--- "a/docs/_sources/\347\254\254\345\205\253\347\253\240/8.2 \345\233\276\345\203\217 - torchvision.md.txt"
+++ /dev/null
@@ -1,134 +0,0 @@
-# 8.2 torchvision
-
-PyTorch之所以会在短短的几年时间里发展成为主流的深度学习框架，除去框架本身的优势，还在于PyTorch有着良好的生态圈。在前面的学习和实战中，我们经常会用到torchvision来调用预训练模型，加载数据集，对图片进行数据增强的操作。在本章我们将给大家简单介绍下torchvision以及相关操作。
-
-经过本节的学习，你将收获：
-
-- 了解torchvision
-- 了解torchvision的作用
-
-
-
-## 8.2.1 torchvision简介
-
-" The torchvision package consists of popular datasets, model architectures, and common image transformations for computer vision. "
-
-正如引言介绍的一样，我们可以知道torchvision包含了在计算机视觉中常常用到的数据集，模型和图像处理的方式，而具体的torchvision则包括了下面这几部分，带 ***** 的部分是我们经常会使用到的一些库，所以在下面的部分我们对这些库进行一个简单的介绍：
-
-+ torchvision.datasets *
-+ torchvision.models *
-+ torchvision.tramsforms *
-+ torchvision.io
-+ torchvision.ops
-+ torchvision.utils
-
-
-
-## 8.2.2 torchvision.datasets
-
-`torchvision.datasets`主要包含了一些我们在计算机视觉中常见的数据集，在==0.10.0版本==的`torchvision`下，有以下的数据集：
-
-| Caltech | CelebA | CIFAR | Cityscapes |
-| ------------- | ---------------- | ----------------- | ---------- |
-| **EMNIST** | **FakeData** | **Fashion-MNIST** | **Flickr** |
-| **ImageNet** | **Kinetics-400** | **KITTI** | **KMNIST** |
-| **PhotoTour** | **Places365** | **QMNIST** | **SBD** |
-| **SEMEION** | **STL10** | **SVHN** | **UCF101** |
-| **VOC** | **WIDERFace** | | |
-
-
-
-## 8.2.3 torchvision.transforms
-
-我们知道在计算机视觉中处理的数据集有很大一部分是图片类型的，如果获取的数据是格式或者大小不一的图片，则需要进行归一化和大小缩放等操作，这些是常用的数据预处理方法。除此之外，当图片数据有限时，我们还需要通过对现有图片数据进行各种变换，如缩小或放大、水平或垂直翻转等，这些是常见的数据增强方法。而torchvision.transforms中就包含了许多这样的操作。在之前第四章的Fashion-mnist实战中对数据的处理时我们就用到了torchvision.transformer：
-
-```python
-from torchvision import transforms
-data_transform = transforms.Compose([
- transforms.ToPILImage(), # 这一步取决于后续的数据读取方式，如果使用内置数据集则不需要
- transforms.Resize(image_size),
- transforms.ToTensor()
-])
-```
-
-除了上面提到的几种数据增强操作，在torchvision官方文档里提到了更多的操作，具体使用方法也可以参考本节配套的”transforms.ipynb“，在这个notebook中我们给出了常见的transforms的API及其使用方法，更多数据变换的操作我们可以点击[这里](https://pytorch.org/vision/stable/transforms.html)进行查看。
-
-
-
-## 8.2.4 torchvision.models
-
-为了提高训练效率，减少不必要的重复劳动，PyTorch官方也提供了一些预训练好的模型供我们使用，可以点击[这里](https://github.com/pytorch/vision/tree/master/torchvision/models)进行查看现在有哪些预训练模型，下面我们将对如何使用这些模型进行详细介绍。 此处我们以torchvision0.10.0 为例，如果希望获取更多的预训练模型，可以使用使用pretrained-models.pytorch仓库。现有预训练好的模型可以分为以下几类：
-
-+ **Classification**
-
-在图像分类里面，PyTorch官方提供了以下模型，并正在不断增多。
-
-| AlexNet | VGG | ResNet | SqueezeNet |
-| --------------- | ---------------- | ------------- | ----------------- |
-| **DenseNet** | **Inception v3** | **GoogLeNet** | **ShuffleNet v2** |
-| **MobileNetV2** | **MobileNetV3** | **ResNext** | **Wide ResNet** |
-| **MNASNet** | **EfficientNet** | **RegNet** | **持续更新** |
-
-这些模型是在ImageNet-1k进行预训练好的，具体的使用我们会在后面进行介绍。除此之外，我们也可以点击[这里](https://pytorch.org/vision/stable/models.html#)去查看这些模型在ImageNet-1k的准确率。
-
-- **Semantic Segmentation**
-
-语义分割的预训练模型是在COCO train2017的子集上进行训练的，提供了20个类别，包括background, aeroplane, bicycle, bird, boat, bottle, bus, car, cat, chair, cow, diningtable, dog, horse, motorbike, person, pottedplant, sheep, sofa,train, tvmonitor。
-
-| **FCN ResNet50** | **FCN ResNet101** | **DeepLabV3 ResNet50** | **DeepLabV3 ResNet101** |
-| ----------------------------- | ------------------------------- | ---------------------- | ----------------------- |
-| **LR-ASPP MobileNetV3-Large** | **DeepLabV3 MobileNetV3-Large** | **未完待续** | |
-
-具体我们可以点击[这里](https://pytorch.org/vision/stable/models.html#semantic-segmentation)进行查看预训练的模型的`mean IOU`和` global pixelwise acc`
-
-- **Object Detection，instance Segmentation and Keypoint Detection**
-
-物体检测，实例分割和人体关键点检测的模型我们同样是在COCO train2017进行训练的，在下方我们提供了实例分割的类别和人体关键点检测类别：
-
-```python
-COCO_INSTANCE_CATEGORY_NAMES = [
- '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus','train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'N/A', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'N/A', 'backpack', 'umbrella', 'N/A', 'N/A','handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball','kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', 'tennis racket','bottle', 'N/A', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl','banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza','donut', 'cake', 'chair', 'couch', 'potted plant', 'bed', 'N/A', 'dining table','N/A', 'N/A', 'toilet', 'N/A', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone','microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'N/A', 'book','clock', 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush']
-COCO_PERSON_KEYPOINT_NAMES =['nose','left_eye','right_eye','left_ear','right_ear','left_shoulder','right_shoulder','left_elbow','right_elbow','left_wrist','right_wrist','left_hip','right_hip','left_knee','right_knee','left_ankle','right_ankle']
-```
-
-| **Faster R-CNN** | **Mask R-CNN** | **RetinaNet** | **SSDlite** |
-| ---------------- | -------------- | ------------- | ----------- |
-| **SSD** | **未完待续** | | |
-
-同样的，我们可以点击[这里](https://pytorch.org/vision/stable/models.html#object-detection-instance-segmentation-and-person-keypoint-detection)查看这些模型在COCO train 2017上的`box AP`,`keypoint AP`,`mask AP`
-
-- **Video classification**
-
-视频分类模型是在 Kinetics-400上进行预训练的
-
-| **ResNet 3D 18** | **ResNet MC 18** | **ResNet (2+1) D** |
-| ---------------- | ---------------- | ------------------ |
-| **未完待续** | | |
-
-同样我们也可以点击[这里](https://pytorch.org/vision/stable/models.html#video-classification)查看这些模型的`Clip acc@1`,`Clip acc@5`
-
-
-
-## 8.2.5 torchvision.io
-
-在`torchvision.io`提供了视频、图片和文件的 IO 操作的功能，它们包括读取、写入、编解码处理操作。随着torchvision的发展，io也增加了更多底层的高效率的API。在使用torchvision.io的过程中，我们需要注意以下几点：
-
-- 不同版本之间，`torchvision.io`有着较大变化，因此在使用时，需要查看下我们的`torchvision`版本是否存在你想使用的方法。
-- 除了read_video()等方法，torchvision.io为我们提供了一个细粒度的视频API torchvision.io.VideoReader() ，它具有更高的效率并且更加接近底层处理。在使用时，我们需要先安装ffmpeg然后从源码重新编译torchvision我们才能我们能使用这些方法。
-- 在使用Video相关API时，我们最好提前安装好PyAV这个库。
-
-
-
-## 8.2.6 torchvision.ops
-
-torchvision.ops 为我们提供了许多计算机视觉的特定操作，包括但不仅限于NMS，RoIAlign（MASK R-CNN中应用的一种方法），RoIPool（Fast R-CNN中用到的一种方法）。在合适的时间使用可以大大降低我们的工作量，避免重复的造轮子，想看更多的函数介绍可以点击[这里](https://pytorch.org/vision/stable/ops.html)进行细致查看。
-
-
-
-## 8.2.7 torchvision.utils
-
-torchvision.utils 为我们提供了一些可视化的方法，可以帮助我们将若干张图片拼接在一起、可视化检测和分割的效果。具体方法可以点击[这里](https://pytorch.org/vision/stable/utils.html)进行查看。
-
-
-
-总的来说，torchvision的出现帮助我们解决了常见的计算机视觉中一些重复且耗时的工作，并在数据集的获取、数据增强、模型预训练等方面大大降低了我们的工作难度，可以让我们更加快速上手一些计算机视觉任务。
diff --git "a/docs/_sources/\347\254\254\345\205\253\347\253\240/8.3 \350\247\206\351\242\221 - PyTorchVideo.md.txt" "b/docs/_sources/\347\254\254\345\205\253\347\253\240/8.3 \350\247\206\351\242\221 - PyTorchVideo.md.txt"
deleted file mode 100644
index daca38d99..000000000
--- "a/docs/_sources/\347\254\254\345\205\253\347\253\240/8.3 \350\247\206\351\242\221 - PyTorchVideo.md.txt"
+++ /dev/null
@@ -1,108 +0,0 @@
-# 8.3 PyTorchVideo简介
-
-
-
-近几年来，随着传播媒介和视频平台的发展，视频正在取代图片成为下一代的主流媒体，这也使得有关视频的深度学习模型正在获得越来越多的关注。然而，有关视频的深度学习模型仍然有着许多缺点：
-
-- 计算资源耗费更多，并且没有高质量的`model zoo`，不能像图片一样进行迁移学习和论文复现。
-- 数据集处理较麻烦，但没有一个很好的视频处理工具。
-- 随着多模态越来越流行，亟需一个工具来处理其他模态。
-
-除此之外，还有部署优化等问题，为了解决这些问题，Meta推出了`PyTorchVideo`深度学习库（包含组件如Figure 1所示）。PyTorchVideo 是一个专注于视频理解工作的深度学习库。PytorchVideo 提供了加速视频理解研究所需的可重用、模块化和高效的组件。PyTorchVideo 是使用[PyTorch](https://pytorch.org/)开发的，支持不同的深度学习视频组件，如视频模型、视频数据集和视频特定转换。
-
-
-
-
-
-## 8.3.1 PyTorchVideo的主要部件和亮点
-
-PytorchVideo 提供了加速视频理解研究所需的模块化和高效的API。它还支持不同的深度学习视频组件，如视频模型、视频数据集和视频特定转换，最重要的是，PytorchVideo也提供了model zoo，使得人们可以使用各种先进的预训练视频模型及其评判基准。PyTorchVideo主要亮点如下：
-
-- **基于 PyTorch：**使用 PyTorch 构建。使所有 PyTorch 生态系统组件的使用变得容易。
-- **Model Zoo：**PyTorchVideo提供了包含I3D、R(2+1)D、SlowFast、X3D、MViT等SOTA模型的高质量model zoo（目前还在快速扩充中，未来会有更多SOTA model），并且PyTorchVideo的model zoo调用与[PyTorch Hub](https://link.zhihu.com/?target=https%3A//pytorch.org/hub/)做了整合，大大简化模型调用，具体的一些调用方法可以参考下面的【使用 PyTorchVideo model zoo】部分。
-
-- **数据预处理和常见数据**，PyTorchVideo支持Kinetics-400, Something-Something V2, Charades, Ava (v2.2), Epic Kitchen, HMDB51, UCF101, Domsev等主流数据集和相应的数据预处理，同时还支持randaug, augmix等数据增强trick。
-- **模块化设计**：PyTorchVideo的设计类似于torchvision，也是提供许多模块方便用户调用修改，在PyTorchVideo中具体来说包括data, transforms, layer, model, accelerator等模块，方便用户进行调用和读取。
-- **支持多模态**：PyTorchVideo现在对多模态的支持包括了visual和audio，未来会支持更多模态，为多模态模型的发展提供支持。
-- **移动端部署优化**：PyTorchVideo支持针对移动端模型的部署优化（使用前述的PyTorchVideo/accelerator模块），模型经过PyTorchVideo优化了最高达**7倍**的提速，并实现了第一个能实时跑在手机端的X3D模型（实验中可以实时跑在2018年的三星Galaxy S8上，具体请见[Android Demo APP](https://github.com/pytorch/android-demo-app/tree/master/TorchVideo)）。
-
-
-
-## 8.3.2 PyTorchVideo的安装
-
-我们可以直接使用pip来安装PyTorchVideo：
-
-```shell
-pip install pytorchvideo
-```
-
-注：
-
-- 安装的虚拟环境的python版本 >= 3.7
-- PyTorch >= 1.8.0，安装的torchvision也需要匹配
-- CUDA >= 10.2
-- ioPath：[具体情况](https://github.com/facebookresearch/iopath)
-- fvcore版本 >= 0.1.4：[具体情况](https://github.com/facebookresearch/fvcore)
-
-
-
-## 8.3.3 Model zoo 和 benchmark
-
-在下面这部分，我将简单介绍些PyTorchVideo所提供的Model zoo和benchmark
-
-- Kinetics-400
-
-| arch | depth | pretrain | frame length x sample rate | top 1 | top 5 | Flops (G) x views | Params (M) | Model |
-| -------- | ----- | -------- | -------------------------- | ----- | ----- | ----------------- | ---------- | ------------------------------------------------------------ |
-| C2D | R50 | \- | 8x8 | 71.46 | 89.68 | 25.89 x 3 x 10 | 24.33 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/C2D\_8x8\_R50.pyth) |
-| I3D | R50 | \- | 8x8 | 73.27 | 90.70 | 37.53 x 3 x 10 | 28.04 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/I3D\_8x8\_R50.pyth) |
-| Slow | R50 | \- | 4x16 | 72.40 | 90.18 | 27.55 x 3 x 10 | 32.45 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/SLOW\_4x16\_R50.pyth) |
-| Slow | R50 | \- | 8x8 | 74.58 | 91.63 | 54.52 x 3 x 10 | 32.45 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/SLOW\_8x8\_R50.pyth) |
-| SlowFast | R50 | \- | 4x16 | 75.34 | 91.89 | 36.69 x 3 x 10 | 34.48 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/SLOWFAST\_4x16\_R50.pyth) |
-| SlowFast | R50 | \- | 8x8 | 76.94 | 92.69 | 65.71 x 3 x 10 | 34.57 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/SLOWFAST\_8x8\_R50.pyth) |
-| SlowFast | R101 | \- | 8x8 | 77.90 | 93.27 | 127.20 x 3 x 10 | 62.83 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/SLOWFAST\_8x8\_R101.pyth) |
-| SlowFast | R101 | \- | 16x8 | 78.70 | 93.61 | 215.61 x 3 x 10 | 53.77 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/SLOWFAST\_16x8\_R101_50_50.pyth) |
-| CSN | R101 | \- | 32x2 | 77.00 | 92.90 | 75.62 x 3 x 10 | 22.21 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/CSN\_32x2\_R101.pyth) |
-| R(2+1)D | R50 | \- | 16x4 | 76.01 | 92.23 | 76.45 x 3 x 10 | 28.11 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/R2PLUS1D\_16x4\_R50.pyth) |
-| X3D | XS | \- | 4x12 | 69.12 | 88.63 | 0.91 x 3 x 10 | 3.79 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/X3D\_XS.pyth) |
-| X3D | S | \- | 13x6 | 73.33 | 91.27 | 2.96 x 3 x 10 | 3.79 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/X3D\_S.pyth) |
-| X3D | M | \- | 16x5 | 75.94 | 92.72 | 6.72 x 3 x 10 | 3.79 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/X3D\_M.pyth) |
-| X3D | L | \- | 16x5 | 77.44 | 93.31 | 26.64 x 3 x 10 | 6.15 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/X3D\_L.pyth) |
-| MViT | B | \- | 16x4 | 78.85 | 93.85 | 70.80 x 1 x 5 | 36.61 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/MVIT\_B\_16x4.pyth) |
-| MViT | B | \- | 32x3 | 80.30 | 94.69 | 170.37 x 1 x 5 | 36.61 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics/MVIT\_B\_32x3\_f294077834.pyth) |
-
-- Something-Something V2
-
-| arch | depth | pretrain | frame length x sample rate | top 1 | top 5 | Flops (G) x views | Params (M) | Model |
-| -------- | ----- | ------------ | -------------------------- | ----- | ----- | ----------------- | ---------- | ------------------------------------------------------------ |
-| Slow | R50 | Kinetics 400 | 8x8 | 60.04 | 85.19 | 55.10 x 3 x 1 | 31.96 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/ssv2/SLOW\_8x8\_R50.pyth) |
-| SlowFast | R50 | Kinetics 400 | 8x8 | 61.68 | 86.92 | 66.60 x 3 x 1 | 34.04 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/ssv2/SLOWFAST\_8x8\_R50.pyth) |
-
-- Charades
-
-| arch | depth | pretrain | frame length x sample rate | MAP | Flops (G) x views | Params (M) | Model |
-| -------- | ----- | ------------ | -------------------------- | ----- | ----------------- | ---------- | ------------------------------------------------------------ |
-| Slow | R50 | Kinetics 400 | 8x8 | 34.72 | 55.10 x 3 x 10 | 31.96 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/charades/SLOW\_8x8\_R50.pyth) |
-| SlowFast | R50 | Kinetics 400 | 8x8 | 37.24 | 66.60 x 3 x 10 | 34.00 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/charades/SLOWFAST\_8x8\_R50.pyth) |
-
-- AVA (V2.2)
-
-| arch | depth | pretrain | frame length x sample rate | MAP | Params (M) | Model |
-| -------- | ----- | ------------ | -------------------------- | ----- | ---------- | ------------------------------------------------------------ |
-| Slow | R50 | Kinetics 400 | 4x16 | 19.5 | 31.78 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/ava/SLOW\_4x16\_R50\_DETECTION.pyth) |
-| SlowFast | R50 | Kinetics 400 | 8x8 | 24.67 | 33.82 | [link](https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/ava/SLOWFAST\_8x8\_R50\_DETECTION.pyth) |
-
-
-
-## 8.3.4 使用 PyTorchVideo model zoo
-
-PyTorchVideo提供了三种使用方法，并且给每一种都配备了`tutorial`
-
-* TorchHub，这些模型都已经在TorchHub存在。我们可以根据实际情况来选择需不需要使用预训练模型。除此之外，官方也给出了TorchHub使用的 [tutorial](https://pytorchvideo.org/docs/tutorial_torchhub_inference) 。
-* PySlowFast，使用 [PySlowFast workflow](https://github.com/facebookresearch/SlowFast/) 去训练或测试PyTorchVideo models/datasets.
-* [PyTorch Lightning](https://github.com/PyTorchLightning/pytorch-lightning)建立一个工作流进行处理，点击查看官方 [tutorial](https://pytorchvideo.org/docs/tutorial_classification)。
-
-- 如果想查看更多的使用教程，可以点击 [这里](https://github.com/facebookresearch/pytorchvideo/tree/main/tutorials) 进行尝试
-
-总的来说，PyTorchVideo的使用与torchvision的使用方法类似，在有了前面的学习基础上，我们可以很快上手PyTorchVideo，具体的我们可以通过查看官方提供的文档和一些例程来了解使用方法：[官方网址](https://pytorchvideo.readthedocs.io/en/latest/index.html)
-
diff --git "a/docs/_sources/\347\254\254\345\205\253\347\253\240/8.4 \346\226\207\346\234\254 - torchtext.md.txt" "b/docs/_sources/\347\254\254\345\205\253\347\253\240/8.4 \346\226\207\346\234\254 - torchtext.md.txt"
deleted file mode 100644
index c38c7ec65..000000000
--- "a/docs/_sources/\347\254\254\345\205\253\347\253\240/8.4 \346\226\207\346\234\254 - torchtext.md.txt"
+++ /dev/null
@@ -1,172 +0,0 @@
-# 8.4 torchtext简介
-
-本节我们来介绍PyTorch官方用于自然语言处理（NLP）的工具包torchtext。自然语言处理也是深度学习的一大应用场景，近年来随着大规模预训练模型的应用，深度学习在人机对话、机器翻译等领域的取得了非常好的效果，也使得NLP相关的深度学习模型获得了越来越多的关注。
-
-由于NLP和CV在数据预处理中的不同，因此NLP的工具包torchtext和torchvision等CV相关工具包也有一些功能上的差异，如：
-
-- 数据集（dataset）定义方式不同
-- 数据预处理工具
-- 没有琳琅满目的model zoo
-
-本节介绍参考了[atnlp的Github](https://github.com/atnlp/torchtext-summary)，在此致谢！
-
-
-
-## 8.4.1 torchtext的主要组成部分
-
-torchtext可以方便的对文本进行预处理，例如截断补长、构建词表等。torchtext主要包含了以下的主要组成部分：
-
-- 数据处理工具 torchtext.data.functional、torchtext.data.utils
-- 数据集 torchtext.data.datasets
-- 词表工具 torchtext.vocab
-- 评测指标 torchtext.metrics
-
-## 8.4.2 torchtext的安装
-
-torchtext可以直接使用pip进行安装：
-
-```bash
-pip install torchtext
-```
-
-## 8.4.3 构建数据集
-
-- **Field及其使用**
-
-Field是torchtext中定义数据类型以及转换为张量的指令。`torchtext` 认为一个样本是由多个字段（文本字段，标签字段）组成，不同的字段可能会有不同的处理方式，所以才会有 `Field` 抽象。定义Field对象是为了明确如何处理不同类型的数据，但具体的处理则是在Dataset中完成的。下面我们通过一个例子来简要说明一下Field的使用：
-
-```python
-tokenize = lambda x: x.split()
-TEXT = data.Field(sequential=True, tokenize=tokenize, lower=True, fix_length=200)
-LABEL = data.Field(sequential=False, use_vocab=False)
-```
-
-其中：
-
- sequential设置数据是否是顺序表示的；
-
- tokenize用于设置将字符串标记为顺序实例的函数
-
- lower设置是否将字符串全部转为小写；
-
- fix_length设置此字段所有实例都将填充到一个固定的长度，方便后续处理；
-
- use_vocab设置是否引入Vocab object，如果为False，则需要保证之后输入field中的data都是numerical的
-
-构建Field完成后就可以进一步构建dataset了：
-
-```python
-from torchtext import data
-def get_dataset(csv_data, text_field, label_field, test=False):
- fields = [("id", None), # we won't be needing the id, so we pass in None as the field
- ("comment_text", text_field), ("toxic", label_field)]
- examples = []
-
- if test:
- # 如果为测试集，则不加载label
- for text in tqdm(csv_data['comment_text']):
- examples.append(data.Example.fromlist([None, text, None], fields))
- else:
- for text, label in tqdm(zip(csv_data['comment_text'], csv_data['toxic'])):
- examples.append(data.Example.fromlist([None, text, label], fields))
- return examples, fields
-```
-
-这里使用数据csv_data中有"comment_text"和"toxic"两列，分别对应text和label。
-
-```python
-train_data = pd.read_csv('train_toxic_comments.csv')
-valid_data = pd.read_csv('valid_toxic_comments.csv')
-test_data = pd.read_csv("test_toxic_comments.csv")
-TEXT = data.Field(sequential=True, tokenize=tokenize, lower=True)
-LABEL = data.Field(sequential=False, use_vocab=False)
-
-# 得到构建Dataset所需的examples和fields
-train_examples, train_fields = get_dataset(train_data, TEXT, LABEL)
-valid_examples, valid_fields = get_dataset(valid_data, TEXT, LABEL)
-test_examples, test_fields = get_dataset(test_data, TEXT, None, test=True)
-# 构建Dataset数据集
-train = data.Dataset(train_examples, train_fields)
-valid = data.Dataset(valid_examples, valid_fields)
-test = data.Dataset(test_examples, test_fields)
-```
-
-可以看到，定义Field对象完成后，通过get_dataset函数可以读入数据的文本和标签，将二者（examples）连同field一起送到torchtext.data.Dataset类中，即可完成数据集的构建。使用以下命令可以看下读入的数据情况：
-
-```python
-# 检查keys是否正确
-print(train[0].__dict__.keys())
-print(test[0].__dict__.keys())
-# 抽查内容是否正确
-print(train[0].comment_text)
-```
-
-- **词汇表（vocab）**
-
-在NLP中，将字符串形式的词语（word）转变为数字形式的向量表示（embedding）是非常重要的一步，被称为Word Embedding。这一步的基本思想是收集一个比较大的语料库（尽量与所做的任务相关），在语料库中使用word2vec之类的方法构建词语到向量（或数字）的映射关系，之后将这一映射关系应用于当前的任务，将句子中的词语转为向量表示。
-
-在torchtext中可以使用Field自带的build_vocab函数完成词汇表构建。
-
-```python
-TEXT.build_vocab(train)
-```
-
-- **数据迭代器**
-
-其实就是torchtext中的DataLoader，看下代码就明白了：
-
-```python
-from torchtext.data import Iterator, BucketIterator
-# 若只针对训练集构造迭代器
-# train_iter = data.BucketIterator(dataset=train, batch_size=8, shuffle=True, sort_within_batch=False, repeat=False)
-
-# 同时对训练集和验证集进行迭代器的构建
-train_iter, val_iter = BucketIterator.splits(
- (train, valid), # 构建数据集所需的数据集
- batch_sizes=(8, 8),
- device=-1, # 如果使用gpu，此处将-1更换为GPU的编号
- sort_key=lambda x: len(x.comment_text), # the BucketIterator needs to be told what function it should use to group the data.
- sort_within_batch=False
-)
-
-test_iter = Iterator(test, batch_size=8, device=-1, sort=False, sort_within_batch=False)
-```
-
-torchtext支持只对一个dataset和同时对多个dataset构建数据迭代器。
-
-- **使用自带数据集**
-
-与torchvision类似，torchtext也提供若干常用的数据集方便快速进行算法测试。可以查看[官方文档](https://pytorch.org/text/stable/datasets.html)寻找想要使用的数据集。
-
-
-
-## 8.4.4 评测指标（metric）
-
-NLP中部分任务的评测不是通过准确率等指标完成的，比如机器翻译任务常用BLEU (bilingual evaluation understudy) score来评价预测文本和标签文本之间的相似程度。torchtext中可以直接调用torchtext.data.metrics.bleu_score来快速实现BLEU，下面是一个官方文档中的一个例子：
-
-```python
-from torchtext.data.metrics import bleu_score
-candidate_corpus = [['My', 'full', 'pytorch', 'test'], ['Another', 'Sentence']]
-references_corpus = [[['My', 'full', 'pytorch', 'test'], ['Completely', 'Different']], [['No', 'Match']]]
-bleu_score(candidate_corpus, references_corpus)
-```
-
-```
-0.8408964276313782
-```
-
-
-
-## 8.4.5 其他
-
-值得注意的是，由于NLP常用的网络结构比较固定，torchtext并不像torchvision那样提供一系列常用的网络结构。模型主要通过torch.nn中的模块来实现，比如torch.nn.LSTM、torch.nn.RNN等。
-
-**备注：**
-
-对于文本研究而言，当下Transformer已经成为了绝对的主流，因此PyTorch生态中的[HuggingFace](https://huggingface.co/)等工具包也受到了越来越广泛的关注。这里强烈建议读者自行探索相关内容，可以写下自己对于HuggingFace的笔记，如果总结全面的话欢迎pull request，充实我们的课程内容。
-
-**本节参考**
-
-- [torchtext官方文档](https://pytorch.org/text/stable/index.html)
-- [atnlp/torchtext-summary](https://github.com/atnlp/torchtext-summary)
-
diff --git "a/docs/_sources/\347\254\254\345\205\253\347\253\240/8.5 \351\237\263\351\242\221 - torchaudio.md.txt" "b/docs/_sources/\347\254\254\345\205\253\347\253\240/8.5 \351\237\263\351\242\221 - torchaudio.md.txt"
deleted file mode 100644
index d54ade84c..000000000
--- "a/docs/_sources/\347\254\254\345\205\253\347\253\240/8.5 \351\237\263\351\242\221 - torchaudio.md.txt"
+++ /dev/null
@@ -1,135 +0,0 @@
-# 8.5 torchaudio简介
-
-本节我们来介绍PyTorch官方用于语音处理的工具包torchaduio。语音的处理也是深度学习的一大应用场景，包括说话人识别(Speaker Identification)，说话人分离(Speaker Diarization)，音素识别(Phoneme Recognition)，语音识别(Automatic Speech Recognition)，语音分离(Speech Separation)，文本转语音(TTS)等任务。
-
-CV有torchvision，NLP有torchtext，人们希望语音领域中也能有一个工具包。而语音的处理工具包就是torchaudio。由于语音任务本身的特性，导致其与NLP和CV在数据处理、模型构建、模型验证有许多不同，因此语音的工具包torchaudio和torchvision等CV相关工具包也有一些功能上的差异。
-
-通过本章的学习，你将收获：
-
-- 语音数据的I/O
-- 语音数据的预处理
-- 语音领域的数据集
-- 语音领域的模型
-
-## 8.4.1 torchaduio的主要组成部分
-torchaduio主要包括以下几个部分：
-
-- torchaudio.io：有关音频的I/O
-- torchaudio.backend：提供了音频处理的后端，包括：sox，soundfile等
-- torchaudio.functional：包含了常用的语音数据处理方法，如：spectrogram，create_fb_matrix等
-- torchaudio.transforms：包含了常用的语音数据预处理方法，如：MFCC，MelScale，AmplitudeToDB等
-- torchaudio.datasets：包含了常用的语音数据集，如：VCTK，LibriSpeech，yesno等
-- torchaudio.models：包含了常用的语音模型，如：Wav2Letter，DeepSpeech等
-- torchaudio.models.decoder：包含了常用的语音解码器，如：GreedyDecoder，BeamSearchDecoder等
-- torchaudio.pipelines：包含了常用的语音处理流水线，如：SpeechRecognitionPipeline，SpeakerRecognitionPipeline等
-- torchaudio.sox_effects：包含了常用的语音处理方法，如：apply_effects_tensor，apply_effects_file等
-- torchaudio.compliance.kaldi：包含了与Kaldi工具兼容的方法，如：load_kaldi_fst，load_kaldi_ark等
-- torchaudio.kalid_io：包含了与Kaldi工具兼容的方法，如：read_vec_flt_scp，read_vec_int_scp等
-- torchaudio.utils：包含了常用的语音工具方法，如：get_audio_backend，set_audio_backend等
-
-## 8.4.2 torchaduio的安装
-一般在安装torch的同时，也会安装torchaudio。假如我们的环境中没有torchaudio，我们可以使用pip或者conda去安装它。只需要执行以下命令即可：
-
-```shell
-pip install torchaudio # conda install torchaudio
-```
-在安装的时候，我们一定要根据自己的PyTorch版本和Python版本选择对应的torchaudio的版本，具体我们可以查看[torchaudio Compatibility Matrix](https://pytorch.org/audio/main/installation.html#compatibility-matrix)
-
-## 8.4.3 datasets的构建
-torchaudio中对于一些公共数据集，我们可以主要通过torchaudio.datasets来实现。对于私有数据集，我们也可以通过继承torch.utils.data.Dataset来构建自己的数据集。数据集的读取和处理，我们可以通过torch.utils.data.DataLoader来实现。
-```python
-import torchaudio
-import torch
-
-# 公共数据集的构建
-yesno_data = torchaudio.datasets.YESNO('.', download=True)
-data_loader = torch.utils.data.DataLoader(
- yesno_data,
- batch_size=1,
- shuffle=True,
- num_workers=4)
-```
-
-torchaudio提供了许多常用的语音数据集，包括CMUARCTIC，CMUDict，COMMONVOICE，DR_VCTK，FluentSpeechCommands，GTZAN，IEMOCAP，LIBRISPEECH，LIBRITTS，LJSPEECH，LibriLightLimited，LibriMix，MUSDB_HQ，QUESST14，SPEECHCOMMANDS，Snips，TEDLIUM，VCTK_092，VoxCeleb1Identification，VoxCeleb1Verification，YESNO等。具体的我们可以通过以下命令来查看：
-
-```python
-import torchaudio
-dir(torchaudio.datasets)
-```
-```shell
-'CMUARCTIC','CMUDict','COMMONVOICE','DR_VCTK','FluentSpeechCommands',
-'GTZAN','IEMOCAP','LIBRISPEECH','LIBRITTS','LJSPEECH','LibriLightLimited',
-'LibriMix','MUSDB_HQ','QUESST14','SPEECHCOMMANDS','Snips','TEDLIUM',
-'VCTK_092','VoxCeleb1Identification','VoxCeleb1Verification','YESNO']
-```
-## 8.4.4 model和pipeline的构建
-torchaudio.models包含了常见语音任务的模型的定义，包括：Wav2Letter，DeepSpeech，HuBERTPretrainModel等。torchaudio.pipelines则是将预训练模型和其对应的任务组合在一起，构成了一个完整的语音处理流水线。torchaudio.pipeline相较于torchvision这种视觉库而言，是torchaudio的精华部分。我们在此也不进行过多的阐述，对于进一步的学习，我们可以参考官方给出的[Pipeline Tutorials](https://pytorch.org/audio/stable/tutorials/speech_recognition_pipeline_tutorial.html)和[torchaudio.pipelines docs](https://pytorch.org/audio/stable/pipelines.html)。
-
-
-## 8.4.5 transforms和functional的使用
-torchaudio.transform模块包含常见的音频处理和特征提取。torchaudio.functional则包括了一些常见的音频操作的函数。关于torchaudio.transform，官方提供了一个流程图供我们参考学习：
-
-torchaudio.transforms继承于torch.nn.Module，但是不同于torchvision.transforms，torchaudio没有compose方法将多个transform组合起来。因此torchaudio构建transform pipeline的常见方法是自定义模块类或使用torch.nn.Sequential将他们在一起。然后将其移动到目标设备和数据类型。我们可以参考官方所给出的例子：
-```python
-# Define custom feature extraction pipeline.
-#
-# 1. Resample audio
-# 2. Convert to power spectrogram
-# 3. Apply augmentations
-# 4. Convert to mel-scale
-#
-class MyPipeline(torch.nn.Module):
- def __init__(
- self,
- input_freq=16000,
- resample_freq=8000,
- n_fft=1024,
- n_mel=256,
- stretch_factor=0.8,
- ):
- super().__init__()
- self.resample = Resample(orig_freq=input_freq, new_freq=resample_freq)
- self.spec = Spectrogram(n_fft=n_fft, power=2)
- self.spec_aug = torch.nn.Sequential(
- TimeStretch(stretch_factor, fixed_rate=True),
- FrequencyMasking(freq_mask_param=80),
- TimeMasking(time_mask_param=80),
- )
- self.mel_scale = MelScale(
- n_mels=n_mel, sample_rate=resample_freq, n_stft=n_fft // 2 + 1)
-
- def forward(self, waveform: torch.Tensor) -> torch.Tensor:
- # Resample the input
- resampled = self.resample(waveform)
- # Convert to power spectrogram
- spec = self.spec(resampled)
- # Apply SpecAugment
- spec = self.spec_aug(spec)
- # Convert to mel-scale
- mel = self.mel_scale(spec)
- return mel
-```
-torchaudio.transform的使用，我们可以参考[torchaudio.transforms](https://pytorch.org/audio/main/transforms.html)进一步了解。
-
-torchaudio.functional支持了许多语音的处理方法，关于torchaudio.functional的使用，我们可以参考[torchaudio.functional](https://pytorch.org/audio/main/functional.html)进一步了解。
-## 8.4.6 compliance和kaldi_io的使用
-Kaldi是一个用于语音识别研究的工具箱,由CMU开发,开源免费。它包含了构建语音识别系统所需的全部组件,是语音识别领域最流行和影响力最大的开源工具之一。torchaudio中提供了一些与Kaldi工具兼容的方法，这些方法分别属于torchaduio.compliance.kaldi，torchaduio.kaldi_io。
-### torchaduio.compliance.kaldi
-在torchaudio.compliance.kaldi中，torchaudio提供了以下三种方法：
-- torchaudio.compliance.kaldi.spectrogram：从语音信号中提取Spectrogram特征
-- torchaudio.compliance.kaldi.fbank：从语音信号中提取FBank特征
-- torchaduio.compliance.kaldi.mfcc：从语音信号中提取MFCC特征
-### torchaduio.kaldi_io
-torchaudio.kaldi_io是一个torchaudio的子模块,用于读取和写入Kaldi的数据集格式。当我们要使用torchaudio.kaldi_io时,我们需要先确保[kalid_io](https://github.com/vesis84/kaldi-io-for-python)已经安装。
-
-具体来说，主要接口包括：
-- torchaudio.kaldi_io.read_vec_int_ark：从Kaldi的scp文件中读取float类型的数据
-- torchaudio.kaldi_io.read_vec_flt_scp
-- torchaudio.kaldi_io.read_vec_flt_ark
-- torchaudio.kaldi_io.read_mat_scp
-- torchaudio.kaldi_io.read_mat_ark
-
-具体的使用方法，我们可以参考[torchaudio.kaldi_io](https://pytorch.org/audio/stable/kaldi_io.html)进一步了解。
-
-## 总结
-本节我们主要介绍了torchaudio的基本使用方法和常用的模块，如果想要进一步学习，可以参考[torchaudio官方文档](https://pytorch.org/audio/stable/index.html)。
\ No newline at end of file
diff --git "a/docs/_sources/\347\254\254\345\205\253\347\253\240/index.md.txt" "b/docs/_sources/\347\254\254\345\205\253\347\253\240/index.md.txt"
deleted file mode 100644
index 8f3159280..000000000
--- "a/docs/_sources/\347\254\254\345\205\253\347\253\240/index.md.txt"
+++ /dev/null
@@ -1,9 +0,0 @@
-# 第八章：PyTorch生态简介
-```{toctree}
-:maxdepth: 2
-8.1 本章简介
-8.2 图像 - torchvision
-8.3 视频 - PyTorchVideo
-8.4 文本 - torchtext
-8.5 音频 - torchaudio
-```
\ No newline at end of file
diff --git "a/docs/_sources/\347\254\254\345\205\253\347\253\240/transforms\345\256\236\346\223\215.md.txt" "b/docs/_sources/\347\254\254\345\205\253\347\253\240/transforms\345\256\236\346\223\215.md.txt"
deleted file mode 100644
index 2f2875067..000000000
--- "a/docs/_sources/\347\254\254\345\205\253\347\253\240/transforms\345\256\236\346\223\215.md.txt"
+++ /dev/null
@@ -1,249 +0,0 @@
-# transforms实战
-
-
-```python
-from PIL import Image
-from torchvision import transforms
-import matplotlib.pyplot as plt
-%matplotlib inline
-# 加载原始图片
-img = Image.open("./lenna.jpg")
-print(img.size)
-plt.imshow(img)
-```
-
- (316, 316)
- 
-
-左：VGG-19模型，作为参考。 中：一个有34个参数层的普通网络。 右：一个有34个参数层的残差网络（即resnet34）
-
-在上图最右侧的路径中，我们可以很明显的看到shortcut connection加入了网络之中，同时，图中也很明显的可以看到，实线部分就是进行了单纯的F(x)+x操作，而虚线部分，第一个卷积层的stride是2（那个/2的意思就是stride是2）；同时注意到深度也发生了变换，channel数目增加一倍（扩大两倍），这样F(x)的分辨率比x小一半，厚度比x大一倍。在这样的shortcut connection中，就需要补充线性映射来增加维度。在ResNet中，作者使用了1 x 1的卷积核来达到这个目的。
-
-另外，论文中又提到说：“……where both designs have similar time complexity.” 既然BasicBlock和Bottleneck二者的时间复杂度类似，那么为什么还要额外设计一个Bottleneck结构呢？
-
-根据前面的叙述我们知道，BasicBlock结构比传统的卷积结构多了一个shortcut支路，用于传递低层的信息，使得网络能够训练地很深。而BottleNeck先通过一个1x1的卷积减少通道数，使得中间卷积的通道数减少为1/4；中间的普通卷积做完卷积后输出通道数等于输入通道数；第三个卷积用于恢复通道数，使得BottleNeck的输出通道数等于BottleNeck的输入通道数。**换句话说，这两个1x1卷积有效地减少了卷积的参数个数和计算量，同时减少了中间特征图的通道数，使单个Block消耗的显存更少，在较深的网络中BottleNeck会在参数上更加节约，这样可以有利于构建层数更多的网络，同时还能保持性能的提升。**所以resnet50, resnet101和resnet152使用了另外设计的BottleNeck结构。
-
-#### 2.2.2 BasicBlock
-
-BasicBlock模块用来构建resnet18和resnet34
-
-```python
-class BasicBlock(nn.Module):
- expansion: int = 1
-
- def __init__(
- self,
- inplanes: int,
- planes: int,
- stride: int = 1,
- downsample: Optional[nn.Module] = None,
- groups: int = 1,
- base_width: int = 64,
- dilation: int = 1,
- norm_layer: Optional[Callable[..., nn.Module]] = None,
- ) -> None:
- super().__init__()
- if norm_layer is None:
- norm_layer = nn.BatchNorm2d
- if groups != 1 or base_width != 64:
- raise ValueError("BasicBlock only supports groups=1 and base_width=64")
- if dilation > 1:
- raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
- # Both self.conv1 and self.downsample layers downsample the input when stride != 1
- self.conv1 = conv3x3(inplanes, planes, stride)
- self.bn1 = norm_layer(planes)
- self.relu = nn.ReLU(inplace=True)
- self.conv2 = conv3x3(planes, planes)
- self.bn2 = norm_layer(planes)
- self.downsample = downsample
- self.stride = stride
-
- def forward(self, x: Tensor) -> Tensor:
- identity = x # x 给自己先备份一份
-
- out = self.conv1(x) # 对x做卷积
- out = self.bn1(out) # 对x归一化
- out = self.relu(out) # 对x用激活函数
-
- out = self.conv2(out) # 对x做卷积
- out = self.bn2(out) # 归一化
-
- if self.downsample is not None:
- identity = self.downsample(x)
-
- out += identity # 进行downsample
- out = self.relu(out)
-
- return out
-```
-
-#### 2.2.3 BottleNeck
-
-BottleNeck模块用来构建resnet50，resnet101和resnet152
-
-```python
-class Bottleneck(nn.Module):
- # Bottleneck in torchvision places the stride for downsampling at 3x3 convolution(self.conv2)
- # while original implementation places the stride at the first 1x1 convolution(self.conv1)
- # according to "Deep residual learning for image recognition"https://arxiv.org/abs/1512.03385.
- # This variant is also known as ResNet V1.5 and improves accuracy according to
- # https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch.
-
- expansion: int = 4 # 对输出通道进行倍增
-
- def __init__(
- self,
- inplanes: int,
- planes: int,
- stride: int = 1,
- downsample: Optional[nn.Module] = None,
- groups: int = 1,
- base_width: int = 64,
- dilation: int = 1,
- norm_layer: Optional[Callable[..., nn.Module]] = None,
- ) -> None:
- super().__init__()
- if norm_layer is None:
- norm_layer = nn.BatchNorm2d
- width = int(planes * (base_width / 64.0)) * groups
- # Both self.conv2 and self.downsample layers downsample the input when stride != 1
- self.conv1 = conv1x1(inplanes, width)
- self.bn1 = norm_layer(width)
- self.conv2 = conv3x3(width, width, stride, groups, dilation)
- self.bn2 = norm_layer(width)
- self.conv3 = conv1x1(width, planes * self.expansion)
- self.bn3 = norm_layer(planes * self.expansion)
- self.relu = nn.ReLU(inplace=True)
- self.downsample = downsample
- self.stride = stride
-
- # Bottleneckd forward函数和BasicBlock类似，不再额外注释
- def forward(self, x: Tensor) -> Tensor:
- identity = x
-
- out = self.conv1(x)
- out = self.bn1(out)
- out = self.relu(out)
-
- out = self.conv2(out)
- out = self.bn2(out)
- out = self.relu(out)
-
- out = self.conv3(out)
- out = self.bn3(out)
-
- if self.downsample is not None:
- identity = self.downsample(x)
-
- out += identity
- out = self.relu(out)
-
- return out
-```
-
-我们在这里再对代码中**expansion**的作用做一个说明，我们可以重新回顾一下下面这张图。
-
-
-
-expansion简单来说就是对输出通道的倍乘。在BasicBlock和BottleNeck中，“\_\_init\_\_”函数中有三个比较关键的参数：inplanes,planes和stride，这三者分别表示输入的通道数，输出的通道数和步幅。在两个模块中，\_\_init__传入的planes都是64,128,156,512，但我们观察上面的表格，会发现对于ResNet-50，ResNet-101和ResNet-152而言，它们需要的输出通道应该为256,512,1024,2048才对。因此在这里设置expansion=4，对应上面BottleNeck代码中的30行和31行，将每一个planes都乘上这个expansion，就得到了需要的通道数；而对于ResNet-18和ResNet-34而言，输入通道和输出通道的维度上没有发生变化，因此expansion也设置为1。
-
-### 2.3 网络整体结构
-
-在定义好最基本的Bottlenneck和BasicBlock后，我们就可以构建ResNet网络了。
-
-```python
-class ResNet(nn.Module):
- def __init__(
- self,
- block: Type[Union[BasicBlock, Bottleneck]], # 选择基本模块
- layers: List[int], # 每一层block的数目构成 -> [3,4,6,3]
- num_classes: int = 1000, # 分类数目
- zero_init_residual: bool = False, # 初始化
-
- #######其他卷积构成，与本文ResNet无关######
- groups: int = 1,
- width_per_group: int = 64,
- replace_stride_with_dilation: Optional[List[bool]] = None,
- #########################################
-
- norm_layer: Optional[Callable[..., nn.Module]] = None, # norm层
- ) -> None:
- super().__init__()
- _log_api_usage_once(self)
- if norm_layer is None:
- norm_layer = nn.BatchNorm2d
- self._norm_layer = norm_layer
-
- self.inplanes = 64 # 输入通道
-
- #######其他卷积构成，与本文ResNet无关######
- self.dilation = 1 # 空洞卷积
- if replace_stride_with_dilation is None:
- # each element in the tuple indicates if we should replace
- # the 2x2 stride with a dilated convolution instead
- replace_stride_with_dilation = [False, False, False]
- if len(replace_stride_with_dilation) != 3:
- raise ValueError(
- "replace_stride_with_dilation should be None "
- f"or a 3-element tuple, got {replace_stride_with_dilation}"
- )
- self.groups = groups
- self.base_width = width_per_group
- #########################################
-
- self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias=False)
- self.bn1 = norm_layer(self.inplanes)
- self.relu = nn.ReLU(inplace=True)
- self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
- # 通过_make_layer带到层次化设计的效果
- self.layer1 = self._make_layer(block, 64, layers[0]) # 对应着conv2_x
- self.layer2 = self._make_layer(block, 128, layers[1], stride=2, dilate=replace_stride_with_dilation[0]) # 对应着conv3_x
- self.layer3 = self._make_layer(block, 256, layers[2], stride=2, dilate=replace_stride_with_dilation[1]) # 对应着conv4_x
- self.layer4 = self._make_layer(block, 512, layers[3], stride=2, dilate=replace_stride_with_dilation[2]) # 对应着conv5_x
- # 分类头
- self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
- self.fc = nn.Linear(512 * block.expansion, num_classes)
-
- # 模型初始化
- for m in self.modules():
- if isinstance(m, nn.Conv2d):
- nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
- elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
- nn.init.constant_(m.weight, 1)
- nn.init.constant_(m.bias, 0)
-
- # Zero-initialize the last BN in each residual branch,
- # so that the residual branch starts with zeros, and each residual block behaves like an identity.
- # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
- if zero_init_residual:
- for m in self.modules():
- if isinstance(m, Bottleneck) and m.bn3.weight is not None:
- nn.init.constant_(m.bn3.weight, 0) # type: ignore[arg-type]
- elif isinstance(m, BasicBlock) and m.bn2.weight is not None:
- nn.init.constant_(m.bn2.weight, 0) # type: ignore[arg-type]
- # 层次化设计
- def _make_layer(
- self,
- block: Type[Union[BasicBlock, Bottleneck]], # 基本构成模块选择
- planes: int, # 输入的通道
- blocks: int, # 模块数目
- stride: int = 1, # 步长
- dilate: bool = False, # 空洞卷积，与本文无关
- ) -> nn.Sequential:
- norm_layer = self._norm_layer
- downsample = None # 是否采用下采样
- ####################无关#####################
- previous_dilation = self.dilation
- if dilate:
- self.dilation *= stride
- stride = 1
- #############################################
- if stride != 1 or self.inplanes != planes * block.expansion:
- downsample = nn.Sequential(
- conv1x1(self.inplanes, planes * block.expansion, stride),
- norm_layer(planes * block.expansion),
- )
-
- # 使用layers存储每个layer
- layers = []
- layers.append(
- block(
- self.inplanes, planes, stride, downsample, self.groups, self.base_width, previous_dilation, norm_layer
- )
- )
- self.inplanes = planes * block.expansion
- for _ in range(1, blocks):
- layers.append(
- block(
- self.inplanes,
- planes,
- groups=self.groups,
- base_width=self.base_width,
- dilation=self.dilation,
- norm_layer=norm_layer,
- )
- )
- # 将layers通过nn.Sequential转化为网络
- return nn.Sequential(*layers)
-
- def _forward_impl(self, x: Tensor) -> Tensor:
- # See note [TorchScript super()]
- x = self.conv1(x) # conv1 x shape [1 64 112 112]
- x = self.bn1(x) # 归一化处理
- x = self.relu(x) # 激活函数
- x = self.maxpool(x) # conv2_x的3x3 maxpool x shape [1 64 56 56]
-
- x = self.layer1(x) # layer 1
- x = self.layer2(x) # layer 2
- x = self.layer3(x) # layer 3
- x = self.layer4(x) # layer 4
-
- x = self.avgpool(x) # 自适应池化
- x = torch.flatten(x, 1)
- x = self.fc(x) # 分类
-
- return x
-
- def forward(self, x: Tensor) -> Tensor:
- return self._forward_impl(x)
-```
-
-观察上述代码，我们不难看到，首先是一个7 x 7的卷积作用在输入的3维图片上，并输入一个64维的特征图（即self.inplanes的初始值），通过BatchNorm层，ReLU层，MaxPool层；然后经过_make_layer()函数构建的4层layer，最后经过一个AveragePooling层，再经过一个fc层得到分类输出。在网络搭建起来后，还对模型的参数(Conv2d、BatchNorm2d、last BN)进行了初始化。
-
-而对于\_make_layer函数，一个_make_layer()构建一个layer层，每一个layer层是上述两种基本模块的堆叠。输入参数中block代表该layer堆叠模块的类型，可选BasicBlock或者BottleNeck；blocks代表该layer中堆叠的block的数目；planes与该layer最终输出的维度数有关，注意最终输出的维度数为planes * block.expansion。除此之外， _make\_layer()是用来生成残差块的，这就牵扯到它的第四个参数：stride，即卷积步幅。该函数中首先定义了如果stride不等于1或者维度不匹配（即输入通道不满足对应关系）的时候的downsample，然后对其进行一次BN操作。接着对inplanes和planes不一致的情况进行了一次downsample ，即将带downsample的block添加至layers。这样保证了x和out的维度一致，接下来通过一个循环添加了指定个数的Block，由于x已经维度一致了，这样添加的其他的Block就可以不用降维了，所以循环添加不含Downsample的Block。正如下面代码所示
-
-```python
-if stride != 1 or self.inplanes != planes * block.expansion:
- downsample = nn.Sequential(
- conv1x1(self.inplanes, planes * block.expansion, stride),
- norm_layer(planes * block.expansion),
- )
-```
-
-当一个layer包含多个block时，是通过向layers列表中依次加入每个block，来实现block的堆叠的。第一个block需要特殊处理，该block依据传入的self.inplanes, planes以及stride判断，可能含有downsample支路；这个block的输出维度是planes\*block.expansion。紧接着便把self.inplanes更新为此值作为后续block的输入维度。后面的block的stride为默认值1，同时，由于输入为self.inplanes，输出为planes*block.expansion，而self.inplanes = planes * block.expansion，因此不会出现特征图大小或者尺寸不一致的情况，不可能出现downsample操作。
-
-## 3 总结
-
-与普通的网络相比，ResNet最大的优势就是引入了Shortcut这个支路，让某一层可以直接连接到后面的层，使得后面的层可以直接学习残差。传统的卷积层或全连接层在信息传递时，或多或少会存在信息丢失、损耗等问题。ResNet 在某种程度上解决了这个问题，通过直接将输入信息绕道传到输出，保护信息的完整性，整个网络则只需要学习输入、输出差别的那一部分，简化学习目标和难度。
-
-ResNet的出现，在一定程度上解决了卷积神经网络随深度的增加，但是模型效果却变差的问题，用作者的话说，就是: “Our deep residual nets can easily enjoy accuracy gains from greatly increased depth, producing results substantially better than previous networks.”。原始的ResNet对于训练卷积神经网路做出了很大的贡献，但是同样也有着许多可以改进的地方。随着时代的发展，原版的ResNet在一次又一次的研究中得到了丰富和完善，衍生出了丰富的改进的模型，如ResNeXt。它提出了一种介于普通卷积核深度可分离卷积的这种策略：分组卷积。通过控制分组的数量（基数）来达到两种策略的平衡。分组卷积的思想是源自Inception，不同于Inception的需要人工设计每个分支，ResNeXt的每个分支的拓扑结构是相同的。最后再结合残差网络，得到的便是最终的ResNeXt。
-
-除此之外，ResNet还有其它变体如Wider ResNet，DarkNet53等。它们的改进相对较大，尤其是DarkNet53，它和ResNet已经有很大不同了，只是使用到了残差连接从而复用特征而已。总而言之，ResNet作为卷积神经网络的一个里程碑式的模型一直在各个领域被应用，因此我们学习这样一个模型架构很有必要。毫不夸张的说，ResNet值得每一个学习深度学习的学子认真研究。
diff --git "a/docs/_sources/\347\254\254\345\215\201\347\253\240/Swin-Transformer\350\247\243\350\257\273.md.txt" "b/docs/_sources/\347\254\254\345\215\201\347\253\240/Swin-Transformer\350\247\243\350\257\273.md.txt"
deleted file mode 100644
index 536d8a026..000000000
--- "a/docs/_sources/\347\254\254\345\215\201\347\253\240/Swin-Transformer\350\247\243\350\257\273.md.txt"
+++ /dev/null
@@ -1,567 +0,0 @@
-# Swin Transformer解读
-
-
-[Swin-T] Swin Transformer: Hierarchical Vision Transformer using Shifted Windows
-
-Ze Liu, Yutong Lin, Yue Cao, Han Hu, Yixuan Wei, Zheng Zhang, Stephen Lin, Baining Guo.
-
-ICCV 2021.
-[paper] [code]
-
-解读者：沈豪，复旦大学博士，Datawhale成员
-
-
-
-在论文的最后，作者也通过大量的实验证明Swin Transformer相较于以前的SOTA模型均有提高，尤其是在ADE20K数据和COCO数据集上的表现。也证明了Swin Transformer可以作为一种通用骨干网络被使用。
-
-## 模型结构
-
-
-
-整个模型采取层次化的设计，一共包含 4 个 Stage，除第一个 stage 外，每个 stage 都会先通过 **Patch Merging** 层缩小输入特征图的分辨率，进行**下采样操作**，像 CNN 一样逐层扩大感受野，以便获取到全局的信息。
-
-以论文的角度：
-
-- 在输入开始的时候，做了一个`Patch Partition`，即ViT中`Patch Embedding`操作，通过 **Patch_size** 为4的卷积层将图片切成一个个 **Patch** ，并嵌入到`Embedding`，将 **embedding_size** 转变为48（可以将 CV 中图片的**通道数**理解为NLP中token的**词嵌入长度**）。
-- 随后在第一个Stage中，通过`Linear Embedding`调整通道数为C。
-- 在每个 Stage 里（除第一个 Stage ），均由`Patch Merging`和多个`Swin Transformer Block`组成。
-- 其中`Patch Merging`模块主要在每个 Stage 一开始降低图片分辨率，进行下采样的操作。
-- 而`Swin Transformer Block`具体结构如右图所示，主要是`LayerNorm`，`Window Attention` ，`Shifted Window Attention`和`MLP`组成 。
-
-从代码的角度：
-
-在微软亚洲研究院提供的代码中，是将`Patch Merging`作为每个 Stage 最后结束的操作，输入先进行`Swin Transformer Block`操作，再下采样。而**最后一个 Stage 不需要进行下采样操作**，之间通过后续的全连接层与 **target label** 计算损失。
-
-
-
-```python
-# window_size=7
-# input_batch_image.shape=[128,3,224,224]
-class SwinTransformer(nn.Module):
- def __init__(...):
- super().__init__()
- ...
- # absolute position embedding
- if self.ape:
- self.absolute_pos_embed = nn.Parameter(torch.zeros(1, num_patches, embed_dim))
-
- self.pos_drop = nn.Dropout(p=drop_rate)
-
- # build layers
- self.layers = nn.ModuleList()
- for i_layer in range(self.num_layers):
- layer = BasicLayer(...)
- self.layers.append(layer)
-
- self.norm = norm_layer(self.num_features)
- self.avgpool = nn.AdaptiveAvgPool1d(1)
- self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else nn.Identity()
-
- def forward_features(self, x):
- x = self.patch_embed(x) # Patch Partition
- if self.ape:
- x = x + self.absolute_pos_embed
- x = self.pos_drop(x)
-
- for layer in self.layers:
- x = layer(x)
-
- x = self.norm(x) # Batch_size Windows_num Channels
- x = self.avgpool(x.transpose(1, 2)) # Batch_size Channels 1
- x = torch.flatten(x, 1)
- return x
-
- def forward(self, x):
- x = self.forward_features(x)
- x = self.head(x) # self.head => Linear(in=Channels,out=Classification_num)
- return x
-```
-
-其中有几个地方处理方法与 ViT 不同：
-
-- ViT 在输入会给 embedding 进行位置编码。而 Swin-T 这里则是作为一个**可选项**（`self.ape`），Swin-T 是在计算 Attention 的时候做了一个**相对位置编码**，我认为这是这篇论文设计最巧妙的地方。
-- ViT 会单独加上一个可学习参数，作为分类的 token。而 Swin-T 则是**直接做平均**（avgpool），输出分类，有点类似 CNN 最后的全局平均池化层。
-
-
-
-## Patch Embedding
-
-在输入进 Block 前，我们需要将图片切成一个个 patch，然后嵌入向量。
-
-具体做法是对原始图片裁成一个个 `window_size * window_size` 的窗口大小，然后进行嵌入。
-
-这里可以通过二维卷积层，**将 stride，kernel_size 设置为 window_size 大小**。设定输出通道来确定嵌入向量的大小。最后将 H,W 维度展开，并移动到第一维度。
-
-> 论文中输出通道设置为48，但是代码中为96，以下我们均以代码为准。
->
-> Batch_size=128
-
-
-
-```python
-import torch
-import torch.nn as nn
-
-class PatchEmbed(nn.Module):
- def __init__(self, img_size=224, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None):
- super().__init__()
- img_size = to_2tuple(img_size) # -> (img_size, img_size)
- patch_size = to_2tuple(patch_size) # -> (patch_size, patch_size)
- patches_resolution = [img_size[0] // patch_size[0], img_size[1] // patch_size[1]]
- self.img_size = img_size
- self.patch_size = patch_size
- self.patches_resolution = patches_resolution
- self.num_patches = patches_resolution[0] * patches_resolution[1]
-
- self.in_chans = in_chans
- self.embed_dim = embed_dim
-
- self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
- if norm_layer is not None:
- self.norm = norm_layer(embed_dim)
- else:
- self.norm = None
-
- def forward(self, x):
- # 假设采取默认参数，论文中embedding_size是96，但是代码中为48.我们以代码为准
- x = self.proj(x) # 出来的是(N, 96, 224/4, 224/4)
- x = torch.flatten(x, 2) # 把HW维展开，(N, 96, 56*56)
- x = torch.transpose(x, 1, 2) # 把通道维放到最后 (N, 56*56, 96)
- if self.norm is not None:
- x = self.norm(x)
- return x
-```
-
-## Patch Merging
-
-该模块的作用是在每个 Stage 开始前做降采样，用于缩小分辨率，调整通道数进而形成层次化的设计，同时也能节省一定运算量。
-
-> 在 CNN 中，则是在每个 Stage 开始前用`stride=2`的卷积/池化层来降低分辨率。
-
-每次降采样是两倍，因此**在行方向和列方向上，间隔 2 选取元素**。
-
-然后拼接在一起作为一整个张量，最后展开。**此时通道维度会变成原先的 4 倍**（因为 H,W 各缩小 2 倍），此时再通过一个**全连接层再调整通道维度为原来的两倍**。
-
-下面是一个示意图（输入张量 N=1, H=W=8, C=1，不包含最后的全连接层调整）
-
-
-
-
-
-```python
-class PatchMerging(nn.Module):
- def __init__(self, input_resolution, dim, norm_layer=nn.LayerNorm):
- super().__init__()
- self.input_resolution = input_resolution
- self.dim = dim
- self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
- self.norm = norm_layer(4 * dim)
-
- def forward(self, x):
- """
- x: B, H*W, C
- """
- H, W = self.input_resolution
- B, L, C = x.shape
- assert L == H * W, "input feature has wrong size"
- assert H % 2 == 0 and W % 2 == 0, f"x size ({H}*{W}) are not even."
-
- x = x.view(B, H, W, C)
-
- x0 = x[:, 0::2, 0::2, :] # B H/2 W/2 C
- x1 = x[:, 1::2, 0::2, :] # B H/2 W/2 C
- x2 = x[:, 0::2, 1::2, :] # B H/2 W/2 C
- x3 = x[:, 1::2, 1::2, :] # B H/2 W/2 C
- x = torch.cat([x0, x1, x2, x3], -1) # B H/2 W/2 4*C
- x = x.view(B, -1, 4 * C) # B H/2*W/2 4*C
-
- x = self.norm(x)
- x = self.reduction(x)
-
- return x
-```
-
-## Window Partition/Reverse
-
-`window partition`函数是用于对张量划分窗口，指定窗口大小。将原本的张量从 `N H W C`, 划分成 `num_windows*B, window_size, window_size, C`，其中 `num_windows = H*W / window_size*window_size`，即窗口的个数。而`window reverse`函数则是对应的逆过程。这两个函数会在后面的`Window Attention`用到。
-
-
-
-```python
-def window_partition(x, window_size):
- B, H, W, C = x.shape
- x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
- windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
- return windows
-
-def window_reverse(windows, window_size, H, W):
- B = int(windows.shape[0] / (H * W / window_size / window_size))
- x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
- x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
- return x
-```
-
-## Window Attention
-
-传统的 Transformer 都是**基于全局来计算注意力的**，因此计算复杂度十分高。而 Swin Transformer 则将**注意力的计算限制在每个窗口内**，进而减少了计算量。我们先简单看下公式
-
-$$
-Attention(Q,K,V)=Softmax(\frac{{QK}^T}{\sqrt d}+B)V
-$$
-主要区别是在原始计算 Attention 的公式中的 Q,K 时**加入了相对位置编码**。
-
-
-
-```python
-class WindowAttention(nn.Module):
- r""" Window based multi-head self attention (W-MSA) module with relative position bias.
- It supports both of shifted and non-shifted window.
-
- Args:
- dim (int): Number of input channels.
- window_size (tuple[int]): The height and width of the window.
- num_heads (int): Number of attention heads.
- qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
- qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set
- attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0
- proj_drop (float, optional): Dropout ratio of output. Default: 0.0
- """
-
- def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):
-
- super().__init__()
- self.dim = dim
- self.window_size = window_size # Wh, Ww
- self.num_heads = num_heads # nH
- head_dim = dim // num_heads # 每个注意力头对应的通道数
- self.scale = qk_scale or head_dim ** -0.5
-
- # define a parameter table of relative position bias
- self.relative_position_bias_table = nn.Parameter(
- torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads)) # 设置一个形状为（2*(Wh-1) * 2*(Ww-1), nH）的可学习变量，用于后续的位置编码
-
- self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
- self.attn_drop = nn.Dropout(attn_drop)
- self.proj = nn.Linear(dim, dim)
- self.proj_drop = nn.Dropout(proj_drop)
-
- trunc_normal_(self.relative_position_bias_table, std=.02)
- self.softmax = nn.Softmax(dim=-1)
- # 相关位置编码...
-```
-
-### 相关位置编码的直观理解
-
-> Q,K,V.shape=[numWindwos\*B, num_heads, window_size\*window_size, head_dim]
->
-> - window_size*window_size 即 NLP 中`token`的个数
-> - $head\_dim=\frac{Embedding\_dim}{num\_heads}$ 即 NLP 中`token`的词嵌入向量的维度
->
-> ${QK}^T$计算出来的`Attention`张量的形状为`[numWindows*B, num_heads, Q_tokens, K_tokens]`
->
-> - 其中Q_tokens=K_tokens=window_size*window_size
-
-以`window_size=2`为例：
-
-
-
-因此：${QK}^T=\left[\begin{array}{cccc}a_{11} & a_{12} & a_{13} & a_{14} \\ a_{21} & a_{22} & a_{23} & a_{24} \\ a_{31} & a_{32} & a_{33} & a_{34} \\ a_{41} & a_{42} & a_{43} & a_{44}\end{array}\right]$
-
-- **第 $i$ 行表示第 $i$ 个 token 的`query`对所有token的`key`的attention。**
-- 对于 Attention 张量来说，**以不同元素为原点，其他元素的坐标也是不同的**，
-
-
-
-所以${QK}^T的相对位置索引=\left[\begin{array}{cccc}(0,0) & (0,-1) & (-1,0) & (-1,-1) \\ (0,1) & (0,0) & (-1,1) & (-1,0) \\ (1,0) & (1,-1) & (0,0) & (0,-1) \\ (1,1) & (1,0) & (0,1) & (0,0)\end{array}\right]$
-
-由于最终我们希望使用一维的位置坐标 `x+y` 代替二维的位置坐标` (x,y)`，为了避免 (1,2) (2,1) 两个坐标转为一维时均为3，我们之后对相对位置索引进行了一些**线性变换**，使得能通过**一维**的位置坐标**唯一映射**到一个**二维**的位置坐标，详细可以通过代码部分进行理解。
-
-### 相关位置编码的代码详解
-
-首先我们利用`torch.arange`和`torch.meshgrid`函数生成对应的坐标，这里我们以`windowsize=2`为例子
-
-```python
-coords_h = torch.arange(self.window_size[0])
-coords_w = torch.arange(self.window_size[1])
-coords = torch.meshgrid([coords_h, coords_w]) # -> 2*(wh, ww)
-"""
- (tensor([[0, 0],
- [1, 1]]),
- tensor([[0, 1],
- [0, 1]]))
-"""
-```
-
-然后堆叠起来，展开为一个二维向量
-
-```python
-coords = torch.stack(coords) # 2, Wh, Ww
-coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww
-"""
-tensor([[0, 0, 1, 1],
- [0, 1, 0, 1]])
-"""
-```
-
-利用广播机制，分别在第一维，第二维，插入一个维度，进行广播相减，得到 `2, wh*ww, wh*ww`的张量
-
-```python
-relative_coords_first = coords_flatten[:, :, None] # 2, wh*ww, 1
-relative_coords_second = coords_flatten[:, None, :] # 2, 1, wh*ww
-relative_coords = relative_coords_first - relative_coords_second # 最终得到 2, wh*ww, wh*ww 形状的张量
-```
-
-
-
-因为采取的是相减，所以得到的索引是从负数开始的，**我们加上偏移量，让其从 0 开始**。
-
-```python
-relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2
-relative_coords[:, :, 0] += self.window_size[0] - 1
-relative_coords[:, :, 1] += self.window_size[1] - 1
-```
-
-后续我们需要将其展开成一维偏移量。而对于 (1，2）和（2，1）这两个坐标。在二维上是不同的，**但是通过将 x,y 坐标相加转换为一维偏移的时候，他的偏移量是相等的**。
-
-
-
-所以最后我们对其中做了个乘法操作，以进行区分
-
-```python
-relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
-```
-
-
-
-然后再最后一维上进行求和，展开成一个一维坐标，并注册为一个不参与网络学习的变量
-
-```python
-relative_position_index = relative_coords.sum(-1) # Wh*Ww, Wh*Ww
-self.register_buffer("relative_position_index", relative_position_index)
-```
-
-之前计算的是相对位置索引，并不是相对位置偏置参数。真正使用到的可训练参数$\hat B$是保存在`relative position bias table`表里的，这个表的长度是等于 **(2M−1) × (2M−1)** (在二维位置坐标中线性变化乘以2M-1导致)的。那么上述公式中的相对位置偏执参数B是根据上面的相对位置索引表根据查`relative position bias table`表得到的。
-
-
-
-接着我们看前向代码
-
-```python
-def forward(self, x, mask=None):
- """
- Args:
- x: input features with shape of (num_windows*B, N, C)
- mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None
- """
- B_, N, C = x.shape
-
- qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
- q, k, v = qkv[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple)
-
- q = q * self.scale
- attn = (q @ k.transpose(-2, -1))
-
- relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1) # Wh*Ww,Wh*Ww,nH
- relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous() # nH, Wh*Ww, Wh*Ww
- attn = attn + relative_position_bias.unsqueeze(0) # (1, num_heads, windowsize, windowsize)
-
- if mask is not None: # 下文会分析到
- ...
- else:
- attn = self.softmax(attn)
-
- attn = self.attn_drop(attn)
-
- x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
- x = self.proj(x)
- x = self.proj_drop(x)
- return x
-```
-
-- 首先输入张量形状为 `[numWindows*B, window_size * window_size, C]`
-- 然后经过`self.qkv`这个全连接层后，进行 reshape，调整轴的顺序，得到形状为`[3, numWindows*B, num_heads, window_size*window_size, c//num_heads]`，并分配给`q,k,v`。
-- 根据公式，我们对`q`乘以一个`scale`缩放系数，然后与`k`（为了满足矩阵乘要求，需要将最后两个维度调换）进行相乘。得到形状为`[numWindows*B, num_heads, window_size*window_size, window_size*window_size]`的`attn`张量
-- 之前我们针对位置编码设置了个形状为`(2*window_size-1*2*window_size-1, numHeads)`的可学习变量。我们用计算得到的相对编码位置索引`self.relative_position_index.vew(-1)`选取，得到形状为`(window_size*window_size, window_size*window_size, numHeads)`的编码，再permute(2,0,1)后加到`attn`张量上
-- 暂不考虑 mask 的情况，剩下就是跟 transformer 一样的 softmax，dropout，与`V`矩阵乘，再经过一层全连接层和 dropout
-
-## Shifted Window Attention
-
-前面的 Window Attention 是在每个窗口下计算注意力的，为了更好的和其他 window 进行信息交互，Swin Transformer 还引入了 shifted window 操作。
-
-
-
-左边是没有重叠的 Window Attention，而右边则是将窗口进行移位的 Shift Window Attention。可以看到移位后的窗口包含了原本相邻窗口的元素。但这也引入了一个新问题，即 **window 的个数翻倍了**，由原本四个窗口变成了 9 个窗口。在实际代码里，我们是**通过对特征图移位，并给 Attention 设置 mask 来间接实现的**。能在**保持原有的 window 个数下**，最后的计算结果等价。
-
-
-
-> 如果需要`reverse cyclic shift`的话只需把参数`shifts`设置为对应的正数值。
-
-### Attention Mask
-
-这是 Swin Transformer 的精华，通过设置合理的 mask，让`Shifted Window Attention`在与`Window Attention`相同的窗口个数下，达到等价的计算结果。
-
-首先我们对 Shift Window 后的每个窗口都给上 index，并且做一个`roll`操作（window_size=2, shift_size=1）
-
-
-
-
-
-我们希望在计算 Attention 的时候，**让具有相同 index QK 进行计算，而忽略不同 index QK 计算结果**。最后正确的结果如下图所示
-
-
-
-而要想在原始四个窗口下得到正确的结果，我们就必须给 Attention 的结果加入一个 mask（如上图最右边所示）相关代码如下：
-
-```python
-if self.shift_size > 0:
- # calculate attention mask for SW-MSA
- H, W = self.input_resolution
- img_mask = torch.zeros((1, H, W, 1)) # 1 H W 1
- h_slices = (slice(0, -self.window_size),
- slice(-self.window_size, -self.shift_size),
- slice(-self.shift_size, None))
- w_slices = (slice(0, -self.window_size),
- slice(-self.window_size, -self.shift_size),
- slice(-self.shift_size, None))
- cnt = 0
- for h in h_slices:
- for w in w_slices:
- img_mask[:, h, w, :] = cnt
- cnt += 1
-
- mask_windows = window_partition(img_mask, self.window_size) # nW, window_size, window_size, 1
- mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
- attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
- attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
-else:
- attn_mask = None
-```
-
-以上图的设置，我们用这段代码会得到这样的一个 mask
-
-```
-tensor([[[[[ 0., 0., 0., 0.],
- [ 0., 0., 0., 0.],
- [ 0., 0., 0., 0.],
- [ 0., 0., 0., 0.]]],
-
-
- [[[ 0., -100., 0., -100.],
- [-100., 0., -100., 0.],
- [ 0., -100., 0., -100.],
- [-100., 0., -100., 0.]]],
-
-
- [[[ 0., 0., -100., -100.],
- [ 0., 0., -100., -100.],
- [-100., -100., 0., 0.],
- [-100., -100., 0., 0.]]],
-
-
- [[[ 0., -100., -100., -100.],
- [-100., 0., -100., -100.],
- [-100., -100., 0., -100.],
- [-100., -100., -100., 0.]]]]])
-```
-
-在之前的 window attention 模块的前向代码里，包含这么一段
-
-```python
-if mask is not None:
- nW = mask.shape[0] # 一张图被分为多少个windows eg:[4,49,49]
- attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0) # torch.Size([128, 4, 12, 49, 49]) torch.Size([1, 4, 1, 49, 49])
- attn = attn.view(-1, self.num_heads, N, N)
- attn = self.softmax(attn)
-else:
- attn = self.softmax(attn)
-```
-
-将 mask 加到 attention 的计算结果，并进行 softmax。mask 的值设置为 - 100，softmax 后就会忽略掉对应的值。关于Mask，我们发现在官方代码库中的issue38也进行了讨论:-->[The Question about the mask of window attention #38](https://github.com/microsoft/Swin-Transformer/issues/38#issuecomment-823806591)
-
-## W-MSA和MSA的复杂度对比
-
-在原论文中，作者提出的基于**滑动窗口操作**的 `W-MSA` 能大幅度减少计算量。那么两者的计算量和算法复杂度大概是如何的呢，论文中给出了一下两个公式进行对比。
-$$
-\begin{aligned}
-&\Omega(M S A)=4 h w C^{2}+2(h w)^{2} C \\
-&\Omega(W-M S A)=4 h w C^{2}+2 M^{2} h w C
-\end{aligned}
-$$
-
-- **h**：feature map的高度
-- **w**：feature map的宽度
-- **C**：feature map的通道数（也可以称为embedding size的大小）
-- **M**：window_size的大小
-
-### MSA模块的计算量
-
-首先对于`feature map`中每一个`token`（一共有 $hw$ 个token，通道数为C），记作$X^{h w \times C}$，需要通过三次线性变换 $W_q,W_k,W_v$ ，产生对应的`q,k,v`向量，记作 $Q^{h w \times C},K^{h w \times C},V^{h w \times C}$ （通道数为C）。
-$$
-X^{h w \times C} \cdot W_{q}^{C \times C}=Q^{h w \times C} \\
-X^{h w \times C} \cdot W_{k}^{C \times C}=K^{h w \times C} \\
-X^{h w \times C} \cdot W_{v}^{C \times C}=V^{h w \times C} \\
-$$
-根据矩阵运算的计算量公式可以得到运算量为 $3hwC \times C$ ，即为 $3hwC^2$ 。
-$$
-Q^{h w \times C} \cdot K^T=A^{h w \times hw} \\
-\Lambda^{h w \times h w}=Softmax(\frac{A^{h w \times hw}}{\sqrt(d)}+B) \\
-\Lambda^{h w \times h w} \cdot V^{h w \times C}=Y^{h w \times C}
-$$
-忽略除以$\sqrt d$ 以及softmax的计算量，根据根据矩阵运算的计算量公式可得 $hwC \times hw + hw^2 \times C$ ，即为 $2(hw^2)C$ 。
-$$
-Y^{h w \times C} \cdot W_O^{C \times C}=O^{h w \times C}
-$$
-最终再通过一个Linear层输出，计算量为 $hwC^2$ 。因此整体的计算量为 $4 h w C^{2}+2(h w)^{2} C$ 。
-
-### W-MSA模块的计算量
-
-对于W-MSA模块，首先会将`feature map`根据`window_size`分成 $\frac{hw}{M^2}$ 的窗口，每个窗口的宽高均为$M$，然后在每个窗口进行MSA的运算。因此，可以利用上面MSA的计算量公式，将 $h=M，w=M$ 带入，可以得到一个窗口的计算量为 $4 M^2 C^{2}+2M^{4} C$ 。
-
-又因为有 $\frac{hw}{M^2}$ 个窗口，则：
-$$
-\frac{hw}{M^2} \times\left(4M^2 C^2+2M^{4} C\right)=4 h w C^{2}+2 M^{2} h w C
-$$
-假设`feature map`的$h=w=112，M=7，C=128$，采用W-MSA模块会比MSA模块节省约40124743680 FLOPs：
-$$
-2(h w)^{2} C-2 M^{2} h w C=2 \times 112^{4} \times 128-2 \times 7^{2} \times 112^{2} \times 128=40124743680
-$$
-
-## 整体流程图
-
-
-[Transformer] Attention Is All You Need
-
-Ashish Vaswani，Noam Shazeer，Niki Parmar，Jakob Uszkoreit，Llion Jones，Aidan N. Gomez，Łukasz Kaiser，Illia Polosukhin.
-
-NIPS 2017.
-[paper] [tensorflow] [pytorch]
-
-解读者：邹雨衡，对外经济贸易大学本科生，牛志康，西安电子科技大学本科生
-
-
-[ViT] An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale.
-
-Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, Neil Houlsby.
-
-ICLR 2021.
-[paper] [code]
-
-解读者：牛志康，西安电子科技大学本科生，Datawhale成员；小饭同学，香港城市大学研究生
-
-
-
-
-其具体流程如下：
-1. **切分和映射**：对一张标准图像，我们首先将图片切分成一个一个小的 `patch`，然后将它们的维度拉平 `Flatten` 为一维的向量，最后我们将这些向量通过线性映射 `Linear Project` $\mathbf{E}$ 到维度为 $D$ 的空间。
-2. **分类表征和位置信息**：**分类表征**：为了实现图像分类，我们在得到的向量中需要加入一个 `classs token` $\mathbf{x}_\text{class}$ 作为分类表征（如上图中标注 $*$的粉色向量所示）。**位置信息**：图像和文本一样也需要注意顺序问题，因此作者通过 `Position Embedding` $\mathbf{E}_{pos}$ 加入位置编码信息（如上图中标注 $0-9$ 的紫色向量所示）。
-3. **Transformer Encoder**：然后我们将经过上面操作的 `token` 送入 `Transformer Encoder`。这里的 `Transformer Encoder` 和 `Transformer (Attention is All You Need)` 文章中实现基本一致，主要是通过多头注意力机制，对 `patch` 之间进行全局的信息提取。
-4. **输出与分类**：对于分类任务，我们只需要获得 `class token` 经过 `Transformer Encoder` 得到的输出，加一个 `MLP Head` 进行分类学习。
-
-我们论文代码的讲解也将按照上面的流程，对重要模块进行讲解，我们所展示的ViT代码示例来源于[rwightman/timm](https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/vision_transformer.py)并进行了部分简化，在此感谢每一位开源贡献者所作出的贡献。
-
-## 切分和映射 Patch Embedding + Linear Projection
-
-对一张标准图像 $\mathbf{x}$，其分辨率为 $H \times W \times C$。为了方便讨论，我们取 ViT 的标准输入 $H \times W \times C = 224 \times 224 \times 3$ 进行一些具体维度的讲解。通过切分操作，我们将整个图片分成多个 `patch` $\mathbf{x}_p$，其大小为 $$P \times P \times C = 16 \times 16 \times 3 = 768。$$ 这样，一共可以得到 `Patch` 的数量为 $$N={(H \times W)}/{(P \times P)} = {(224 \times 224)}/{(16 \times 16)} = {(224 / 16)}\times {(224 / 16)} = 14 \times 14 = 196。$$ 所以，我们将一张 $224 \times 224 \times 3$ 的标准图片， 通过转换得到了 $196$ 个 `patch`，每个 `patch` 的维度是 $768$。
-
-对得到的 `patch` 通过 $\mathbf{E} \in {\mathbb{R}^{768 \times D}}$ 进行线性映射到维度 $D$，我们将映射后的 `patch` 叫做 `token`，以便于和原本 Transformer 的术语进行统一（代码中默认的 $D$ 仍然为 $768$。我们认为，为了不损失信息，这里 $D$ 满足大于等于 $768$ 即可）。对应文中公式，上述操作可以表示为：
-$$
-\begin{align}
-[\mathbf{x}_p^1\mathbf{E}; \mathbf{x}_p^2\mathbf{E}; \cdots; \mathbf{x}_p^N\mathbf{E}], \quad \mathbf{E}\in\mathbb{R}^{(P^2\cdot C)\times D}。
-\end{align}
-$$
-
-以上是按照原论文对**切分和映射**的讲解，在实际的代码实现过程中，切分和映射实际上是通过一个二维卷积 `nn.Conv2d()` 一步完成的。为了实现一步操作，作者将卷积核的大小 `kernal_size` 直接设置为了 `patch_size`，即 $P=16$。然后，将卷积核的步长 `stride` 也设置为了同样的 `patch_size`，这样就实现了不重复的切割图片。而卷积的特征输入和输出维度，分别设为了 $C=3$ 和 $D=768$，对应下方代码的 `in_c` 和 `embed_dim`。
-```python
-self.proj = nn.Conv2d(in_c, embed_dim, kernel_size=patch_size, stride=patch_size)
-```
-一张 $1 \times 3 \times 224 \times 224$ 的图像（其中 $1$ 是 `batch_size` 的维度），经过上述卷积操作得到 $1 \times 768 \times 14 \times 14$ 的张量。（代码中将 $14 \times 14 = 196$ 当作 `grid` 的个数，即 `grid_size=(14, 14)`）然后，对其进行拉平 `flatten(2)` 得到 $1 \times 768 \times 196$ 的张量。因为 Transformer 需要将序列维度调整到前面，我们再通过 `transpose(1, 2)` 调整特征和序列维度，最终得到的张量大小为 $1 \times 196 \times 768$。切分、映射、拉平和维度调整统统经过下面一步操作得到：
-```python
-x = self.proj(x).flatten(2).transpose(1, 2)
-```
-
-在代码中，这些操作全部被写在名为 `PatchEmbed` 的模块中，其具体的实现如下所示：
-
-```python
-class PatchEmbed(nn.Module):
- """
- Image --> Patch Embedding --> Linear Proj --> Pos Embedding
- Image size -> [224,224,3]
- Patch size -> 16*16
- Patch num -> (224^2)/(16^2)=196
- Patch dim -> 16*16*3 =768
- Patch Embedding: [224,224,3] -> [196,768]
- Linear Proj: [196,768] -> [196,768]
- Positional Embedding: [197,768] -> [196,768]
- """
- def __init__(self, img_size=224, patch_size=16, in_c=3, embed_dim=768, norm_layer=None):
- """
- Args:
- img_size: 默认参数224
- patch_size: 默认参数是16
- in_c: 输入的通道数
- embed_dim: 16*16*3 = 768
- norm_layer: 是否使用norm层，默认为否
- """
- super().__init__()
- img_size = (img_size, img_size) # -> img_size = (224,224)
- patch_size = (patch_size, patch_size) # -> patch_size = (16,16)
- self.img_size = img_size # -> (224,224)
- self.patch_size = patch_size # -> (16,16)
- self.grid_size = (img_size[0] // patch_size[0], img_size[1] // patch_size[1]) # -> grid_size = (14,14)
- self.num_patches = self.grid_size[0] * self.grid_size[1] # -> num_patches = 196
- # Patch+linear proj的这个操作 [224,224,3] --> [14,14,768]
- self.proj = nn.Conv2d(in_c, embed_dim, kernel_size=patch_size, stride=patch_size)
- # 判断是否有norm_layer层，要是没有不改变输入
- self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()
-
- def forward(self, x):
- # 计算各个维度的大小
- B, C, H, W = x.shape
- assert H == self.img_size[0] and W == self.img_size[1], \
- f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})."
-
- # flatten: [B, C, H, W] -> [B, C, HW], flatten(2)代表的是从2位置开始展开
- # eg: [1,3,224,224] --> [1,768,14,14] -flatten->[1,768,196]
- # transpose: [B, C, HW] -> [B, HW, C]
- # eg: [1,768,196] -transpose-> [1,196,768]
- x = self.proj(x).flatten(2).transpose(1, 2)
- x = self.norm(x)
- return x
-```
-**在默认情况下，这一步是不进行 ``layer_norm`` 操作的，即它被设置为 ``nn.Identity()``。对于 ``layer_norm``，我们会在下面进行详细的讲解。
-
-## 分类表征和位置信息 Class Token + Postional Embedding
-如下图所示，左侧灰色部分为加入分类表征，中间紫色部分为加入位置信息。
-
-
-**分类表征：Class Token**
-为了实现图像分类，我们在切分和映射后的向量 $[\mathbf{x}_p^1\mathbf{E}; \mathbf{x}_p^2\mathbf{E}; \cdots; \mathbf{x}_p^N\mathbf{E}]$ 中加入一个 `class token` $\mathbf{x}_\text{class} \in \mathbb{R}^{D}$ 作为分类表征（如上图中最左侧深灰色框所示）。将这个表征放置在序列的第一个位置上，我们就得到一个维度为 $(196+1) \times 768$ 的新张量：
-$$
-\begin{align}
-[\mathbf{x}_{\text{class}}; \mathbf{x}_p^1\mathbf{E}; \mathbf{x}_p^2\mathbf{E}; \cdots; \mathbf{x}_p^N\mathbf{E}]
-\end{align}
-$$
-对于具体的代码实现，我们通过 `nn.Parameter(torch.zeros(1, 1, 768))` 实例化一个可学习的 `cls_token`，然后将这个 `cls_token` 按照 `batch_size = x.shape[0]` 进行复制，最后将其和之前经过切分和映射的 `x` 并在一起 ` torch.cat((cls_token, x), dim=1)`。其完整代码，如下所示：
-```python
-cls_token = nn.Parameter(torch.zeros(1, 1, 768)) # -> cls token
-nn.init.trunc_normal_(self.cls_token, std=0.02) # 初始化
-cls_token = cls_token.expand(x.shape[0], -1, -1) # (1,1,768) -> (128,1,768)
-x = torch.cat((cls_token, x), dim=1) # [128, 197, 768]
-```
-
-**其实也可以不加入这个 `cls token`，我们可以对输出 `token` 做 `GAP(Global Average Pooling)`，然后对 `GAP` 的结果进行分类。
-
-**位置信息：Postional Embedding**
-图像和文本一样也需要注意顺序问题，因此作者通过 `Position Embedding` $\mathbf{E}_{\text{pos}}\in\mathbb{R}^{(N + 1)\times D}$ 加入位置编码信息。这个 `Position Embedding` 和上面得到的分类表征张量，直接相加：
-$$
-\begin{align}
-\mathbf{z}_0 &= [\mathbf{x}_{\text{class}}; \mathbf{x}_p^1\mathbf{E}; \mathbf{x}_p^2\mathbf{E}; \cdots; \mathbf{x}_p^N\mathbf{E};] + \mathbf{E}_{\text{pos}}, & \mathbf{E}&\in\mathbb{R}^{(P^2\cdot C)\times D}, \mathbf{E}_{\text{pos}}\in\mathbb{R}^{(N + 1)\times D}
-\end{align}
-$$
-
-与 Transformer 使用余弦位置编码不同的是，ViT 通过`nn.Parameter()`实现了一个可以学习的位置编码。
-```python
-num_patches = 196
-pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, 768))
-x = x + pos_embed
-```
-**这里 `pos_embed` 在 `batch_size` 的维度进行了 boardcast，所以所有的样本都是同样的 `pos_embed`。
-
-
-## Transformer Encoder
-下一步，我们只需要将序列 $\mathbf{z}_0$ 输入 Transformer Encoder 即可。如下图所示，每个 Transformer Encoder 由 Multi-head Attention、MLP、Norm (Layer Norm,LN) 并外加 shortcut 连接实现。
-$$
-\begin{align}
-\mathbf{z}'_l &= \text{MSA}(\text{LN}(\mathbf{z}_{l-1})) + \mathbf{z}_{l-1}, & l &=1\dots L, \\
-\mathbf{z}_l &= \text{MLP}(\text{LN}(\mathbf{z}'_l)) + \mathbf{z}'_l, & l &=1\dots L, \\
-\mathbf{y} &= \text{LN}(\mathbf{z}_L^0)
-\end{align}
-$$
-
-
-·
-·
-·
-·
-·
-·
-
-
- 
-
-
- 图为 RangeKing@GitHub 提供，非常感谢！
-
-| - Backbones - | -- Necks - | -- Loss - | -- Common - | -
-
|
-
-
|
-
-
|
-
-
|
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-左：VGG-19模型，作为参考。 中：一个有34个参数层的普通网络。 右：一个有34个参数层的残差网络（即resnet34）
-
-在上图最右侧的路径中，我们可以很明显的看到shortcut connection加入了网络之中，同时，图中也很明显的可以看到，实线部分就是进行了单纯的F(x)+x操作，而虚线部分，第一个卷积层的stride是2（那个/2的意思就是stride是2）；同时注意到深度也发生了变换，channel数目增加一倍（扩大两倍），这样F(x)的分辨率比x小一半，厚度比x大一倍。在这样的shortcut connection中，就需要补充线性映射来增加维度。在ResNet中，作者使用了1 x 1的卷积核来达到这个目的。
-
-另外，论文中又提到说：“……where both designs have similar time complexity.” 既然BasicBlock和Bottleneck二者的时间复杂度类似，那么为什么还要额外设计一个Bottleneck结构呢？
-
-根据前面的叙述我们知道，BasicBlock结构比传统的卷积结构多了一个shortcut支路，用于传递低层的信息，使得网络能够训练地很深。而BottleNeck先通过一个1x1的卷积减少通道数，使得中间卷积的通道数减少为1/4；中间的普通卷积做完卷积后输出通道数等于输入通道数；第三个卷积用于恢复通道数，使得BottleNeck的输出通道数等于BottleNeck的输入通道数。**换句话说，这两个1x1卷积有效地减少了卷积的参数个数和计算量，同时减少了中间特征图的通道数，使单个Block消耗的显存更少，在较深的网络中BottleNeck会在参数上更加节约，这样可以有利于构建层数更多的网络，同时还能保持性能的提升。**所以resnet50, resnet101和resnet152使用了另外设计的BottleNeck结构。
-
-#### 2.2.2 BasicBlock
-
-BasicBlock模块用来构建resnet18和resnet34
-
-```python
-class BasicBlock(nn.Module):
- expansion: int = 1
-
- def __init__(
- self,
- inplanes: int,
- planes: int,
- stride: int = 1,
- downsample: Optional[nn.Module] = None,
- groups: int = 1,
- base_width: int = 64,
- dilation: int = 1,
- norm_layer: Optional[Callable[..., nn.Module]] = None,
- ) -> None:
- super().__init__()
- if norm_layer is None:
- norm_layer = nn.BatchNorm2d
- if groups != 1 or base_width != 64:
- raise ValueError("BasicBlock only supports groups=1 and base_width=64")
- if dilation > 1:
- raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
- # Both self.conv1 and self.downsample layers downsample the input when stride != 1
- self.conv1 = conv3x3(inplanes, planes, stride)
- self.bn1 = norm_layer(planes)
- self.relu = nn.ReLU(inplace=True)
- self.conv2 = conv3x3(planes, planes)
- self.bn2 = norm_layer(planes)
- self.downsample = downsample
- self.stride = stride
-
- def forward(self, x: Tensor) -> Tensor:
- identity = x # x 给自己先备份一份
-
- out = self.conv1(x) # 对x做卷积
- out = self.bn1(out) # 对x归一化
- out = self.relu(out) # 对x用激活函数
-
- out = self.conv2(out) # 对x做卷积
- out = self.bn2(out) # 归一化
-
- if self.downsample is not None:
- identity = self.downsample(x)
-
- out += identity # 进行downsample
- out = self.relu(out)
-
- return out
-```
-
-#### 2.2.3 BottleNeck
-
-BottleNeck模块用来构建resnet50，resnet101和resnet152
-
-```python
-class Bottleneck(nn.Module):
- # Bottleneck in torchvision places the stride for downsampling at 3x3 convolution(self.conv2)
- # while original implementation places the stride at the first 1x1 convolution(self.conv1)
- # according to "Deep residual learning for image recognition"https://arxiv.org/abs/1512.03385.
- # This variant is also known as ResNet V1.5 and improves accuracy according to
- # https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch.
-
- expansion: int = 4 # 对输出通道进行倍增
-
- def __init__(
- self,
- inplanes: int,
- planes: int,
- stride: int = 1,
- downsample: Optional[nn.Module] = None,
- groups: int = 1,
- base_width: int = 64,
- dilation: int = 1,
- norm_layer: Optional[Callable[..., nn.Module]] = None,
- ) -> None:
- super().__init__()
- if norm_layer is None:
- norm_layer = nn.BatchNorm2d
- width = int(planes * (base_width / 64.0)) * groups
- # Both self.conv2 and self.downsample layers downsample the input when stride != 1
- self.conv1 = conv1x1(inplanes, width)
- self.bn1 = norm_layer(width)
- self.conv2 = conv3x3(width, width, stride, groups, dilation)
- self.bn2 = norm_layer(width)
- self.conv3 = conv1x1(width, planes * self.expansion)
- self.bn3 = norm_layer(planes * self.expansion)
- self.relu = nn.ReLU(inplace=True)
- self.downsample = downsample
- self.stride = stride
-
- # Bottleneckd forward函数和BasicBlock类似，不再额外注释
- def forward(self, x: Tensor) -> Tensor:
- identity = x
-
- out = self.conv1(x)
- out = self.bn1(out)
- out = self.relu(out)
-
- out = self.conv2(out)
- out = self.bn2(out)
- out = self.relu(out)
-
- out = self.conv3(out)
- out = self.bn3(out)
-
- if self.downsample is not None:
- identity = self.downsample(x)
-
- out += identity
- out = self.relu(out)
-
- return out
-```
-
-我们在这里再对代码中**expansion**的作用做一个说明，我们可以重新回顾一下下面这张图。
-
-
-
-expansion简单来说就是对输出通道的倍乘。在BasicBlock和BottleNeck中，“\_\_init\_\_”函数中有三个比较关键的参数：inplanes,planes和stride，这三者分别表示输入的通道数，输出的通道数和步幅。在两个模块中，\_\_init__传入的planes都是64,128,156,512，但我们观察上面的表格，会发现对于ResNet-50，ResNet-101和ResNet-152而言，它们需要的输出通道应该为256,512,1024,2048才对。因此在这里设置expansion=4，对应上面BottleNeck代码中的30行和31行，将每一个planes都乘上这个expansion，就得到了需要的通道数；而对于ResNet-18和ResNet-34而言，输入通道和输出通道的维度上没有发生变化，因此expansion也设置为1。
-
-### 2.3 网络整体结构
-
-在定义好最基本的Bottlenneck和BasicBlock后，我们就可以构建ResNet网络了。
-
-```python
-class ResNet(nn.Module):
- def __init__(
- self,
- block: Type[Union[BasicBlock, Bottleneck]], # 选择基本模块
- layers: List[int], # 每一层block的数目构成 -> [3,4,6,3]
- num_classes: int = 1000, # 分类数目
- zero_init_residual: bool = False, # 初始化
-
- #######其他卷积构成，与本文ResNet无关######
- groups: int = 1,
- width_per_group: int = 64,
- replace_stride_with_dilation: Optional[List[bool]] = None,
- #########################################
-
- norm_layer: Optional[Callable[..., nn.Module]] = None, # norm层
- ) -> None:
- super().__init__()
- _log_api_usage_once(self)
- if norm_layer is None:
- norm_layer = nn.BatchNorm2d
- self._norm_layer = norm_layer
-
- self.inplanes = 64 # 输入通道
-
- #######其他卷积构成，与本文ResNet无关######
- self.dilation = 1 # 空洞卷积
- if replace_stride_with_dilation is None:
- # each element in the tuple indicates if we should replace
- # the 2x2 stride with a dilated convolution instead
- replace_stride_with_dilation = [False, False, False]
- if len(replace_stride_with_dilation) != 3:
- raise ValueError(
- "replace_stride_with_dilation should be None "
- f"or a 3-element tuple, got {replace_stride_with_dilation}"
- )
- self.groups = groups
- self.base_width = width_per_group
- #########################################
-
- self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias=False)
- self.bn1 = norm_layer(self.inplanes)
- self.relu = nn.ReLU(inplace=True)
- self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
- # 通过_make_layer带到层次化设计的效果
- self.layer1 = self._make_layer(block, 64, layers[0]) # 对应着conv2_x
- self.layer2 = self._make_layer(block, 128, layers[1], stride=2, dilate=replace_stride_with_dilation[0]) # 对应着conv3_x
- self.layer3 = self._make_layer(block, 256, layers[2], stride=2, dilate=replace_stride_with_dilation[1]) # 对应着conv4_x
- self.layer4 = self._make_layer(block, 512, layers[3], stride=2, dilate=replace_stride_with_dilation[2]) # 对应着conv5_x
- # 分类头
- self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
- self.fc = nn.Linear(512 * block.expansion, num_classes)
-
- # 模型初始化
- for m in self.modules():
- if isinstance(m, nn.Conv2d):
- nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
- elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
- nn.init.constant_(m.weight, 1)
- nn.init.constant_(m.bias, 0)
-
- # Zero-initialize the last BN in each residual branch,
- # so that the residual branch starts with zeros, and each residual block behaves like an identity.
- # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
- if zero_init_residual:
- for m in self.modules():
- if isinstance(m, Bottleneck) and m.bn3.weight is not None:
- nn.init.constant_(m.bn3.weight, 0) # type: ignore[arg-type]
- elif isinstance(m, BasicBlock) and m.bn2.weight is not None:
- nn.init.constant_(m.bn2.weight, 0) # type: ignore[arg-type]
- # 层次化设计
- def _make_layer(
- self,
- block: Type[Union[BasicBlock, Bottleneck]], # 基本构成模块选择
- planes: int, # 输入的通道
- blocks: int, # 模块数目
- stride: int = 1, # 步长
- dilate: bool = False, # 空洞卷积，与本文无关
- ) -> nn.Sequential:
- norm_layer = self._norm_layer
- downsample = None # 是否采用下采样
- ####################无关#####################
- previous_dilation = self.dilation
- if dilate:
- self.dilation *= stride
- stride = 1
- #############################################
- if stride != 1 or self.inplanes != planes * block.expansion:
- downsample = nn.Sequential(
- conv1x1(self.inplanes, planes * block.expansion, stride),
- norm_layer(planes * block.expansion),
- )
-
- # 使用layers存储每个layer
- layers = []
- layers.append(
- block(
- self.inplanes, planes, stride, downsample, self.groups, self.base_width, previous_dilation, norm_layer
- )
- )
- self.inplanes = planes * block.expansion
- for _ in range(1, blocks):
- layers.append(
- block(
- self.inplanes,
- planes,
- groups=self.groups,
- base_width=self.base_width,
- dilation=self.dilation,
- norm_layer=norm_layer,
- )
- )
- # 将layers通过nn.Sequential转化为网络
- return nn.Sequential(*layers)
-
- def _forward_impl(self, x: Tensor) -> Tensor:
- # See note [TorchScript super()]
- x = self.conv1(x) # conv1 x shape [1 64 112 112]
- x = self.bn1(x) # 归一化处理
- x = self.relu(x) # 激活函数
- x = self.maxpool(x) # conv2_x的3x3 maxpool x shape [1 64 56 56]
-
- x = self.layer1(x) # layer 1
- x = self.layer2(x) # layer 2
- x = self.layer3(x) # layer 3
- x = self.layer4(x) # layer 4
-
- x = self.avgpool(x) # 自适应池化
- x = torch.flatten(x, 1)
- x = self.fc(x) # 分类
-
- return x
-
- def forward(self, x: Tensor) -> Tensor:
- return self._forward_impl(x)
-```
-
-观察上述代码，我们不难看到，首先是一个7 x 7的卷积作用在输入的3维图片上，并输入一个64维的特征图（即self.inplanes的初始值），通过BatchNorm层，ReLU层，MaxPool层；然后经过_make_layer()函数构建的4层layer，最后经过一个AveragePooling层，再经过一个fc层得到分类输出。在网络搭建起来后，还对模型的参数(Conv2d、BatchNorm2d、last BN)进行了初始化。
-
-而对于\_make_layer函数，一个_make_layer()构建一个layer层，每一个layer层是上述两种基本模块的堆叠。输入参数中block代表该layer堆叠模块的类型，可选BasicBlock或者BottleNeck；blocks代表该layer中堆叠的block的数目；planes与该layer最终输出的维度数有关，注意最终输出的维度数为planes * block.expansion。除此之外， _make\_layer()是用来生成残差块的，这就牵扯到它的第四个参数：stride，即卷积步幅。该函数中首先定义了如果stride不等于1或者维度不匹配（即输入通道不满足对应关系）的时候的downsample，然后对其进行一次BN操作。接着对inplanes和planes不一致的情况进行了一次downsample ，即将带downsample的block添加至layers。这样保证了x和out的维度一致，接下来通过一个循环添加了指定个数的Block，由于x已经维度一致了，这样添加的其他的Block就可以不用降维了，所以循环添加不含Downsample的Block。正如下面代码所示
-
-```python
-if stride != 1 or self.inplanes != planes * block.expansion:
- downsample = nn.Sequential(
- conv1x1(self.inplanes, planes * block.expansion, stride),
- norm_layer(planes * block.expansion),
- )
-```
-
-当一个layer包含多个block时，是通过向layers列表中依次加入每个block，来实现block的堆叠的。第一个block需要特殊处理，该block依据传入的self.inplanes, planes以及stride判断，可能含有downsample支路；这个block的输出维度是planes\*block.expansion。紧接着便把self.inplanes更新为此值作为后续block的输入维度。后面的block的stride为默认值1，同时，由于输入为self.inplanes，输出为planes*block.expansion，而self.inplanes = planes * block.expansion，因此不会出现特征图大小或者尺寸不一致的情况，不可能出现downsample操作。
-
-## 3 总结
-
-与普通的网络相比，ResNet最大的优势就是引入了Shortcut这个支路，让某一层可以直接连接到后面的层，使得后面的层可以直接学习残差。传统的卷积层或全连接层在信息传递时，或多或少会存在信息丢失、损耗等问题。ResNet 在某种程度上解决了这个问题，通过直接将输入信息绕道传到输出，保护信息的完整性，整个网络则只需要学习输入、输出差别的那一部分，简化学习目标和难度。
-
-ResNet的出现，在一定程度上解决了卷积神经网络随深度的增加，但是模型效果却变差的问题，用作者的话说，就是: “Our deep residual nets can easily enjoy accuracy gains from greatly increased depth, producing results substantially better than previous networks.”。原始的ResNet对于训练卷积神经网路做出了很大的贡献，但是同样也有着许多可以改进的地方。随着时代的发展，原版的ResNet在一次又一次的研究中得到了丰富和完善，衍生出了丰富的改进的模型，如ResNeXt。它提出了一种介于普通卷积核深度可分离卷积的这种策略：分组卷积。通过控制分组的数量（基数）来达到两种策略的平衡。分组卷积的思想是源自Inception，不同于Inception的需要人工设计每个分支，ResNeXt的每个分支的拓扑结构是相同的。最后再结合残差网络，得到的便是最终的ResNeXt。
-
-除此之外，ResNet还有其它变体如Wider ResNet，DarkNet53等。它们的改进相对较大，尤其是DarkNet53，它和ResNet已经有很大不同了，只是使用到了残差连接从而复用特征而已。总而言之，ResNet是深度学习领域一个里程碑式的工作。。
diff --git "a/docs/_sources/\347\254\254\345\233\233\347\253\240/4.3 DenseNet.md.txt" "b/docs/_sources/\347\254\254\345\233\233\347\253\240/4.3 DenseNet.md.txt"
deleted file mode 100644
index e69de29bb..000000000
diff --git "a/docs/_sources/\347\254\254\345\233\233\347\253\240/4.4 FashionMNIST\345\233\276\345\203\217\345\210\206\347\261\273.md.txt" "b/docs/_sources/\347\254\254\345\233\233\347\253\240/4.4 FashionMNIST\345\233\276\345\203\217\345\210\206\347\261\273.md.txt"
deleted file mode 100644
index 87e118d60..000000000
--- "a/docs/_sources/\347\254\254\345\233\233\347\253\240/4.4 FashionMNIST\345\233\276\345\203\217\345\210\206\347\261\273.md.txt"
+++ /dev/null
@@ -1,338 +0,0 @@
-# 基础实战——FashionMNIST时装分类
-
-
-
-经过前面三章内容的学习，我们完成了以下的内容：
-- 对PyTorch有了初步的认识
-- 学会了如何安装PyTorch以及对应的编程环境
-- 学习了PyTorch最核心的理论基础（张量&自动求导）
-- 梳理了利用PyTorch完成深度学习的主要步骤和对应实现方式
-
-现在，我们通过一个基础实战案例，将第一部分所涉及的PyTorch入门知识串起来，便于大家加深理解。同时为后续的进阶学习打好基础。
-
-经过本节的学习，你将收获：
-
-- 一个完整的深度学习流程
-- 各个组件的实际使用方法
-
-我们这里的任务是对10个类别的“时装”图像进行分类，使用[FashionMNIST数据集](https://github.com/zalandoresearch/fashion-mnist/tree/master/data/fashion )。
-上图给出了FashionMNIST中数据的若干样例图，其中每个小图对应一个样本。
-FashionMNIST数据集中包含已经预先划分好的训练集和测试集，其中训练集共60,000张图像，测试集共10,000张图像。每张图像均为单通道黑白图像，大小为28\*28pixel，分属10个类别。
-
-下面让我们一起将第三章各部分内容逐步实现，来跑完整个深度学习流程。
-
-**首先导入必要的包**
-
-
-```python
-import os
-import numpy as np
-import pandas as pd
-import torch
-import torch.nn as nn
-import torch.optim as optim
-from torch.utils.data import Dataset, DataLoader
-```
-
-**配置训练环境和超参数**
-
-
-
-```python
-# 配置GPU，这里有两种方式
-## 方案一：使用os.environ
-os.environ['CUDA_VISIBLE_DEVICES'] = '0'
-# 方案二：使用“device”，后续对要使用GPU的变量用.to(device)即可
-device = torch.device("cuda:1" if torch.cuda.is_available() else "cpu")
-
-## 配置其他超参数，如batch_size, num_workers, learning rate, 以及总的epochs
-batch_size = 256
-num_workers = 4 # 对于Windows用户，这里应设置为0，否则会出现多线程错误
-lr = 1e-4
-epochs = 20
-```
-
-**数据读入和加载**
-这里同时展示两种方式:
-- 下载并使用PyTorch提供的内置数据集
-- 从网站下载以csv格式存储的数据，读入并转成预期的格式
-第一种数据读入方式只适用于常见的数据集，如MNIST，CIFAR10等，PyTorch官方提供了数据下载。这种方式往往适用于快速测试方法（比如测试下某个idea在MNIST数据集上是否有效）
-第二种数据读入方式需要自己构建Dataset，这对于PyTorch应用于自己的工作中十分重要
-
-同时，还需要对数据进行必要的变换，比如说需要将图片统一为一致的大小，以便后续能够输入网络训练；需要将数据格式转为Tensor类，等等。
-
-这些变换可以很方便地借助torchvision包来完成，这是PyTorch官方用于图像处理的工具库，上面提到的使用内置数据集的方式也要用到。PyTorch的一大方便之处就在于它是一整套“生态”，有着官方和第三方各个领域的支持。这些内容我们会在后续课程中详细介绍。
-
-
-```python
-# 首先设置数据变换
-from torchvision import transforms
-
-image_size = 28
-data_transform = transforms.Compose([
- transforms.ToPILImage(),
- # 这一步取决于后续的数据读取方式，如果使用内置数据集读取方式则不需要
- transforms.Resize(image_size),
- transforms.ToTensor()
-])
-```
-
-
-```python
-## 读取方式一：使用torchvision自带数据集，下载可能需要一段时间
-from torchvision import datasets
-
-train_data = datasets.FashionMNIST(root='./', train=True, download=True, transform=data_transform)
-test_data = datasets.FashionMNIST(root='./', train=False, download=True, transform=data_transform)
-```
-
- /data1/ljq/anaconda3/envs/smp/lib/python3.8/site-packages/torchvision/datasets/mnist.py:498: UserWarning: The given NumPy array is not writeable, and PyTorch does not support non-writeable tensors. This means you can write to the underlying (supposedly non-writeable) NumPy array using the tensor. You may want to copy the array to protect its data or make it writeable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at /opt/conda/conda-bld/pytorch_1623448234945/work/torch/csrc/utils/tensor_numpy.cpp:180.)
- return torch.from_numpy(parsed.astype(m[2], copy=False)).view(*s)
-
-
-
-```python
-## 读取方式二：读入csv格式的数据，自行构建Dataset类
-# csv数据下载链接：https://www.kaggle.com/zalando-research/fashionmnist
-class FMDataset(Dataset):
- def __init__(self, df, transform=None):
- self.df = df
- self.transform = transform
- self.images = df.iloc[:,1:].values.astype(np.uint8)
- self.labels = df.iloc[:, 0].values
-
- def __len__(self):
- return len(self.images)
-
- def __getitem__(self, idx):
- image = self.images[idx].reshape(28,28,1)
- label = int(self.labels[idx])
- if self.transform is not None:
- image = self.transform(image)
- else:
- image = torch.tensor(image/255., dtype=torch.float)
- label = torch.tensor(label, dtype=torch.long)
- return image, label
-
-train_df = pd.read_csv("./FashionMNIST/fashion-mnist_train.csv")
-test_df = pd.read_csv("./FashionMNIST/fashion-mnist_test.csv")
-train_data = FMDataset(train_df, data_transform)
-test_data = FMDataset(test_df, data_transform)
-```
-
-在构建训练和测试数据集完成后，需要定义DataLoader类，以便在训练和测试时加载数据
-
-
-
-```python
-train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True, num_workers=num_workers, drop_last=True)
-test_loader = DataLoader(test_data, batch_size=batch_size, shuffle=False, num_workers=num_workers)
-```
-
-读入后，我们可以做一些数据可视化操作，主要是验证我们读入的数据是否正确
-
-
-```python
-import matplotlib.pyplot as plt
-image, label = next(iter(train_loader))
-print(image.shape, label.shape)
-plt.imshow(image[0][0], cmap="gray")
-```
-
- torch.Size([256, 1, 28, 28])
- torch.Size([256])
- 
-
-4. 在文件夹中双击打开配置文件
-
-
-
-5. 打开Python文件后，用`Ctrl+F`快捷键查找，输入关键词，找到`# c.NotebookApp.notebook_dir = ''`
-
-6. 去掉注释，并填充路径`c.NotebookApp.notebook_dir = 'D:\\Adatascience'`
-
-
-
-7. 此时我们在终端中输入`jupyter notebook`，打开页面后发现文件默认路径已经被更改。但是点击菜单栏中的应用快捷方式打开Jupyter Notebook，打开页面发现文件位置仍然是默认路径
-
-
-
-8. 如果我们想要更改应用快捷方式Jupyter Notebook的文件位置，此时需要右键选中快捷方式，打开文件所在位置。再右键点击快捷方式，查看属性，再点击快捷方式
-
-
-
-
-
-9. 我们只需要在“目标”中删除红框标记部分，点击确定
-
-
-
-10. 此时再打开菜单栏中Jupyter Notebook的快捷方式，发现页面文件路径已经变为之前自主设置的路径啦！
-
-
-
-* Jupyter Lab的修改操作和Jupyter Notebook流程相似，但是在细节上有些不同
-
-1. 同样我们还是首先需要查看配置文件，在终端输入
-
- ```python
- jupyter lab --generate-config
- ```
-
-2. 找到配置文件所在的文件夹，打开配置文件
-
-3. 修改配置文件时，用`Ctrl+F`快捷键查找，输入关键词，找到`# c.ServerApp.notebook_dir`，去掉注释。改为`c.ServerApp.notebook_dir = 'D:\\Adatascience（这里填自己想改的文件路径）'`
-
-4. 之后的步骤和Jupyter Notebook修改配置文件的第七至第十步相同
-
-### 2.2 使用虚拟环境
-
- 需要注意的是，Anaconda安装的虚拟环境和Jupyter Notebook运行需要的Kernel并不互通。那么我们该如何解决这个问题，并且如果我们想要切换内核（Change Kernel），该如何操作呢？
-
-1. 将在Anaconda中创建的虚拟环境添加`ipykernel`
-
-```python
-# 如果还没创建环境，在创建时要加上ipykernel
-conda create -n env_name python=3.8 ipykernel
-# 如果已经创建环境，在环境中安装ipykernel
-pip install ipykernel
-```
-
-2. 将虚拟环境写进Jupyter
-
-```python
-python -m ipykernel install --user --name env_name --display-name "env_name"
-```
-
-3. 在`Kernel`中更换添加的虚拟环境即可
-
-
-
-## 3 Jupyter Notebook\Lab基本操作
-
-### 3.1 基本使用
-
-#### 3.1.1 Jupyter Notebook
-
-1. 创建文件：点击右上角New，选择Notebook；创建文件夹：点击右上角New，选择Folder
-
-
-
-2. 删除文件：点击文件前的方框，再点击删除图标
-
-
-
-3. 重命名文件：当文件在运行时（即文件前图标为绿色），需要先点击“Shutdown”（关闭终端），再点击“Rename”
-
-
-
-4. 重命名文件夹：点击文件夹前的方框，再点击“Rename”
-5. 复制（Duplicate）、移动（Move）、下载（Download）、查看（View）等操作，同样可以点击文件前的方框，再点上方的图标进行操作
-
-#### 3.1.2 Jupyter Lab
-
-1. 红框内按钮从左到右分别是新建文件、新建文件夹、上传文件和刷新
-
-
-
-2. 上传多个文件的方法：
-
-* 将文件打包成一个zip压缩包
-* 上传该压缩包
-* 解压文件`!unzip (压缩包所在路径) -d (解压路径)`，例如：`!unzip coco.zip -d data/coco`
-* 删除该压缩包
-
-
-
-### 3.2 常用快捷键
-
-1. 入门操作
-
- ```python
- # 增加，减少，剪切，保存，删除等
- # a, b, x, s, dd
-
- # 合并，执行本单元代码，并跳转到下一单元，执行本单元代码，留在本单元
- # Shift+M Shift+Enter Ctrl+Enter
-
- # 显示行数，切换markdown/code
- # l, m/y
- ```
-
-2. Jupyter Notebook中按下Enter进入编辑模式，按下Esc进入命令模式
-
-* **编辑模式（绿色）**
-
- 
-
-* **命令模式（蓝色）**
-
- 
-
-* 在命令模式下，点击h，会弹出快捷键窗口
-
-
-
-3. Jupyter Lab同样有两种模式。按下Enter进入编辑模式，按下Esc进入命令模式
-
-* 编辑模式（有框线无光标）
-
-
-
-* 命令模式（无框线无光标）
-
-
-
-* 快捷键操作与Jupyter Notebook基本相同，可参考上一部分
-
-4. 快捷键汇总
-
- 命令模式（按`Esc`）
-
-- **Enter** : 转入编辑模式
-- **Shift-Enter** : 运行本单元，选中下个单元
-- **Ctrl-Enter** : 运行本单元
-- **Alt-Enter** : 运行本单元，在其下插入新单元
-- **Y** : 单元转入代码状态
-- **M** :单元转入markdown状态
-- **R** : 单元转入raw状态
-- **1** : 设定 1 级标题
-- **2** : 设定 2 级标题
-- **3** : 设定 3 级标题
-- **4** : 设定 4 级标题
-- **5** : 设定 5 级标题
-- **6** : 设定 6 级标题
-- **Up** : 选中上方单元
-- **K** : 选中上方单元
-- **Down** : 选中下方单元
-- **J** : 选中下方单元
-- **Shift-K** : 扩大选中上方单元
-- **Shift-J** : 扩大选中下方单元
-- **A** : 在上方插入新单元
-- **B** : 在下方插入新单元
-- **X** : 剪切选中的单元
-- **C** : 复制选中的单元
-- **Shift-V** : 粘贴到上方单元
-- **V** : 粘贴到下方单元
-- **Z** : 恢复删除的最后一个单元
-- **D,D** : 删除选中的单元
-- **Shift-M** : 合并选中的单元
-- **Ctrl-S** : 文件存盘
-- **S** : 文件存盘
-- **L** : 转换行号
-- **O** : 转换输出
-- **Shift-O** : 转换输出滚动
-- **Esc** : 关闭页面
-- **Q** : 关闭页面
-- **H** : 显示快捷键帮助
-- **I,I** : 中断Notebook内核
-- **0,0** : 重启Notebook内核
-- **Shift** : 忽略
-- **Shift-Space** : 向上滚动
-- **Space** : 向下滚动
-
- 编辑模式（按`Enter`）
-
-- **Tab** : 代码补全或缩进
-- **Shift-Tab** : 提示
-- **Ctrl-]** : 缩进
-- **Ctrl-[** : 解除缩进
-- **Ctrl-A** : 全选
-- **Ctrl-Z** : 复原
-- **Ctrl-Shift-Z** : 再做
-- **Ctrl-Y** : 再做
-- **Ctrl-Home** : 跳到单元开头
-- **Ctrl-Up** : 跳到单元开头
-- **Ctrl-End** : 跳到单元末尾
-- **Ctrl-Down** : 跳到单元末尾
-- **Ctrl-Left** : 跳到左边一个字首
-- **Ctrl-Right** : 跳到右边一个字首
-- **Ctrl-Backspace** : 删除前面一个字
-- **Ctrl-Delete** : 删除后面一个字
-- **Esc** : 进入命令模式
-- **Ctrl-M** : 进入命令模式
-- **Shift-Enter** : 运行本单元，选中下一单元
-- **Ctrl-Enter** : 运行本单元
-- **Alt-Enter** : 运行本单元，在下面插入一单元
-- **Ctrl-Shift--** : 分割单元
-- **Ctrl-Shift-Subtract** : 分割单元
-- **Ctrl-S** : 文件存盘
-- **Shift** : 忽略
-- **Up** : 光标上移或转入上一单元
-- **Down** :光标下移或转入下一单元
-
-### 3.3 安装插件
-
-* Jupyter Notebook安装插件的方法
-
-1. 在Anaconda Powershell Prompt中输入
-
- ```python
- pip install jupyter_contrib_nbextensions
- ```
-
-2. 再次输入以下指令，将插件添加到工具栏
-
- ```python
- jupyter contrib nbextension install
- ```
-
-3. 打开Jupyter Notebook，点击Nbextensions，取消勾选`disable configuration for nbextensions without explicit compatibility`，此时可以添加自己喜欢的插件啦！
-
-
-
-4. 推荐以下两个基础插件
-
-* Execute Time：可以显示执行一个Cell要花费多少时间
-* Hinterland：提供代码补全功能
-
-
-
-* Jupyter Lab安装插件的方法
-
-1. Jupyter Lab安装插件点击左侧的第四个标志，点击“Enable”后就可以在搜索栏中搜索想要的插件
-
-
-
-2. 例如搜索`jupyterlab-execute-time`后，在Search Results中查看结果，点击Install便可安装插件
-
-
-
-3. 还可以在Anaconda Powershell Prompt中使用指令来安装插件
-
- ```python
- jupyter labextension install jupyterlab-execute-time # 安装jupyterlab-execute-time
- ```
-
-
-
-## 4 进阶操作
-
- 除了以上操作，Jupyter Notebook还有许多丰富的内容等待大家探索。如Bash命令、魔术命令等。我们为大家提供了一份在Notebook中编写的进阶操作，快来试试看吧~
-
- [点击查看进阶教程](https://github.com/datawhalechina/thorough-pytorch/blob/main/notebook/%E7%AC%AC%E9%9B%B6%E7%AB%A0%20%E5%89%8D%E7%BD%AE%E7%9F%A5%E8%AF%86%E8%A1%A5%E5%85%85/%E8%BF%9B%E9%98%B6%E6%93%8D%E4%BD%9C.ipynb)
-
-
-
-## 5 参考资料
-
-【1】[Jupyter Notebook介绍、安装及使用教程 - 知乎 (zhihu.com)](https://zhuanlan.zhihu.com/p/33105153)
-
diff --git "a/docs/_sources/\347\254\254\351\233\266\347\253\240/index.md.txt" "b/docs/_sources/\347\254\254\351\233\266\347\253\240/index.md.txt"
deleted file mode 100644
index 5d8c72a79..000000000
--- "a/docs/_sources/\347\254\254\351\233\266\347\253\240/index.md.txt"
+++ /dev/null
@@ -1,8 +0,0 @@
-# 第零章：前置知识
-```{toctree}
-:maxdepth: 2
-0.1 人工智能简史
-0.2 评价指标
-0.3 常用包的学习
-0.4 Jupyter相关操作
-```
\ No newline at end of file
diff --git a/docs/_static/basic.css b/docs/_static/basic.css
deleted file mode 100644
index d54be8067..000000000
--- a/docs/_static/basic.css
+++ /dev/null
@@ -1,906 +0,0 @@
-/*
- * basic.css
- * ~~~~~~~~~
- *
- * Sphinx stylesheet -- basic theme.
- *
- * :copyright: Copyright 2007-2022 by the Sphinx team, see AUTHORS.
- * :license: BSD, see LICENSE for details.
- *
- */
-
-/* -- main layout ----------------------------------------------------------- */
-
-div.clearer {
- clear: both;
-}
-
-div.section::after {
- display: block;
- content: '';
- clear: left;
-}
-
-/* -- relbar ---------------------------------------------------------------- */
-
-div.related {
- width: 100%;
- font-size: 90%;
-}
-
-div.related h3 {
- display: none;
-}
-
-div.related ul {
- margin: 0;
- padding: 0 0 0 10px;
- list-style: none;
-}
-
-div.related li {
- display: inline;
-}
-
-div.related li.right {
- float: right;
- margin-right: 5px;
-}
-
-/* -- sidebar --------------------------------------------------------------- */
-
-div.sphinxsidebarwrapper {
- padding: 10px 5px 0 10px;
-}
-
-div.sphinxsidebar {
- float: left;
- width: 270px;
- margin-left: -100%;
- font-size: 90%;
- word-wrap: break-word;
- overflow-wrap : break-word;
-}
-
-div.sphinxsidebar ul {
- list-style: none;
-}
-
-div.sphinxsidebar ul ul,
-div.sphinxsidebar ul.want-points {
- margin-left: 20px;
- list-style: square;
-}
-
-div.sphinxsidebar ul ul {
- margin-top: 0;
- margin-bottom: 0;
-}
-
-div.sphinxsidebar form {
- margin-top: 10px;
-}
-
-div.sphinxsidebar input {
- border: 1px solid #98dbcc;
- font-family: sans-serif;
- font-size: 1em;
-}
-
-div.sphinxsidebar #searchbox form.search {
- overflow: hidden;
-}
-
-div.sphinxsidebar #searchbox input[type="text"] {
- float: left;
- width: 80%;
- padding: 0.25em;
- box-sizing: border-box;
-}
-
-div.sphinxsidebar #searchbox input[type="submit"] {
- float: left;
- width: 20%;
- border-left: none;
- padding: 0.25em;
- box-sizing: border-box;
-}
-
-
-img {
- border: 0;
- max-width: 100%;
-}
-
-/* -- search page ----------------------------------------------------------- */
-
-ul.search {
- margin: 10px 0 0 20px;
- padding: 0;
-}
-
-ul.search li {
- padding: 5px 0 5px 20px;
- background-image: url(file.png);
- background-repeat: no-repeat;
- background-position: 0 7px;
-}
-
-ul.search li a {
- font-weight: bold;
-}
-
-ul.search li p.context {
- color: #888;
- margin: 2px 0 0 30px;
- text-align: left;
-}
-
-ul.keywordmatches li.goodmatch a {
- font-weight: bold;
-}
-
-/* -- index page ------------------------------------------------------------ */
-
-table.contentstable {
- width: 90%;
- margin-left: auto;
- margin-right: auto;
-}
-
-table.contentstable p.biglink {
- line-height: 150%;
-}
-
-a.biglink {
- font-size: 1.3em;
-}
-
-span.linkdescr {
- font-style: italic;
- padding-top: 5px;
- font-size: 90%;
-}
-
-/* -- general index --------------------------------------------------------- */
-
-table.indextable {
- width: 100%;
-}
-
-table.indextable td {
- text-align: left;
- vertical-align: top;
-}
-
-table.indextable ul {
- margin-top: 0;
- margin-bottom: 0;
- list-style-type: none;
-}
-
-table.indextable > tbody > tr > td > ul {
- padding-left: 0em;
-}
-
-table.indextable tr.pcap {
- height: 10px;
-}
-
-table.indextable tr.cap {
- margin-top: 10px;
- background-color: #f2f2f2;
-}
-
-img.toggler {
- margin-right: 3px;
- margin-top: 3px;
- cursor: pointer;
-}
-
-div.modindex-jumpbox {
- border-top: 1px solid #ddd;
- border-bottom: 1px solid #ddd;
- margin: 1em 0 1em 0;
- padding: 0.4em;
-}
-
-div.genindex-jumpbox {
- border-top: 1px solid #ddd;
- border-bottom: 1px solid #ddd;
- margin: 1em 0 1em 0;
- padding: 0.4em;
-}
-
-/* -- domain module index --------------------------------------------------- */
-
-table.modindextable td {
- padding: 2px;
- border-collapse: collapse;
-}
-
-/* -- general body styles --------------------------------------------------- */
-
-div.body {
- min-width: 450px;
- max-width: 800px;
-}
-
-div.body p, div.body dd, div.body li, div.body blockquote {
- -moz-hyphens: auto;
- -ms-hyphens: auto;
- -webkit-hyphens: auto;
- hyphens: auto;
-}
-
-a.headerlink {
- visibility: hidden;
-}
-
-a.brackets:before,
-span.brackets > a:before{
- content: "[";
-}
-
-a.brackets:after,
-span.brackets > a:after {
- content: "]";
-}
-
-h1:hover > a.headerlink,
-h2:hover > a.headerlink,
-h3:hover > a.headerlink,
-h4:hover > a.headerlink,
-h5:hover > a.headerlink,
-h6:hover > a.headerlink,
-dt:hover > a.headerlink,
-caption:hover > a.headerlink,
-p.caption:hover > a.headerlink,
-div.code-block-caption:hover > a.headerlink {
- visibility: visible;
-}
-
-div.body p.caption {
- text-align: inherit;
-}
-
-div.body td {
- text-align: left;
-}
-
-.first {
- margin-top: 0 !important;
-}
-
-p.rubric {
- margin-top: 30px;
- font-weight: bold;
-}
-
-img.align-left, figure.align-left, .figure.align-left, object.align-left {
- clear: left;
- float: left;
- margin-right: 1em;
-}
-
-img.align-right, figure.align-right, .figure.align-right, object.align-right {
- clear: right;
- float: right;
- margin-left: 1em;
-}
-
-img.align-center, figure.align-center, .figure.align-center, object.align-center {
- display: block;
- margin-left: auto;
- margin-right: auto;
-}
-
-img.align-default, figure.align-default, .figure.align-default {
- display: block;
- margin-left: auto;
- margin-right: auto;
-}
-
-.align-left {
- text-align: left;
-}
-
-.align-center {
- text-align: center;
-}
-
-.align-default {
- text-align: center;
-}
-
-.align-right {
- text-align: right;
-}
-
-/* -- sidebars -------------------------------------------------------------- */
-
-div.sidebar,
-aside.sidebar {
- margin: 0 0 0.5em 1em;
- border: 1px solid #ddb;
- padding: 7px;
- background-color: #ffe;
- width: 40%;
- float: right;
- clear: right;
- overflow-x: auto;
-}
-
-p.sidebar-title {
- font-weight: bold;
-}
-
-div.admonition, div.topic, blockquote {
- clear: left;
-}
-
-/* -- topics ---------------------------------------------------------------- */
-
-div.topic {
- border: 1px solid #ccc;
- padding: 7px;
- margin: 10px 0 10px 0;
-}
-
-p.topic-title {
- font-size: 1.1em;
- font-weight: bold;
- margin-top: 10px;
-}
-
-/* -- admonitions ----------------------------------------------------------- */
-
-div.admonition {
- margin-top: 10px;
- margin-bottom: 10px;
- padding: 7px;
-}
-
-div.admonition dt {
- font-weight: bold;
-}
-
-p.admonition-title {
- margin: 0px 10px 5px 0px;
- font-weight: bold;
-}
-
-div.body p.centered {
- text-align: center;
- margin-top: 25px;
-}
-
-/* -- content of sidebars/topics/admonitions -------------------------------- */
-
-div.sidebar > :last-child,
-aside.sidebar > :last-child,
-div.topic > :last-child,
-div.admonition > :last-child {
- margin-bottom: 0;
-}
-
-div.sidebar::after,
-aside.sidebar::after,
-div.topic::after,
-div.admonition::after,
-blockquote::after {
- display: block;
- content: '';
- clear: both;
-}
-
-/* -- tables ---------------------------------------------------------------- */
-
-table.docutils {
- margin-top: 10px;
- margin-bottom: 10px;
- border: 0;
- border-collapse: collapse;
-}
-
-table.align-center {
- margin-left: auto;
- margin-right: auto;
-}
-
-table.align-default {
- margin-left: auto;
- margin-right: auto;
-}
-
-table caption span.caption-number {
- font-style: italic;
-}
-
-table caption span.caption-text {
-}
-
-table.docutils td, table.docutils th {
- padding: 1px 8px 1px 5px;
- border-top: 0;
- border-left: 0;
- border-right: 0;
- border-bottom: 1px solid #aaa;
-}
-
-table.footnote td, table.footnote th {
- border: 0 !important;
-}
-
-th {
- text-align: left;
- padding-right: 5px;
-}
-
-table.citation {
- border-left: solid 1px gray;
- margin-left: 1px;
-}
-
-table.citation td {
- border-bottom: none;
-}
-
-th > :first-child,
-td > :first-child {
- margin-top: 0px;
-}
-
-th > :last-child,
-td > :last-child {
- margin-bottom: 0px;
-}
-
-/* -- figures --------------------------------------------------------------- */
-
-div.figure, figure {
- margin: 0.5em;
- padding: 0.5em;
-}
-
-div.figure p.caption, figcaption {
- padding: 0.3em;
-}
-
-div.figure p.caption span.caption-number,
-figcaption span.caption-number {
- font-style: italic;
-}
-
-div.figure p.caption span.caption-text,
-figcaption span.caption-text {
-}
-
-/* -- field list styles ----------------------------------------------------- */
-
-table.field-list td, table.field-list th {
- border: 0 !important;
-}
-
-.field-list ul {
- margin: 0;
- padding-left: 1em;
-}
-
-.field-list p {
- margin: 0;
-}
-
-.field-name {
- -moz-hyphens: manual;
- -ms-hyphens: manual;
- -webkit-hyphens: manual;
- hyphens: manual;
-}
-
-/* -- hlist styles ---------------------------------------------------------- */
-
-table.hlist {
- margin: 1em 0;
-}
-
-table.hlist td {
- vertical-align: top;
-}
-
-/* -- object description styles --------------------------------------------- */
-
-.sig {
- font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
-}
-
-.sig-name, code.descname {
- background-color: transparent;
- font-weight: bold;
-}
-
-.sig-name {
- font-size: 1.1em;
-}
-
-code.descname {
- font-size: 1.2em;
-}
-
-.sig-prename, code.descclassname {
- background-color: transparent;
-}
-
-.optional {
- font-size: 1.3em;
-}
-
-.sig-paren {
- font-size: larger;
-}
-
-.sig-param.n {
- font-style: italic;
-}
-
-/* C++ specific styling */
-
-.sig-inline.c-texpr,
-.sig-inline.cpp-texpr {
- font-family: unset;
-}
-
-.sig.c .k, .sig.c .kt,
-.sig.cpp .k, .sig.cpp .kt {
- color: #0033B3;
-}
-
-.sig.c .m,
-.sig.cpp .m {
- color: #1750EB;
-}
-
-.sig.c .s, .sig.c .sc,
-.sig.cpp .s, .sig.cpp .sc {
- color: #067D17;
-}
-
-
-/* -- other body styles ----------------------------------------------------- */
-
-ol.arabic {
- list-style: decimal;
-}
-
-ol.loweralpha {
- list-style: lower-alpha;
-}
-
-ol.upperalpha {
- list-style: upper-alpha;
-}
-
-ol.lowerroman {
- list-style: lower-roman;
-}
-
-ol.upperroman {
- list-style: upper-roman;
-}
-
-:not(li) > ol > li:first-child > :first-child,
-:not(li) > ul > li:first-child > :first-child {
- margin-top: 0px;
-}
-
-:not(li) > ol > li:last-child > :last-child,
-:not(li) > ul > li:last-child > :last-child {
- margin-bottom: 0px;
-}
-
-ol.simple ol p,
-ol.simple ul p,
-ul.simple ol p,
-ul.simple ul p {
- margin-top: 0;
-}
-
-ol.simple > li:not(:first-child) > p,
-ul.simple > li:not(:first-child) > p {
- margin-top: 0;
-}
-
-ol.simple p,
-ul.simple p {
- margin-bottom: 0;
-}
-
-dl.footnote > dt,
-dl.citation > dt {
- float: left;
- margin-right: 0.5em;
-}
-
-dl.footnote > dd,
-dl.citation > dd {
- margin-bottom: 0em;
-}
-
-dl.footnote > dd:after,
-dl.citation > dd:after {
- content: "";
- clear: both;
-}
-
-dl.field-list {
- display: grid;
- grid-template-columns: fit-content(30%) auto;
-}
-
-dl.field-list > dt {
- font-weight: bold;
- word-break: break-word;
- padding-left: 0.5em;
- padding-right: 5px;
-}
-
-dl.field-list > dt:after {
- content: ":";
-}
-
-dl.field-list > dd {
- padding-left: 0.5em;
- margin-top: 0em;
- margin-left: 0em;
- margin-bottom: 0em;
-}
-
-dl {
- margin-bottom: 15px;
-}
-
-dd > :first-child {
- margin-top: 0px;
-}
-
-dd ul, dd table {
- margin-bottom: 10px;
-}
-
-dd {
- margin-top: 3px;
- margin-bottom: 10px;
- margin-left: 30px;
-}
-
-dl > dd:last-child,
-dl > dd:last-child > :last-child {
- margin-bottom: 0;
-}
-
-dt:target, span.highlighted {
- background-color: #fbe54e;
-}
-
-rect.highlighted {
- fill: #fbe54e;
-}
-
-dl.glossary dt {
- font-weight: bold;
- font-size: 1.1em;
-}
-
-.versionmodified {
- font-style: italic;
-}
-
-.system-message {
- background-color: #fda;
- padding: 5px;
- border: 3px solid red;
-}
-
-.footnote:target {
- background-color: #ffa;
-}
-
-.line-block {
- display: block;
- margin-top: 1em;
- margin-bottom: 1em;
-}
-
-.line-block .line-block {
- margin-top: 0;
- margin-bottom: 0;
- margin-left: 1.5em;
-}
-
-.guilabel, .menuselection {
- font-family: sans-serif;
-}
-
-.accelerator {
- text-decoration: underline;
-}
-
-.classifier {
- font-style: oblique;
-}
-
-.classifier:before {
- font-style: normal;
- margin: 0 0.5em;
- content: ":";
- display: inline-block;
-}
-
-abbr, acronym {
- border-bottom: dotted 1px;
- cursor: help;
-}
-
-/* -- code displays --------------------------------------------------------- */
-
-pre {
- overflow: auto;
- overflow-y: hidden; /* fixes display issues on Chrome browsers */
-}
-
-pre, div[class*="highlight-"] {
- clear: both;
-}
-
-span.pre {
- -moz-hyphens: none;
- -ms-hyphens: none;
- -webkit-hyphens: none;
- hyphens: none;
- white-space: nowrap;
-}
-
-div[class*="highlight-"] {
- margin: 1em 0;
-}
-
-td.linenos pre {
- border: 0;
- background-color: transparent;
- color: #aaa;
-}
-
-table.highlighttable {
- display: block;
-}
-
-table.highlighttable tbody {
- display: block;
-}
-
-table.highlighttable tr {
- display: flex;
-}
-
-table.highlighttable td {
- margin: 0;
- padding: 0;
-}
-
-table.highlighttable td.linenos {
- padding-right: 0.5em;
-}
-
-table.highlighttable td.code {
- flex: 1;
- overflow: hidden;
-}
-
-.highlight .hll {
- display: block;
-}
-
-div.highlight pre,
-table.highlighttable pre {
- margin: 0;
-}
-
-div.code-block-caption + div {
- margin-top: 0;
-}
-
-div.code-block-caption {
- margin-top: 1em;
- padding: 2px 5px;
- font-size: small;
-}
-
-div.code-block-caption code {
- background-color: transparent;
-}
-
-table.highlighttable td.linenos,
-span.linenos,
-div.highlight span.gp { /* gp: Generic.Prompt */
- user-select: none;
- -webkit-user-select: text; /* Safari fallback only */
- -webkit-user-select: none; /* Chrome/Safari */
- -moz-user-select: none; /* Firefox */
- -ms-user-select: none; /* IE10+ */
-}
-
-div.code-block-caption span.caption-number {
- padding: 0.1em 0.3em;
- font-style: italic;
-}
-
-div.code-block-caption span.caption-text {
-}
-
-div.literal-block-wrapper {
- margin: 1em 0;
-}
-
-code.xref, a code {
- background-color: transparent;
- font-weight: bold;
-}
-
-h1 code, h2 code, h3 code, h4 code, h5 code, h6 code {
- background-color: transparent;
-}
-
-.viewcode-link {
- float: right;
-}
-
-.viewcode-back {
- float: right;
- font-family: sans-serif;
-}
-
-div.viewcode-block:target {
- margin: -1px -10px;
- padding: 0 10px;
-}
-
-/* -- math display ---------------------------------------------------------- */
-
-img.math {
- vertical-align: middle;
-}
-
-div.body div.math p {
- text-align: center;
-}
-
-span.eqno {
- float: right;
-}
-
-span.eqno a.headerlink {
- position: absolute;
- z-index: 1;
-}
-
-div.math:hover a.headerlink {
- visibility: visible;
-}
-
-/* -- printout stylesheet --------------------------------------------------- */
-
-@media print {
- div.document,
- div.documentwrapper,
- div.bodywrapper {
- margin: 0 !important;
- width: 100%;
- }
-
- div.sphinxsidebar,
- div.related,
- div.footer,
- #top-link {
- display: none;
- }
-}
\ No newline at end of file
diff --git a/docs/_static/doctools.js b/docs/_static/doctools.js
deleted file mode 100644
index e1bfd708b..000000000
--- a/docs/_static/doctools.js
+++ /dev/null
@@ -1,358 +0,0 @@
-/*
- * doctools.js
- * ~~~~~~~~~~~
- *
- * Sphinx JavaScript utilities for all documentation.
- *
- * :copyright: Copyright 2007-2022 by the Sphinx team, see AUTHORS.
- * :license: BSD, see LICENSE for details.
- *
- */
-
-/**
- * select a different prefix for underscore
- */
-$u = _.noConflict();
-
-/**
- * make the code below compatible with browsers without
- * an installed firebug like debugger
-if (!window.console || !console.firebug) {
- var names = ["log", "debug", "info", "warn", "error", "assert", "dir",
- "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace",
- "profile", "profileEnd"];
- window.console = {};
- for (var i = 0; i < names.length; ++i)
- window.console[names[i]] = function() {};
-}
- */
-
-/**
- * small helper function to urldecode strings
- *
- * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL
- */
-jQuery.urldecode = function(x) {
- if (!x) {
- return x
- }
- return decodeURIComponent(x.replace(/\+/g, ' '));
-};
-
-/**
- * small helper function to urlencode strings
- */
-jQuery.urlencode = encodeURIComponent;
-
-/**
- * This function returns the parsed url parameters of the
- * current request. Multiple values per key are supported,
- * it will always return arrays of strings for the value parts.
- */
-jQuery.getQueryParameters = function(s) {
- if (typeof s === 'undefined')
- s = document.location.search;
- var parts = s.substr(s.indexOf('?') + 1).split('&');
- var result = {};
- for (var i = 0; i < parts.length; i++) {
- var tmp = parts[i].split('=', 2);
- var key = jQuery.urldecode(tmp[0]);
- var value = jQuery.urldecode(tmp[1]);
- if (key in result)
- result[key].push(value);
- else
- result[key] = [value];
- }
- return result;
-};
-
-/**
- * highlight a given string on a jquery object by wrapping it in
- * span elements with the given class name.
- */
-jQuery.fn.highlightText = function(text, className) {
- function highlight(node, addItems) {
- if (node.nodeType === 3) {
- var val = node.nodeValue;
- var pos = val.toLowerCase().indexOf(text);
- if (pos >= 0 &&
- !jQuery(node.parentNode).hasClass(className) &&
- !jQuery(node.parentNode).hasClass("nohighlight")) {
- var span;
- var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg");
- if (isInSVG) {
- span = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
- } else {
- span = document.createElement("span");
- span.className = className;
- }
- span.appendChild(document.createTextNode(val.substr(pos, text.length)));
- node.parentNode.insertBefore(span, node.parentNode.insertBefore(
- document.createTextNode(val.substr(pos + text.length)),
- node.nextSibling));
- node.nodeValue = val.substr(0, pos);
- if (isInSVG) {
- var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
- var bbox = node.parentElement.getBBox();
- rect.x.baseVal.value = bbox.x;
- rect.y.baseVal.value = bbox.y;
- rect.width.baseVal.value = bbox.width;
- rect.height.baseVal.value = bbox.height;
- rect.setAttribute('class', className);
- addItems.push({
- "parent": node.parentNode,
- "target": rect});
- }
- }
- }
- else if (!jQuery(node).is("button, select, textarea")) {
- jQuery.each(node.childNodes, function() {
- highlight(this, addItems);
- });
- }
- }
- var addItems = [];
- var result = this.each(function() {
- highlight(this, addItems);
- });
- for (var i = 0; i < addItems.length; ++i) {
- jQuery(addItems[i].parent).before(addItems[i].target);
- }
- return result;
-};
-
-/*
- * backward compatibility for jQuery.browser
- * This will be supported until firefox bug is fixed.
- */
-if (!jQuery.browser) {
- jQuery.uaMatch = function(ua) {
- ua = ua.toLowerCase();
-
- var match = /(chrome)[ \/]([\w.]+)/.exec(ua) ||
- /(webkit)[ \/]([\w.]+)/.exec(ua) ||
- /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) ||
- /(msie) ([\w.]+)/.exec(ua) ||
- ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) ||
- [];
-
- return {
- browser: match[ 1 ] || "",
- version: match[ 2 ] || "0"
- };
- };
- jQuery.browser = {};
- jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true;
-}
-
-/**
- * Small JavaScript module for the documentation.
- */
-var Documentation = {
-
- init : function() {
- this.fixFirefoxAnchorBug();
- this.highlightSearchWords();
- this.initIndexTable();
- this.initOnKeyListeners();
- },
-
- /**
- * i18n support
- */
- TRANSLATIONS : {},
- PLURAL_EXPR : function(n) { return n === 1 ? 0 : 1; },
- LOCALE : 'unknown',
-
- // gettext and ngettext don't access this so that the functions
- // can safely bound to a different name (_ = Documentation.gettext)
- gettext : function(string) {
- var translated = Documentation.TRANSLATIONS[string];
- if (typeof translated === 'undefined')
- return string;
- return (typeof translated === 'string') ? translated : translated[0];
- },
-
- ngettext : function(singular, plural, n) {
- var translated = Documentation.TRANSLATIONS[singular];
- if (typeof translated === 'undefined')
- return (n == 1) ? singular : plural;
- return translated[Documentation.PLURALEXPR(n)];
- },
-
- addTranslations : function(catalog) {
- for (var key in catalog.messages)
- this.TRANSLATIONS[key] = catalog.messages[key];
- this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')');
- this.LOCALE = catalog.locale;
- },
-
- /**
- * add context elements like header anchor links
- */
- addContextElements : function() {
- $('div[id] > :header:first').each(function() {
- $('\u00B6').
- attr('href', '#' + this.id).
- attr('title', _('Permalink to this headline')).
- appendTo(this);
- });
- $('dt[id]').each(function() {
- $('\u00B6').
- attr('href', '#' + this.id).
- attr('title', _('Permalink to this definition')).
- appendTo(this);
- });
- },
-
- /**
- * workaround a firefox stupidity
- * see: https://bugzilla.mozilla.org/show_bug.cgi?id=645075
- */
- fixFirefoxAnchorBug : function() {
- if (document.location.hash && $.browser.mozilla)
- window.setTimeout(function() {
- document.location.href += '';
- }, 10);
- },
-
- /**
- * highlight the search words provided in the url in the text
- */
- highlightSearchWords : function() {
- var params = $.getQueryParameters();
- var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : [];
- if (terms.length) {
- var body = $('div.body');
- if (!body.length) {
- body = $('body');
- }
- window.setTimeout(function() {
- $.each(terms, function() {
- body.highlightText(this.toLowerCase(), 'highlighted');
- });
- }, 10);
- $('')
- .appendTo($('#searchbox'));
- }
- },
-
- /**
- * init the domain index toggle buttons
- */
- initIndexTable : function() {
- var togglers = $('img.toggler').click(function() {
- var src = $(this).attr('src');
- var idnum = $(this).attr('id').substr(7);
- $('tr.cg-' + idnum).toggle();
- if (src.substr(-9) === 'minus.png')
- $(this).attr('src', src.substr(0, src.length-9) + 'plus.png');
- else
- $(this).attr('src', src.substr(0, src.length-8) + 'minus.png');
- }).css('display', '');
- if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) {
- togglers.click();
- }
- },
-
- /**
- * helper function to hide the search marks again
- */
- hideSearchWords : function() {
- $('#searchbox .highlight-link').fadeOut(300);
- $('span.highlighted').removeClass('highlighted');
- var url = new URL(window.location);
- url.searchParams.delete('highlight');
- window.history.replaceState({}, '', url);
- },
-
- /**
- * helper function to focus on search bar
- */
- focusSearchBar : function() {
- $('input[name=q]').first().focus();
- },
-
- /**
- * make the url absolute
- */
- makeURL : function(relativeURL) {
- return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL;
- },
-
- /**
- * get the current relative url
- */
- getCurrentURL : function() {
- var path = document.location.pathname;
- var parts = path.split(/\//);
- $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() {
- if (this === '..')
- parts.pop();
- });
- var url = parts.join('/');
- return path.substring(url.lastIndexOf('/') + 1, path.length - 1);
- },
-
- initOnKeyListeners: function() {
- // only install a listener if it is really needed
- if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS &&
- !DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS)
- return;
-
- $(document).keydown(function(event) {
- var activeElementType = document.activeElement.tagName;
- // don't navigate when in search box, textarea, dropdown or button
- if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT'
- && activeElementType !== 'BUTTON') {
- if (event.altKey || event.ctrlKey || event.metaKey)
- return;
-
- if (!event.shiftKey) {
- switch (event.key) {
- case 'ArrowLeft':
- if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS)
- break;
- var prevHref = $('link[rel="prev"]').prop('href');
- if (prevHref) {
- window.location.href = prevHref;
- return false;
- }
- break;
- case 'ArrowRight':
- if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS)
- break;
- var nextHref = $('link[rel="next"]').prop('href');
- if (nextHref) {
- window.location.href = nextHref;
- return false;
- }
- break;
- case 'Escape':
- if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS)
- break;
- Documentation.hideSearchWords();
- return false;
- }
- }
-
- // some keyboard layouts may need Shift to get /
- switch (event.key) {
- case '/':
- if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS)
- break;
- Documentation.focusSearchBar();
- return false;
- }
- }
- });
- }
-};
-
-// quick alias for translations
-_ = Documentation.gettext;
-
-$(document).ready(function() {
- Documentation.init();
-});
diff --git a/docs/_static/documentation_options.js b/docs/_static/documentation_options.js
deleted file mode 100644
index 7b66312d3..000000000
--- a/docs/_static/documentation_options.js
+++ /dev/null
@@ -1,14 +0,0 @@
-var DOCUMENTATION_OPTIONS = {
- URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
- VERSION: '0.0.1',
- LANGUAGE: 'zh',
- COLLAPSE_INDEX: false,
- BUILDER: 'html',
- FILE_SUFFIX: '.html',
- LINK_SUFFIX: '.html',
- HAS_SOURCE: true,
- SOURCELINK_SUFFIX: '.txt',
- NAVIGATION_WITH_KEYS: true,
- SHOW_SEARCH_SUMMARY: true,
- ENABLE_SEARCH_SHORTCUTS: true,
-};
\ No newline at end of file
diff --git a/docs/_static/file.png b/docs/_static/file.png
deleted file mode 100644
index a858a410e..000000000
Binary files a/docs/_static/file.png and /dev/null differ
diff --git a/docs/_static/images/logo_binder.svg b/docs/_static/images/logo_binder.svg
deleted file mode 100644
index 45fecf751..000000000
--- a/docs/_static/images/logo_binder.svg
+++ /dev/null
@@ -1,19 +0,0 @@
-
-
-
diff --git a/docs/_static/images/logo_colab.png b/docs/_static/images/logo_colab.png
deleted file mode 100644
index b7560ec21..000000000
Binary files a/docs/_static/images/logo_colab.png and /dev/null differ
diff --git a/docs/_static/images/logo_deepnote.svg b/docs/_static/images/logo_deepnote.svg
deleted file mode 100644
index fa77ebfc2..000000000
--- a/docs/_static/images/logo_deepnote.svg
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/docs/_static/images/logo_jupyterhub.svg b/docs/_static/images/logo_jupyterhub.svg
deleted file mode 100644
index 60cfe9f22..000000000
--- a/docs/_static/images/logo_jupyterhub.svg
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/docs/_static/jquery-3.5.1.js b/docs/_static/jquery-3.5.1.js
deleted file mode 100644
index 50937333b..000000000
--- a/docs/_static/jquery-3.5.1.js
+++ /dev/null
@@ -1,10872 +0,0 @@
-/*!
- * jQuery JavaScript Library v3.5.1
- * https://jquery.com/
- *
- * Includes Sizzle.js
- * https://sizzlejs.com/
- *
- * Copyright JS Foundation and other contributors
- * Released under the MIT license
- * https://jquery.org/license
- *
- * Date: 2020-05-04T22:49Z
- */
-( function( global, factory ) {
-
- "use strict";
-
- if ( typeof module === "object" && typeof module.exports === "object" ) {
-
- // For CommonJS and CommonJS-like environments where a proper `window`
- // is present, execute the factory and get jQuery.
- // For environments that do not have a `window` with a `document`
- // (such as Node.js), expose a factory as module.exports.
- // This accentuates the need for the creation of a real `window`.
- // e.g. var jQuery = require("jquery")(window);
- // See ticket #14549 for more info.
- module.exports = global.document ?
- factory( global, true ) :
- function( w ) {
- if ( !w.document ) {
- throw new Error( "jQuery requires a window with a document" );
- }
- return factory( w );
- };
- } else {
- factory( global );
- }
-
-// Pass this if window is not defined yet
-} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
-
-// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
-// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
-// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
-// enough that all such attempts are guarded in a try block.
-"use strict";
-
-var arr = [];
-
-var getProto = Object.getPrototypeOf;
-
-var slice = arr.slice;
-
-var flat = arr.flat ? function( array ) {
- return arr.flat.call( array );
-} : function( array ) {
- return arr.concat.apply( [], array );
-};
-
-
-var push = arr.push;
-
-var indexOf = arr.indexOf;
-
-var class2type = {};
-
-var toString = class2type.toString;
-
-var hasOwn = class2type.hasOwnProperty;
-
-var fnToString = hasOwn.toString;
-
-var ObjectFunctionString = fnToString.call( Object );
-
-var support = {};
-
-var isFunction = function isFunction( obj ) {
-
- // Support: Chrome <=57, Firefox <=52
- // In some browsers, typeof returns "function" for HTML