- 第02章 Pytorch基础知识
- 2.1 张量
- 2.2 自动求导
- 2.3 并行计算简介
- 2.3.1 为什么要做并行计算
- 2.3.2 CUDA是个啥
- 2.3.3 做并行的方法
- 补充：通过股票数据感受张量概念。
本图文是Datawhale组队学习Pytorch的学习笔记，主要内容包括张量的概念（0维、1维、2维、3维、4维张量等等），自动求导的原理（通过动态图进行理解），以及对并行的理解。
第02章 Pytorch基础知识 2.1 张量本章我们开始介绍Pytorch基础知识，我们从张量说起，建立起对数据的描述，再介绍张量的运算，最后再讲 PyTorch 中所有神经网络的核心包 autograd，也就是自动微分，了解完这些内容我们就可以较好地理解 PyTorch 代码了。下面我们开始吧～
简介
几何代数中定义的张量是基于标量、向量和矩阵的推广，比如我们可以将标量视为0维张量，向量可以视为1维张量，矩阵就是2维张量。
- 0 维张量/标量：标量是一个数字。如 1。
- 1 维张量/向量：如[1,2,3]。
- 2 维张量/矩阵：如[[1,2,3],[4,5,6]]。
- 3 维张量：如[[[1, 4, 7], [2, 5, 8]],[[1, 2, 3], [4, 5, 6]]]。
张量是现代机器学习的基础。它的核心是一个数据容器，多数情况下，它包含数字，有时候它也包含字符串，但这种情况比较少。因此可以把它想象成一个数字的水桶。
机器学习（深度学习） 中用到的数据，包括结构性数据 (数据表、序列) 和非结构性数据（图片、视屏）都是张量，总结如下：
- 数据表：2 维，形状 = (样本数，特征数)
- 序列类：3 维，形状 = (样本数，步长，特征数)
- 图像类：4 维，形状 = (样本数，宽，高，通道数)
- 视屏类：5 维，形状 = (样本数，帧数，宽，高，通道数)
机器学习，尤其深度学习，需要大量的数据，因此样本数肯定占一个维度，惯例我们把它称为维度 1。这样机器学习要处理的张量至少从 2 维开始。
2 维张量就是矩阵，也叫数据表，一般用 csv 存储。
这套表格 21,000 个数据，包括：其价格 (y)，平方英尺，卧室数，楼层，日期，翻新年份等等 21 栏。该数据形状为 (21000, 21)。传统机器学习的线性回归可以来预测房价。
2 维张量的数据表示图如下：
3 维序列数据
推特 (twitter) 的每条推文 (tweet) 规定只能发 280 个字符。在编码推文时，将 280 个字符的序列用独热编码 (one-hot encoding) 到包含 128 个字符的 ASCII 表，如下所示。
这样，每条推文都可以编码为 2 维张量，形状 (280, 128)，比如一条 tweet 是 “I love python ”，这句话映射到 ASCII 表变成：
如果收集到 1 百万条推文，那么整个数据集的形状为 (1000000, 280, 128)。传统机器学习的对率回归可以来做情感分析。
3 维张量的数据表示图如下：
?- 3维=时间序列公用数据存储在张量 时间序列数据 股价 文本数据
4维 图像数据
图像通常具有3个维度：宽度，高度和颜色通道。虽然是黑白图像 (如 MNIST 数字) 只有一个颜色通道，按照惯例，我们还是把它当成 3 维，即颜色通道只有一维。
- 一组黑白照片可存成形状为 (样本数，宽，高，1) 的 4 维张量
- 一组彩色照片可存成形状为 (样本数，宽，高，3) 的 4 维张量
通常 0 代表黑色，255 代表白色。
4 维张量的数据表示图如下：
5维 视频数据
视频可以被分解成一幅幅帧 (frame)。
- 每幅帧就是彩色图像，可以存储在形状是 (宽度，高度，通道) 的 3D 张量中
- 视屏 (一个序列的帧) 可以存储在形状是 (帧数，宽度，高度，通道) 的 4D 张量中
- 一批不同的视频可以存储在形状是 (样本数，帧数，宽度，高度，通道) 的 5D 张量中
下面一个 9:42 秒的 1280x720 YouTube 视频 (哈登三分绝杀勇士)，被分解成 40 个样本数据，每个样本包括 240 帧。这样的视频剪辑将存储在形状为 (40, 240, 1280, 720, 3) 的张量中。
5 维张量的数据表示图如下：
张量可以看成多维数组，下面用 Python 的numpy来定义张量。
import numpy as np
# 0维张量 ()
x0 = np.array(28)
# 1维张量 (3,)
x1 = np.array([1,2,3])
# 2维张量 (2, 3)
x2=np.array([[1,2,3],[4,5,6]])
# 3维张量 (3, 3, 4)
x3 = np.array([[[1, 4, 7, 3], [2, 5, 8, 5], [3, 6, 9, 4]],
[[1, 2, 3, 4], [4, 5, 6, 3], [7, 8, 9, 5]],
[[9, 8, 7, 5], [6, 5, 4, 4], [3, 2, 1, 3]]])
# 4维张量 (2, 5, 4, 3)
x4 = np.ones((2,5,4,3))
不难看出：
- x0, x1, x2, x3 都是用 np.array 直接设定张量里的元素来定义张量。
- X4 用 np.ones 和张量的形状 (2,5,4,3) 来定义一个所有元素都是 1 的张量
在 PyTorch中，torch.Tensor是存储和变换数据的主要工具。如果你之前用过NumPy，你会发现Tensor和NumPy的多维数组非常类似。然而，Tensor提供GPU计算和自动求梯度等更多功能，这些使 Tensor 这一数据类型更加适合深度学习。
from __future__ import print_function import torch
张量的操作主要包括张量的结构操作和张量的数学运算操作。
- Tensor的结构操作包括：创建张量，查看属性，修改形状，指定设备，数据转换， 索引切片，广播机制，元素操作，归并操作；
- Tensor的数学运算包括：标量运算，向量运算，矩阵操作，比较操作；
创建tensor
# （0维张量） x = torch.tensor(2) print(x, x.shape, x.type()) # tensor(2) torch.Size([]) torch.LongTensor y = torch.Tensor(2) print(y, y.shape, y.type()) # tensor([0., 0.]) torch.Size([2]) torch.FloatTensor
注意到了torch.tensor与torch.Tensor的区别没？一字之差，结果差别却很大。
- torch.tensor(2) 返回常量2，数据类型从数据推断而来，其中的2表示的是数据值。
- torch.Tensor(2) 使用全局默认 dtype（FloatTensor），返回一个size为2的向量，初值为 0；
直接使用数据，构造一个张量：
# 1维度张量 x = torch.tensor([5.5, 3]) print(x, x.shape, x.type()) # tensor([5.5000, 3.0000]) torch.Size([2]) torch.FloatTensor
构造一个随机初始化的矩阵：
# 2维向量 torch.manual_seed(20211013) x = torch.rand([4, 3]) print(x, x.shape, x.type()) # tensor([[0.4786, 0.4584, 0.2201], # [0.5064, 0.5879, 0.9110], # [0.8603, 0.5285, 0.0871], # [0.8849, 0.4521, 0.3099]]) torch.Size([4, 3]) torch.FloatTensor
构造一个矩阵全为 0，而且数据类型是 long。
# 2维向量 x = torch.zeros([4,3],dtype=torch.long) print(x) # tensor([[0, 0, 0], # [0, 0, 0], # [0, 0, 0], # [0, 0, 0]])
基于已经存在的 tensor，创建一个 tensor ：
x = torch.tensor([5.5, 3]) x = x.new_ones([4,3]) print(x,x.type()) # tensor([[1., 1., 1.], # [1., 1., 1.], # [1., 1., 1.], # [1., 1., 1.]], dtype=torch.float64) # 创建一个新的tensor，返回的tensor默认具有相同的 torch.dtype和torch.device # 也可以像之前的写法 x = torch.ones(4, 3, dtype=torch.double) x = torch.ones([4,3],dtype=torch.double) print(x) # tensor([[1., 1., 1.], # [1., 1., 1.], # [1., 1., 1.], # [1., 1., 1.]], dtype=torch.float64) x = torch.rand_like(x,dtype=torch.float) # 重置数据类型 print(x) # 结果会有一样的size # tensor([[0.5162, 0.1575, 0.3045], # [0.8349, 0.5412, 0.5001], # [0.8255, 0.7037, 0.3061], # [0.4699, 0.6661, 0.0216]])
获取它的维度等属性信息：
- tensor.shape，tensor.size(): 返回张量的形状；
- tensor.ndim：查看张量的维度；
- tensor.dtype，tensor.type()：查看张量的数据类型；
- tensor.is_cuda：查看张量是否在GPU上；
- tensor.grad：查看张量的梯度；
- tensor.requires_grad：查看张量是否可微。
torch.manual_seed(20211013)
x = torch.rand([4, 3])
print("形状: ", x.shape, x.size())
print("维度: ", x.ndim)
print("类型: ", x.dtype, x.type())
print("cuda: ", x.is_cuda)
print("梯度: ", x.grad)
print("是否可微: ", x.requires_grad)
# 形状: torch.Size([4, 3]) torch.Size([4, 3])
# 维度: 2
# 类型: torch.float32 torch.FloatTensor
# cuda: False
# 梯度: None
# 是否可微: False
还有一些常见的构造Tensor的函数：
| 函数 | 功能 |
|---|---|
| Tensor(*sizes) | 基础构造函数。 直接从参数构建一个张量，支持List，Numpy数组。 |
| tensor(data) | 类似于np.array |
| ones(*sizes) | 指定shape，生成元素全1的数据。 |
| zeros(*sizes) | 指定shape，生成元素全0的数据。 |
| eye(*sizes) | 对角为1，其余为0。 指定（行列）数，创建二维单位Tensor。 |
| arange(s,e,step) | 从s到e，步长为step生成一个序列张量。 |
| linspace(s,e,steps) | 从s到e，均匀分成step份。 |
| logspace(s,e,steps) | 从10^s 到 10^e，均匀分成steps份。 |
| rand/randn(*sizes) | 生成[0,1]均匀分布和标准正态分布数据。 |
| normal(mean,std)/uniform(from,to) | 正态分布/均匀分布 |
| randperm(m) | 随机排列 |
操作
一些加法操作：
torch.manual_seed(20211013) x = torch.rand([4, 3]) y = torch.ones([4, 3]) print(x) # tensor([[0.4786, 0.4584, 0.2201], # [0.5064, 0.5879, 0.9110], # [0.8603, 0.5285, 0.0871], # [0.8849, 0.4521, 0.3099]]) # 方式1 print(x + y) # tensor([[1.4786, 1.4584, 1.2201], # [1.5064, 1.5879, 1.9110], # [1.8603, 1.5285, 1.0871], # [1.8849, 1.4521, 1.3099]]) # 方式2 print(torch.add(x, y)) # tensor([[1.4786, 1.4584, 1.2201], # [1.5064, 1.5879, 1.9110], # [1.8603, 1.5285, 1.0871], # [1.8849, 1.4521, 1.3099]]) # 方式3 提供一个输出 tensor 作为参数 result = torch.empty([4, 3]) torch.add(x, y, out=result) print(result) # tensor([[1.4786, 1.4584, 1.2201], # [1.5064, 1.5879, 1.9110], # [1.8603, 1.5285, 1.0871], # [1.8849, 1.4521, 1.3099]]) # 方式4 in-place y.add_(x) print(y) # tensor([[1.4786, 1.4584, 1.2201], # [1.5064, 1.5879, 1.9110], # [1.8603, 1.5285, 1.0871], # [1.8849, 1.4521, 1.3099]])
索引操作：（类似于numpy）
需要注意的是：索引出来的结果与原数据共享内存，也即修改一个，另一个会跟着修改。
torch.manual_seed(20211013) x = torch.rand([4, 3]) print(x) # tensor([[0.4786, 0.4584, 0.2201], # [0.5064, 0.5879, 0.9110], # [0.8603, 0.5285, 0.0871], # [0.8849, 0.4521, 0.3099]]) # 取第二列 print(x[:, 1]) # tensor([0.4584, 0.5879, 0.5285, 0.4521])
y = x[0, :] y += 1 print(y) # tensor([1.4786, 1.4584, 1.2201]) print(x[0, :]) # tensor([1.4786, 1.4584, 1.2201]) # 源tensor也被改了了
改变大小：如果你想改变一个 tensor 的大小或者形状，你可以使用 torch.view：
torch.manual_seed(20211013) x = torch.randn([4, 4]) print(x) # tensor([[ 0.9747, 0.8300, -0.6734, -0.4365], # [ 0.1867, 0.9543, 0.3457, -0.1776], # [ 0.5936, -0.7330, 0.2092, 1.1053], # [ 1.3183, -1.9817, 1.9537, -1.2133]]) y = x.view(16) z = x.view(-1, 8) # -1是指这一维的维数由其他维度决定 print(x.size(), y.size(), z.size()) # torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8]) print(y) # tensor([ 0.9747, 0.8300, -0.6734, -0.4365, 0.1867, 0.9543, 0.3457, -0.1776, # 0.5936, -0.7330, 0.2092, 1.1053, 1.3183, -1.9817, 1.9537, -1.2133]) print(z) # tensor([[ 0.9747, 0.8300, -0.6734, -0.4365, 0.1867, 0.9543, 0.3457, -0.1776], # [ 0.5936, -0.7330, 0.2092, 1.1053, 1.3183, -1.9817, 1.9537, -1.2133]])
注意 view() 返回的新tensor与源tensor共享内存（其实是同一个tensor），也即更改其中的一个，另外一个也会跟着改变。（顾名思义，view仅仅是改变了对这个张量的观察⻆度）。
x += 1 print(x) # tensor([[ 1.9747, 1.8300, 0.3266, 0.5635], # [ 1.1867, 1.9543, 1.3457, 0.8224], # [ 1.5936, 0.2670, 1.2092, 2.1053], # [ 2.3183, -0.9817, 2.9537, -0.2133]]) print(y) # 也加了了1 # tensor([ 1.9747, 1.8300, 0.3266, 0.5635, 1.1867, 1.9543, 1.3457, 0.8224, # 1.5936, 0.2670, 1.2092, 2.1053, 2.3183, -0.9817, 2.9537, -0.2133])
所以如果我们想返回一个真正新的副本（即不共享内存）该怎么办呢？
Pytorch还提供了一 个reshape()可以改变形状，但是此函数并不能保证返回的是其拷贝，所以不推荐使用。推荐先用clone创造一个副本然后再使用view。
注意：使用clone还有一个好处是会被记录在计算图中，即梯度回传到副本时也会传到源 Tensor 。
如果你有一个元素 tensor ，使用 .item() 来获得这个 value，即得到Python的标量：
x = torch.randn(1) print(x) # tensor([0.1032]) print(x.item()) # 0.10324124991893768
PyTorch中的 Tensor 支持超过一百种操作，包括转置、索引、切片、数学运算、线性代数、随机数等等，可参考官方文档。
广播机制
当对两个形状不同的 Tensor 按元素运算时，可能会触发广播（broadcasting）机制：先适当复制元素使这两个 Tensor 形状相同后再按元素运算。
import torch x = torch.arange(1, 3).view(1, 2) print(x) # tensor([1, 2]) y = torch.arange(1, 4).view(3, 1) print(y) # tensor([[1], # [2], # [3]]) print(x + y) # tensor([[2, 3], # [3, 4], # [4, 5]])
由于 x 和 y 分别是1行2列和3行1列的矩阵，如果要计算 x + y ，那么 x 中第一行的2个元素被广播（复制）到了第二行和第三行，y中第1列的3个元素被广播（复制）到了第二列。如此，就可以对2 个3行2列的矩阵按元素相加。
2.2 自动求导PyTorch 中，所有神经网络的核心是autograd包。autograd包为张量上的所有操作提供了自动求导机制。它是一个在运行时定义（define-by-run）的框架，这意味着反向传播是根据代码如何运行来决定的，并且每次迭代可以是不同的。
torch.Tensor是这个包的核心类。如果设置它的属性.requires_grad为True，那么它将会追踪对于该张量的所有操作。当完成计算后可以通过调用.backward()，来自动计算所有的梯度。这个张量的所有梯度将会自动累加到.grad属性。
注意：在y.backward()时，如果 y 是标量，则不需要为backward()传入任何参数；否则，需要传入一个与 y 同形的Tensor。
要阻止一个张量被跟踪历史，可以调用.detach()方法将其与计算历史分离，并阻止它未来的计算记录被跟踪。为了防止跟踪历史记录（和使用内存），可以将代码块包装在 with torch.no_grad():中。在评估模型时特别有用，因为模型可能具有requires_grad = True 的可训练的参数，但是我们不需要在此过程中对他们进行梯度计算。
还有一个类对于autograd的实现非常重要：Function。Tensor和Function互相连接生成了一个无环图（acyclic graph），它编码了完整的计算历史。每个张量都有一个.grad_fn属性，该属性引用了创建 Tensor自身的Function（除非这个张量是用户手动创建的，即这个张量的grad_fn是None）。
如果需要计算导数，可以在 Tensor 上调用 .backward()。如果Tensor 是一个标量（即它包含一个元素的数据），则不需要为backward()指定任何参数，但是如果它有更多的元素，则需要指定一个gradient参数，该参数是形状匹配的张量。
import torch
创建一个张量并设置requires_grad=True用来追踪其计算历史。
x = torch.ones([2, 2], requires_grad=True) print(x) # tensor([[1., 1.], # [1., 1.]], requires_grad=True)
对这个张量做一次运算：
y = x ** 2 print(y) # tensor([[1., 1.], # [1., 1.]], grad_fn=)
y是计算的结果，所以它有grad_fn属性。
print(y.grad_fn) #
对y进行更多操作
z = y * y * 3 print(z) # tensor([[3., 3.], # [3., 3.]], grad_fn=) out = z.mean() print(out) # tensor(3., grad_fn= )
.requires_grad_(...)原地改变了现有张量的requires_grad标志。如果没有指定的话，默认输入的这个标志是False。
torch.manual_seed(20211013) a = torch.rand(2, 2) # 缺失情况下默认 requires_grad = False a = ((a * 3) / (a - 1)) print(a.requires_grad) # False a.requires_grad_(True) print(a.requires_grad) # True b = (a * a).sum() print(b.grad_fn) #
梯度
现在开始进行反向传播，因为out是一个标量，因此out.backward()和out.backward(torch.tensor(1.))等价。
输出导数d(out)/dx
x = torch.ones([2, 2], requires_grad=True) y = x ** 2 z = y * y * 3 out = z.mean() out.backward() print(x.grad) # tensor([[3., 3.], # [3., 3.]])
数学上，若有向量函数$vec{y}=f(vec{x})$，那么 $vec{y}$ 关于 $vec{x}$
的梯度就是一个雅可比矩阵：
J=left(begin{array}{ccc}frac{partial y_{1}}{partial x_{1}} & cdots & frac{partial y_{1}}{partial x_{n}} \ vdots & ddots & vdots \ frac{partial y_{m}}{partial x_{1}} & cdots & frac{partial y_{m}}{partial x_{n}}end{array}right)
而 torch.autograd 这个包就是用来计算一些雅可比矩阵的乘积的。例如，如果$v$是一个标量函数$l = g(vec{y})$的梯度：
v=left(begin{array}{lll}frac{partial l}{partial y_{1}} & cdots & frac{partial l}{partial y_{m}}end{array}right)
由链式法则，我们可以得到：
v J=left(begin{array}{lll}frac{partial l}{partial y_{1}} & cdots & frac{partial l}{partial y_{m}}end{array}right)left(begin{array}{ccc}frac{partial y_{1}}{partial x_{1}} & cdots & frac{partial y_{1}}{partial x_{n}} \ vdots & ddots & vdots \ frac{partial y_{m}}{partial x_{1}} & cdots & frac{partial y_{m}}{partial x_{n}}end{array}right)=left(begin{array}{lll}frac{partial l}{partial x_{1}} & cdots & frac{partial l}{partial x_{n}}end{array}right)
注意：grad在反向传播过程中是累加的（accumulated），这意味着每一次运行反向传播，梯度都会累加之前的梯度，所以一般在反向传播之前需把梯度清零。
# 再来反向传播一次，注意grad是累加的 2 out2 = x.sum() out2 = x.sum() out2.backward() print(x.grad) # tensor([[4., 4.], # [4., 4.]]) out3 = x.sum() x.grad.data.zero_() out3.backward() print(x.grad) # tensor([[1., 1.], # [1., 1.]])
现在我们来看一个雅可比向量积的例子：
torch.manual_seed(20211013)
x = torch.randn(3, requires_grad=True)
print(x)
# tensor([ 0.8004, -1.4908, -0.6038], requires_grad=True)
y = x * 2
i = 0
while y.data.norm() < 1000:
y = y * 2
i = i + 1
print(y)
# tensor([ 819.6005, -1526.5718, -618.2654], grad_fn=)
print(i)
# 9
在这种情况下，y不再是标量。torch.autograd不能直接计算完整的雅可比矩阵，但是如果我们只想要雅可比向量积，只需将这个向量作为参数传给backward：
torch.manual_seed(20211013) x = torch.randn(3, requires_grad=True) print(x) # tensor([ 0.8004, -1.4908, -0.6038], requires_grad=True) y = x * 2 print(y) # tensor([ 1.6008, -2.9816, -1.2075], grad_fn=) y.backward() # RuntimeError: grad can be implicitly created only for scalar outputs print(x.grad)
v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float) y.backward(v) print(x.grad) # tensor([1.0240e+02, 1.0240e+03, 1.0240e-01])
也可以通过将代码块包装在with torch.no_grad(): 中，来阻止autograd跟踪设置了.requires_grad=True的张量的历史记录。
torch.manual_seed(20211013)
x = torch.randn(3, requires_grad=True)
print(x.requires_grad) # True
print((x ** 2).requires_grad) # True
with torch.no_grad():
print((x ** 2).requires_grad) # False
如果我们想要修改 tensor 的数值，但是又不希望被 autograd 记录（即不会影响反向传播）， 那么我么可以对 tensor.data 进行操作。
x = torch.ones(1,requires_grad=True) print(x.data) # 还是一个tensor # tensor([1.]) print(x.data.requires_grad) # 但是已经是独立于计算图之外 # False y = 2 * x x.data *= 100 # 只改变了值，不会记录在计算图，所以不会影响梯度传播 y.backward() print(x) # 更改data的值也会影响tensor的值 # tensor([100.], requires_grad=True) print(x.grad) # tensor([2.])2.3 并行计算简介
在利用PyTorch做深度学习的过程中，可能会遇到数据量较大无法在单块GPU上完成，或者需要提升计算速度的场景，这时就需要用到并行计算。本节让我们来简单地了解一下并行计算的基本概念和主要实现方式，具体的内容会在课程的第二部分详细介绍。
2.3.1 为什么要做并行计算我们学习PyTorch的目的就是可以编写我们自己的框架，来完成特定的任务。可以说，在深度学习时代，GPU的出现让我们可以训练的更快，更好。所以，如何充分利用GPU的性能来提高我们模型学习的效果，这一技能是我们必须要学习的。这一节，我们主要讲的就是PyTorch的并行计算。PyTorch可以在编写完模型之后，让多个GPU来参与训练。
2.3.2 CUDA是个啥CUDA是我们使用GPU的提供商——NVIDIA提供的GPU并行计算框架。对于GPU本身的编程，使用的是CUDA语言来实现的。但是，在我们使用PyTorch编写深度学习代码时，使用的CUDA又是另一个意思。在PyTorch使用 CUDA表示要开始要求我们的模型或者数据开始使用GPU了。
在编写程序中，当我们使用了 cuda() 时，其功能是让我们的模型或者数据迁移到GPU当中，通过GPU开始计算。
2.3.3 做并行的方法- 网络结构分布到不同的设备中(Network partitioning)
在刚开始做模型并行的时候，这个方案使用的比较多。其中主要的思路是，将一个模型的各个部分拆分，然后将不同的部分放入到GPU来做不同任务的计算。其架构如下：
这里遇到的问题就是，不同模型组件在不同的GPU上时，GPU之间的传输就很重要，对于GPU之间的通信是一个考验。但是GPU的通信在这种密集任务中很难办到。所有这个方式慢慢淡出了视野，
- 同一层的任务分布到不同数据中(Layer-wise partitioning)
第二种方式就是，同一层的模型做一个拆分，让不同的GPU去训练同一层模型的部分任务。其架构如下：
这样可以保证在不同组件之间传输的问题，但是在我们需要大量的训练，同步任务加重的情况下，会出现和第一种方式一样的问题。
- 不同的数据分布到不同的设备中，执行相同的任务(Data parallelism)
第三种方式有点不一样，它的逻辑是，我不再拆分模型，我训练的时候模型都是一整个模型。但是我将输入的数据拆分。所谓的拆分数据就是，同一个模型在不同GPU中训练一部分数据，然后再分别计算一部分数据之后，只需要将输出的数据做一个汇总，然后再反传。其架构如下：
这种方式可以解决之前模式遇到的通讯问题。
PS:现在的主流方式是数据并行的方式（Data parallelism）
补充：通过股票数据感受张量概念。
在量化金融中，我们用股票数据举例来说明不同维度的张量。
阶段一：一个收盘价
斯蒂文查了查 2019 年 1 月 3 日平安银行 (000001.XSHE) 的收盘价，发现是 9.28，他默默将这个单数字存到 X0 里。
X0 又称为标量 (scalar)，或更严谨的称为 0 维张量 (0D tensor)。
阶段二：加入时间维度
单天股票价格太少，至少要算一些均值、标准差这些统计量吧。
斯蒂文从一天的数据扩展到一年，下载了从 2019 年 1 月 3 日起过去一年的平安银行历史收盘价，存到 X1 里。
X1 在 X0 基础上添加了时间维度 （红色箭头），从标量扩展成向量 (vector)，又称为 1 维张量 (1D tensor)。
阶段三：加入股票维度
单个股票太少，分散原则告诉我们需要投资相关性系数为负的两支股票。
斯蒂文增加了茅台股票 (600519.XSHG)，下载了从 2019年 1 月 3 日起过去一年的平安银行和茅台历史收盘价，存到 X2 里。
X2 在 X1 基础上添加了横截维度（蓝色箭头），从向量扩展成矩阵（matrix），又称为 2 维张量（2D tensor）。
阶段四：加入信息维度
收盘价一个信息不够，在趋势追踪模型中，价格和交易量是在股票走势中相当重要的因素。
斯蒂文增加了交易量，下载了从 2019 年 1 月 3 日起过去一年的平安银行和茅台历史收盘价和交易量，存到 X3 里。
X3 在 X2 基础上添加了信息维度（绿色箭头），从矩阵扩展成 3 维张量（3D tensor）。
阶段五：加入频率维度
收盘信息太过于少，如果要日内交易怎么办？
斯蒂文又增加了 tick 数据，下载了从 2019 年 1 月 3 日起过去一年的平安银行和茅台历史 tick 价格和交易量，存到 X4 里。
国外和国内对于 tick 数据定义有些不同：
- 国外：任何委托单（order）使委托账本（order book）变化而得到的表格。
- 国内：对委托账本的按一定切片时间（500 毫秒，3 秒，6 秒等）抽样的信息。
X4 在 X3 基础上添加了频率维度(灰色箭头)，从 3 维张量扩展成 4 维张量 (4D tensor)。
