* torch.Tensor 存储和变换数据的工具

* Tensor与Ndarray多维数组类似，可提供GPU计算和自动求梯度

* 标量：0纬张量，一个数字

* 向量：1纬张量，[ ]

* 矩阵：2纬张量，[ [ ] ]

首先导入torch，查看版本号

importtorch#打印torch版本

print(torch.__version__)#查看是否支持GPUtorch.cuda.is_avaliable()

代码运行后的结果是：1.4.0

True

1.创建Tensor

1.11 直接创建

* torch.tensor(value)

* value:可以是任何维度的张量

print("创建一个标量5")

x= torch.tensor(5)print("创建一个向量[]")

y= torch.tensor([2,3])print("创建一个矩阵[ [ ] ]")

z= torch.tensor([[1,2],

[2,3]])print(x)print(y)print(z)

输出结果是：

创建一个标量5

创建一个向量[]

创建一个矩阵[ [ ] ]

tensor(5)

tensor([2, 3])

tensor([[1, 2],

[2, 3]])

1.2使用方法创建

* torch.empty(shape,dtype = type):创建未初始化的Tensor,可指定数据类型，dtype参数可省略

* torch.rand(shape) :创建随机矩阵

* torch.zeros(shape):创建0矩阵

* 创建维度均为2纬矩阵

print("创建二维未初始化矩阵")

A= torch.empty((2,2))print(A)print("创建随机矩阵")

B= torch.rand((2,2))print(B)print("创建0矩阵")

C= torch.zeros((2,2))print(C)

输出结果是：

创建二维未初始化矩阵

tensor([[0.0000e+00, 1.4279e+00],

[-9.3980e-11, 4.5908e-41]])

创建随机矩阵

tensor([[0.3857, 0.0058],

[0.1388, 0.9339]])

创建0矩阵

tensor([[0., 0.],

[0., 0.]])

1.3通过现有的Tensor创建

* matrix.new_ones(shape,dtype) 可以改变维度

* torch.randn_like(matirx,dtype)

print("将原本2*2未初始化矩阵进行重新创建")

B= B.new_ones(5,3)print(B)print("将原本2*2未初始化矩阵进行重新创建")

A= torch.randn_like(A, dtype =torch.float)print(A)

输出结果是：

将原本2*2未初始化矩阵进行重新创建

tensor([[1., 1., 1.],

[1., 1., 1.],

[1., 1., 1.],

[1., 1., 1.],

[1., 1., 1.]])

将原本2*2未初始化矩阵进行重新创建

tensor([[0.1454, -0.1173],

[-0.7503, 0.5255]])

1.4Tensor的基本方法

* matrix.shape: 获取Tensor形状

* matirx.size():获取Tensor形状 返回一个tuple，支持tuple的所有操作

print("获取B矩阵形状")print(B.shape)print(B.size())

输出结果是：

获取B矩阵形状

torch.Size([5, 3])

torch.Size([5, 3])

2 Tensor操作

2.1 算法操作

2.11 加法操作

* matrix1 + matirx2

* torch.add(matrix1, matrix2, out = A) out指定输出参数，可省略

* inplace matrix1.add_(matrix2) == (matirx1 += matrix2)

print("使用 + 完成加法操作")print(A +C)print("使用torch.add完成加法操作")print(torch.add(A,C))print("使用inplace完成加法操作")print(C.add_(A))

输出结果是：

使用+完成加法操作

tensor([[0.1454, -0.1173],

[-0.7503, 0.5255]])

使用torch.add完成加法操作

tensor([[0.1454, -0.1173],

[-0.7503, 0.5255]])

使用inplace完成加法操作

tensor([[0.1454, -0.1173],

[-0.7503, 0.5255]])

2.1.2 索引

* 类似于Numpy

* 索引结果与原数据共享内存

A = torch.rand(5,5)print('查看创建Tensor')print(A[1][1])

A[1][1] = 5

print("查看A矩阵第一行第一列是否为5")print(A[1][1])

输出结果是：

查看创建Tensor

tensor(0.6124)

查看A矩阵第一行第一列是否为5

tensor(5.)

2.1.3 改变形状

* marix.clone() 克隆新副本，解决共享内存带来的问题

* matrix.view(shape) view() 前后共享data

* matrix.reshape(shape)

#查看clone与变量赋值的区别

print("查看A变量地址")print(id(A))

A_cl=A.clone()print('查看克隆新副本地址')print(id(A_cl))

A_an=Aprint('查看变量重新赋值后的地址')print(id(A_an))

输出结果是：

查看A变量地址2337547400576查看克隆新副本地址2337538344512查看变量重新赋值后的地址2337547400576

note:这里主要是解释共享data的问题。直接view()的话维度改变，操作的是同一内存的数据。不会生成新的维度的数据。

* 变量赋值相当于引用，地址不变，只想同一块内存

* clone()操作会重新申请内存空间

* matrix.item() 将标量Tensor转化为number

* https://pytorch.org/docs/stable/tensors.html     Tensor操作链接

2.1.4 Tensor的广播机制

* 自动使得运算的Tensor相同的操作

* 首先会比较最靠右的维度，如果最靠右的维度相等或其中一个为 1，则认为此维度相等；

* 再继续向左比较，如果一直满足，则认为两者兼容；

* 最后，分别在对应维度上发生广播，以此补齐直到维度一致；

x = torch.rand(4 , 6)

y= torch.rand(4, 1)print(torch.add(x , y))

输出结果是：

tensor([[0.6108, 0.1842, 0.9873, 0.9042, 0.2456, 0.4298],

[1.0251, 0.6726, 1.2724, 1.2861, 1.1256, 0.5654],

[1.0223, 0.3473, 0.5952, 0.3701, 0.4500, 0.4993],

[0.0542, 0.9524, 0.1668, 0.5762, 0.0671, 0.4689]])

2.1.5 Tensor与Numpy的相互转换

* tensor.numpy() 可将Tensor转为ndarray数据

a = torch.rand(3,2)print(id(a))

b=a.numpy()print(id(b))print(a)print(b)

输出结果为：2337547166400

2337547429088tensor([[0.3145, 0.9862],

[0.7604, 0.9342],

[0.3104, 0.7312]])

[[0.31446308 0.9861587]

[0.7603721 0.9341993]

[0.31042498 0.73123205]]

Numpy转为Tensor

* torch.from_numpy(array)

* torch.Tensor()

importnumpy as np

c=torch.from_numpy(b)

d=torch.Tensor(b)print(type(c))print(type(d))

2.1.6 Tensor on GPU

* .to("cuda") 将Tensor在GPU上运算

x.to("cuda")

* .to(device) 将Tensor在GPU运算

torch.device("cuda")

x.to(device)

* .to("cpu") 将Tensor在CPU上运算

验证GPU的运算速度

%%time #jupyter notebook中的魔法语句，可以输出当前代码块的运行速度print("使用device")

device= torch.device("cuda")

x= torch.rand(200,100).to(device)

y= torch.rand(200,100).to(device)print(x + y)

输出结果是：

使用device

tensor([[1.3311, 1.7433, 1.1089, ..., 0.8775, 1.1430, 0.4877],

[1.1953, 0.3628, 0.6479, ..., 0.4781, 0.9154, 1.3447],

[1.2134, 0.5482, 1.7713, ..., 0.9025, 1.1786, 0.2083],

...,

[0.9276, 0.8605, 0.9905, ..., 0.9992, 1.1613, 0.8636],

[1.2191, 0.6350, 0.9921, ..., 1.7540, 1.0139, 1.2921],

[1.2137, 0.9510, 0.9126, ..., 0.8433, 0.5871, 1.0881]],

device='cuda:0')

Wall time:6.45 s

验证CPU运算速度

%%timeprint("使用CPU")

x= torch.rand(200,100).to("cpu")

y= torch.rand(200,100).to("cpu")print(x + y)

输出结果是：

使用CPU

tensor([[1.4920, 1.1891, 0.0936, ..., 0.5056, 1.6395, 1.0162],

[1.4211, 0.9837, 1.1501, ..., 1.2990, 0.7121, 0.3505],

[1.1503, 1.0263, 1.4055, ..., 0.6856, 0.3320, 0.7620],

...,

[0.4615, 1.0520, 1.3409, ..., 1.1014, 1.0806, 0.9630],

[0.9770, 1.4159, 1.6652, ..., 0.9515, 1.2479, 1.2459],

[0.7622, 0.9159, 0.9734, ..., 0.5249, 0.1216, 0.6906]])

Wall time:112 ms

查看同样维度矩阵计算GPU与CPU的速度差异

print("GPU 比 CPU 的运算速度块: %.2f 倍" %(112 / 6.45))

输出结果是：

GPU 比 CPU 的运算速度块:17.36 倍