pytorch学习笔记

1、基本数据类型

import torch
from torch.autograd import Variable
import numpy as np
import time

#一基本数据类型，IntTensor，FloatTensor与python中的int，float对应，对应的array与Tensor的size对应
'''
#CPU版本,下边生成的是维度为1的矩阵，而非标量数据
a=torch.FloatTensor(1)#32位浮点型
b=torch.DoubleTensor(1)#64位浮点型
c=torch.IntTensor(1)#32位整型
d=torch.LongTensor(1)#64位整型
e=torch.ByteTensor(1)
print(a,a.shape,'\n',b,'\n',c,'\n',d,'\n',e)
#GPU版本
g_a=torch.cuda.FloatTensor(1)
g_b=torch.cuda.DoubleTensor(1)
g_c=torch.cuda.IntTensor(1)
g_d=torch.cuda.LongTensor(1)
g_e=torch.cuda.ByteTensor(1)
print(g_a,'\n',g_b,'\n',g_c,'\n',g_d,'\n',g_e)

#tensor合法化格式检查
a=torch.randn(2,3)
b=isinstance(a,torch.FloatTensor)
print(a,'\n',a.type(),'\n',type(a),'\n',b,'\n',
      a.size(),'\n',a.shape)
a=a.cuda()#将数据布置到cuda上
b=isinstance(a,torch.cuda.FloatTensor)
print(a,b)

#标量,可用于计算loss,维度为0
a=torch.tensor(1.3)

print(a,'\n',a.type(),'\n',type(a),'\n',
      a.size(),'\n',a.shape,'\n',
      len(a.shape))

#rank=1,可用在bias,linear input
a=torch.tensor([1.2])
b=torch.tensor([1.2,3])
c=torch.tensor([[1,2],[2.2,3]])
print(a,'\n',a.shape,'\n',b,'\n',b.shape,'\n',
      c,'\n',c.size())
data=np.ones(2)
tor_data=torch.from_numpy(data)
print(torch.__version__)

#rank=2,带有batch的linear input batch
a=torch.randn(2,3)
b=torch.FloatTensor(2,3)
print(a.size(),'\n',a.size(0),'\n',a)
print(b.size(),'\n',b,'\n',b.shape[1])
c=a.shape
print(type(c))

#rank=3,用于序列模型，RNN等
a=torch.randn(1,2,3)
b=torch.FloatTensor(3,3,3)
print(a,'\n',a.shape,'\n',a.size(2),'\n',
      b,'\n',list(b.shape))

#rank=4,用于多通道的图片处理，CNN模型
a=torch.randn(5,3,28,28)
print(a,'\n',list(a.shape))
#数据个数
print(a.numel(),a.dim())
'''

2、可用于GPU加速

print(torch.__version__)
print('GPU',torch.cuda.is_available())

#基本数据类型，与numpy的转化
np_data=np.arange(6).reshape(2,3)
# print(type(np_data))
torch_data=torch.from_numpy(np_data)
torch_numpy=torch_data.numpy()
print(np_data,"\n",
      torch_data,"\n",
      torch_numpy)

#基本操作，abs、sin
data=[-1,2,-3,-3]
print(type(data))#这里是简单的list类型
torch_opera=torch.FloatTensor(data)#对于list对象与tensor的转换，需要用FloatTensor
# torch_opera=torch.FloatTensor(data)
print(np.abs(data),torch_opera.abs())
print(np.sin(data),torch_opera.sin())
print(np.mean(data),torch_opera.mean())

#多维矩阵的运算
tensor=torch.FloatTensor([[1,2],[3,4]])
v_data=Variable(tensor,requires_grad=True)
# print(tensor,v_data)
# ten_result=tensor.mm(tensor)
ten_result=torch.mean(tensor*tensor)
v_result=torch.mean(v_data*v_data)
v_result.backward()
print(ten_result,v_data.grad)
print(ten_result,v_data.data.numpy())

data=torch.FloatTensor([[1,2],[1,2]])
i_data=torch.eye(3)
o_data=torch.ones(1,5)
one_data=torch.ones(5)#默认是5X1的矩阵
print(torch.numel(data))
print(i_data)
print(i_data)
print(o_data,one_data)

# pytorch可用于GPU加速
print(torch.cuda.is_available())
a=torch.randn(10000,3000)
b=torch.randn(3000,3000)
#普通矩阵乘法
t1_start=time.time()
mm=torch.matmul(a,b)
t1_end=time.time()
t_total=t1_end-t1_start
print('CPU',t_total)
# GPU加速乘法
device=torch.device('cuda')
a=a.to(device)
b=b.to(device)
t2_start=time.time()
mm=torch.matmul(a,b)
t2_end=time.time()
t2_total=t2_end-t2_start
print('GPU',t2_total)

t2_start=time.time()
mm=torch.matmul(a,b)
t2_end=time.time()
t2_total=t2_end-t2_start
print('GPU',t2_total)
'''

3、创建tensor的方法

#1 从Numpy中引入,引入默认是int型和double型
a=np.array([2,3,3])
b=torch.from_numpy(a)
print(b,'\n',b.shape,'\n',b.numel(),'\n',b.type())
c=np.ones([3,5])
d=torch.from_numpy(c)
c=isinstance(d,torch.DoubleTensor)
print(d,'\n',d.shape,'\n',d.numel(),'\n',d.type(),c)

#2 直接从List中引入，默认是long型和float型
a=torch.tensor([2,3])
b=torch.tensor([2.3,4])
print(a.type(),'\n',b.type())

#tensor和Tensor的区别,tensor接现成的数据，Tensor接维度生成随机数
a=torch.tensor([1])
b=torch.Tensor(1)
c=torch.FloatTensor(1)
d=torch.Tensor([[1,2],[4,7]])#此处也可用Tensor接具体的数，但为避免混淆，用tensor接具体数据，Tensor接维度
print(a,b,c,d)

#3 预先生成空占位符,未初始化数据
a=torch.empty(1)
b=torch.FloatTensor(2,3)
c=torch.IntTensor(2,3)
print(a,'\n',b,'\n',c)

#tensor和Tensor的默认类型
a=torch.tensor([1,2,3])#默认为long
b=torch.Tensor(2,3)#默认为float,所以等价于torch.FloatTensor
# c=torch.set_default_dtype(torch.DoubleTensor)
d=b.type(dtype=torch.DoubleTensor)
print(a.type(),b.type(),d.type())

#4 随机初始化
a=torch.rand(3,3)#取值在[0,1]
b=torch.rand_like(a)#随机初始化与a维度一致的张量
c=torch.randint(1,10,[3,3])#min,max,维度
d=torch.randn(3,3)#均值为0，方差为1
e=torch.normal(mean=0.5,std=torch.arange(1,0.1,-0.1)).reshape(3,3)
print(a,b,c,d,e)

#5 设置整个矩阵都为某个数
a=torch.full([3,5],8)
b=torch.full([],5)#生成标量
c=torch.full([1],5)#生成有一个元素的向量
print(a,b,c)

a=torch.arange(0,10,2)#不包括右节点，不使用range
b=torch.linspace(0,10,steps=10)#表示生成多少个数
c=torch.logspace(0,10,steps=10,base=2)#返回的是以2为底，b为指数
d=torch.zeros(3,3)
e=torch.eye(3)#等价于eye(3,3)
f=torch.ones(3,3)
g=torch.ones_like(f)
h=torch.zeros_like(f)
print(a,'\n',b,'\n',c
      , '\n',d,'\n',e,'\n',f,'\n',
      g,'\n',h)

#6 随机打散tensor数列,可用于协同shuffle数据和标签
a=torch.randperm(10)
print(a.numel())

a=torch.randn(3,4)#表示三个人4次考试的数学成绩
print(a,a[0])
b=torch.arange(1,4)#表示三个人的总排名
print(b)
id=torch.randperm(3)#打乱三个人的顺序
a=a[id]
b=b[id]
print(id,'\n',a,'\n',b)

4、切片与索引

#像在python中直接索引
a=torch.randn(5,3,28,28)
# print(a[0].shape,'\n',a[0].numel()
#     , '\n',a[0][0],'\n',
#       a[0][0][1][3])
b=a[:3]#表示从0到2，不包括第四个
c=a[:2,1:,:,:]
e=a[:2,:1,:,:]
f=a[:2,-1:,:,:]#从最后一个开始，-1表示最后一个字母的索引
g=a[:2,-2:,:,:]#从倒数第二个开始
h=a[:2,-3:,:,:]#从最倒数第三个开始
# print(b,'\n',b.size())
# print(c,'\n',c.size())
# print(e,'\n',e.size())
# print(f,'\n',f.size())
# print(g,'\n',g.size())
# print(h,'\n',h.size())

#隔行采样
i=a[:,:,0:26:3,:]#表示第0到第27，不包含第27，每隔3个取一次样，默认的是隔一行取样一次
# print(i,'\n',i.size())
#给特定的索引进行采样
p=a.index_select(0,torch.tensor([0,2]))#第一个参数表示进行采样的维度数，第二个参数表示要采样的索引
# print(p,'\n',p.size())
q=a.index_select(2,torch.arange(8))
# print(q,'\n',q.size())
#...
q=a[:,1,...]
# print(q,'\n',q.size())
#mask
x=torch.rand(3,5)
mask=x.ge(0.5)
y=torch.masked_select(x,mask)
print(x,'\n',mask,'\n',y)

5、tensor维度变换

#view reshape,会破坏数据，难以恢复
a=torch.rand(4,1,28,28)
b=a.view(4,28*28)
c=a.view(4*28,28)
print(a.shape,b.shape,c.shape)

#Squeeze,unsqueeze
a=torch.randn(1,8,28,28)
b=a.unsqueeze(0)#把维度展开，增加维度，给哪个维度插入,索引是几，就增加第几个维度
c=a.unsqueeze(-1)
d=torch.randn(8)#把d作为偏置值，加在a上
d=d.unsqueeze(0).unsqueeze(2).unsqueeze(3)
# print(a.shape,'\n',b.shape,'\n',c.shape,'\n')
# print(d,d.shape)
e=a.squeeze()#把维度是1的给挤压掉
f=d.squeeze()
print(e.shape,f.shape)

#Expand,repeat
#expand,只是改变数据维度；repeat改变了数据的数目，推荐使用expand
a=torch.randn(4,32,14,14)
b=torch.randn(1,32,1,1)
c=b.expand(4,32,14,14)#操作仅限于从1变为N
d=b.expand(-1,32,-1,-3)#此处-3没有意义，-1表示不变
print(c.shape)
print(d.shape)
#不建议使用repeat
e=b.repeat(4,1,14,14)#表示要在每个维度重复多少次
print(e.shape)

a=torch.randn(2,3)
b=a.t()#只适用于2维操作
# print(a,b,a.shape,b.shape)
c=torch.randn(3,4,6)
d=c.transpose(0,2)#适用于多维矩阵，参数为要交换的维度索引
print(c.shape,d.shape)

#permute，推荐使用
a=torch.randn(5,28,6,28)
b=a.permute(0,2,1,3)#索引为放置原来的维度
print(a.shape,b.shape)