python--tensor的基础知识，基本运算

import torch
import numpy as np
# 二维numpy数组
a=np.array([[1,2],[3,4]])
print(type(a))
print(a)
print()
# 二维tensor张量
b=torch.tensor([[1,2],[3,4]])
print(type(b))
print(b)
print()
# tensor 转 numpy
c=b.numpy()
print(type(c))
print(c)
print()
# numpy 转 tensor
d=torch.from_numpy(c)
print(type(d))
print(d)

创建tensor

import torch
import numpy as np
print("1.用numpy或list初始化创建")
# 如果用numpy初始化创建，就要先定义numpy的二维数组，然后转化为torch
a=np.array([[1,2],[3,4]])
print(a)
b=torch.from_numpy(a)
print(b)
"""
dtype=torch.int32
dtype为数据类型，意思为torch类中的int32数据类型
"""
# 用list初始化创建
c=torch.tensor([2.,1.2])
print(c)
"""
torch.tensor([2.,1.2])
2.0可以简写为2.
tensor是直接可以输入数据创建，c为一维张量
"""
# d为二维张量
d=torch.tensor([[3,5],[1,6]])
print(d)
print("2.未初始化创建")
e=torch.empty(1) # torch.empty()创建一个指定大小的张量，但不会对张量的元素进行初始化，因此，值是随机的,empty(m,n),m为行，n为列,里面有几个数字就是几维张量
print(e)
f=torch.Tensor([2,3]) # torch,Tensor用于生成一个单精度浮点类型的张量
print(f)
print("3.随机生成创建")
g=torch.rand(3,2) # torch.rand生成在区间 [0, 1) 内分布的随机数，3为行数，2为列数，里面有几个数字就是几维张量
print(g)
h=torch.randn(3,3) # torch.randn 生成的是从标准正态分布中采样的随机数,因此它的值可以在负无穷到正无穷之间
print(h)
i1=torch.randn_like(g) # torch.randn_like(g)指生成和 g格式相同的 randn张量
print(i1)
i2=torch.rand_like(h) # torch.rand_like(h)指生成和 h格式相同的 rand张量
print(i2)
print("3.序列生成创建")
print(torch.arange(1,10))  # 其值介于区间[1,10),第三个数为步长,默认值为1
print(torch.arange(1,10,2))
print(torch.linspace(1,10,5)) # 其值介于区间[1,10],第三个数为分割的点数，默认是100
print(torch.eye(2,5)) # 生成对角线为1其余全为0的矩阵
print(torch.eye(2))

而关于torch.eye(),又有以下要注意的地方：

torch.eye(m,n)，m为行数，n为列数，如果只有m，就生成m*m的矩阵

关于torch.size():

import torch
x=torch.tensor([1.0,2.0,3.0,4.0,5.0],dtype=torch.float32)
print(x.size())
y=x.reshape(1,5)

print(y.size())
print(x)
print(y)

可以试着运行一下，就会发现，x的size()和resahpe之后的size（）是不一样的

tensor属性

import torch
print("定义tensor属性")
a=torch.tensor([[1,2,3],[2,3,4]],dtype=torch.float)
print(a)
print("tensor类型")
print(a.dtype)
print("tensor形状")
print(a.shape)
print("tensor形状，比shape类型更灵活,主要体现在维度上")
print(a.size())
print("tensor第一维的大小")
print(a.size(0))
print("tensor第二维的大小")
print(a.size(1))
print("tensor维度大小")
print(a.dim())
print("tensor梯度")
print(a.grad)
print("tensor所在设备")
print(a.device)

tensor的变形

import torch
a=torch.tensor([[1,2,3],[2,3,4]],dtype=torch.float)
print("a的值",a)
print("a的形状",a.shape)
print()
# 拉平
b=a.flatten()
print("b的值",b)
print("b的形状",b.shape)
print()
# reshape 改变 b的形状
c=b.reshape(2,3)
print("c的值",c)
print("c的形状",c.shape)
print()
# view 改变 b的形状
d=b.view(1,6)
print("d的值",d)
print("d的形状",d.shape)
print()
# 将 b中张量为 1的那一维去掉
e=torch.squeeze(d)
print("e的值",e)
print("e的形状",e.shape)
print()
# 在指定位置插入1维度
f1=torch.unsqueeze(e,0)
print("f1的值",f1)
print("f1的形状",f1.shape)
print()
f2=torch.unsqueeze(e,1)
print("f2的值",f2)
print("f2的形状",f2.shape)
print()

tensor的索引和切片

import torch
a=torch.tensor([[1,2,3],[4,5,6],[7,8,9]],dtype=torch.float)
b=torch.tensor([[10,10,10],[10,10,10],[10,10,10]],dtype=torch.float)
print("索引")
print("a的值",a)
print("a[1,2]的值:",a[1,2])
print("a[-1,-1]的值:",a[-1,-1])
print("a第2行中的第1列和第3列的值:",a[[1],[0,2]])
print("a的大于4的索引:",a>4)                                # bool索引
print("a的大于4的值:",a[a>4])
print("大于5输出a的值，否则输出b:\n",torch.where(a>6,a,b))   # 条件
print()
print("切片")
# 切片：提取 tensor中某一范围的元素[起始索引：结束索引：步长]
print("a的值",a)
print("a的第1列:",a[:,0])
print("a的第3列:",a[:,2])
print("a的第3列:",a[:,-1])
print("a的1到3列:",a[:,0:2])
print("a的第1行:",a[0,:])
print("a的第2行:",a[1,:])
print("a的最后1行",a[-1,:])
print("a的间隔行值:",a[::2])

tensor的连接和拆分

import torch
a=torch.tensor([[1,2,3],[4,5,6],[7,8,9]],dtype=torch.float)
b=torch.tensor([[10,10,10],[10,10,10],[10,10,10]],dtype=torch.float)
print(a)
print(b)
print("cat,维度不变")
print("a,b按行拼接:\n",torch.cat((a,b),dim=0))
print("a,b按行拼接:\n",torch.cat((a,b),dim=0).shape)
print("a,b按列拼接:\n",torch.cat((a,b),dim=1))
print("a,b按列拼接:\n",torch.cat((a,b),dim=1).shape)
print("stack,维度加一")
print("a,b按行拼接:\n",torch.stack((a,b),dim=0))
print("a,b按行拼接:\n",torch.stack((a,b),dim=0).shape)
print("a,b按列拼接:\n",torch.stack((a,b),dim=1))
print("a,b按列拼接:\n",torch.stack((a,b),dim=1).shape)
print("split")
print(a)
print(torch.split(a,2,dim=0))
print(torch.split(a,1,dim=0))
print(torch.split(a,1,dim=1))
# torch.chunk是将tensor切割为k个tensor。
print("chunk")
print(torch.chunk(a,2,dim=0))
print(torch.chunk(a,2,dim=1))

在这之中，torch.split()与torch.chunk()是有着不同的，我们可以通过以下代码来看区别

print("......................................")
print(torch.split(a,1,dim=0))
print(torch.chunk(a,1,dim=0))
print(11111)
print(torch.split(a,1,dim=1))
print(torch.chunk(a,1,dim=1))
print(22222)
print(torch.split(a,3,dim=0))
print(torch.chunk(a,3,dim=0))

总结一下就是:

split是指定一个 tensor中张量的个数，而 chunk是指定分割后 tensor的数量

tensor的换位与置换

import torch
a=torch.tensor([[1,2,3],[4,5,6],[7,8,9]],dtype=torch.float)
print("二维")
print(a)
print(a.T)
print(torch.t(a))
print("..............")
print(torch.transpose(a,1,0))
print(torch.transpose(a,0,1))
print("多维")
print(a.permute(1,0))
print()
c=torch.unsqueeze(a,0)
print(c)
print(c.shape)
print(c)
print(c.permute(1,0,2).shape)

关于torch.permute()

permute()中，每个数的位置就是它的维度，如三维（0，1，2）
将1维和2维置换，就应是permute(1，0，2)
将2维和3维置换，就应是permute(0，2，1)

tensor的运算

import torch
a=torch.tensor([[1,2,3],[4,5,6],[7,8,9]],dtype=torch.float)
b=torch.tensor([[10,10,10],[10,10,10],[10,10,10]],dtype=torch.float)
print(a)
print(b)
# 点加
print(a+100)
print(a+b)
print(a.add(b))
print()
# 点乘
print(a*b)
# 矩阵相乘
print(a@b)
print(a.matmul(b))
print(torch.mm(a,b))

tensor的微分运算

import torch
x=torch.tensor([1.0,2.0,3.0,4.0,5.0],requires_grad=True,dtype=torch.float32)
print(x.requires_grad)  # 是否需要求导
print(x.grad)           # 输出张量的梯度
print(x.grad_fn)        # 指向运算生成此张量的方法
print()

y=torch.sum(x**2)       # 标量，只是一个数值
print(y)
print(y.item())         # 打印计算值
print(y.grad_fn)        # 打印计算方法
print()

print(x.grad)

y.backward()            # 利用自动微分计算微分
# y对 x的微分值
print('shape:{0};{1}'.format(x.grad.size(),x.grad))

关于

'shape:{0};{1}'.format(x.grad.size(),x.grad)

这里，我们可能会有所遗忘

shape:{0};{1}’.format(x.grad.size(),x.grad)'
是一个字符串格式化的表达式，用于将变量的值插入到字符串中。
其中，{0}和{1}是占位符，分别表示第一个和第二个要插入的变量。

x.grad是一个张量（tensor）,x.grad.size()返回该张量的大小（即元素的个数）,
x.grad返回该张量的值。通过使用.format()方法，
可以将这两个值插入到字符串中，形成最终的结果