2021.12.09 pytorch

pytorch

## torch.randn
x = torch.randn(4, 3)
# 沿着行取最大值,dim为索引

max_value, max_idx = torch.max(x, dim=0)
# 每一行的最大值
max_value
# 每一行最大值的下标
max_idx

# 沿着行对 x 求和
sum_x = torch.sum(x, dim=1)
print(sum_x)

## unsqueeze和squeeze
x = x.unsqueeze(2) # 在第三维增加1
x = x.unsqueeze(1) # 在第二维增加1
x = x.squeeze(1) # 减少第二维
x = x.squeeze() # 将 tensor 中所有的一维全部都去掉

## permute和transpose
#使用permute和transpose进行维度交换
x = torch.randn(3, 4, 5)
# permute 可以重新排列 tensor 的维度，变成[4,3,5]
x = x.permute(1, 0, 2)
# transpose 交换 tensor 中的两个维度，变成[5,4,3]
x = x.transpose(0, 2)

## view
#使用 view 对 tensor 进行 reshape
x = torch.randn(3, 4, 5)
x = x.view(3,-1,2) # -1 表示任意的大小，3 表示第0维变成 3
print(x.shape)
#torch.Size([3, 10, 2])

#直接对 tensor 进行操作而不需要另外开辟内存空间，，一般都是在操作的符号后面加_
x = torch.ones(3, 3)
x.unsqueeze_(0)#torch.Size([1, 3, 3])
x.transpose_(1, 0)#torch.Size([3, 1, 3])

#Variable
from torch.autograd import Variable

#标量求导
x = Variable(torch.Tensor([2]), requires_grad=True)
y = x + 2
z = y ** 2 + 3
print(z)#19
# 使用自动求导
z.backward()
print(x.grad)#8

#矩阵求导
x = Variable(torch.randn(10, 20), requires_grad=True)
y = Variable(torch.randn(10, 5), requires_grad=True)
w = Variable(torch.randn(20, 5), requires_grad=True)
# torch.matmul 是做矩阵乘法
out = torch.mean(y - torch.matmul(x, w)) 
out.backward()
# 得到 x 的梯度
print(x.grad) 
通过调用 backward 我们可以进行一次自动求导，如果我们再调用一次 backward，会发现程序报错，这是因为 PyTorch 默认做完一次自动求导之后，计算图就被丢弃了，所以两次自动求导需要手动设置
x = Variable(torch.FloatTensor([3]), requires_grad=True)
y = x * 2 + x ** 2 + 3
print(y)  #18
y.backward(retain_graph=True) # 设置 retain_graph 为 True 来保留计算图
print(x.grad)#8
y.backward() # 再做一次自动求导，这次不保留计算图
print(x.grad)
#16。因为这里做了两次自动求导，所以讲第一次的梯度 8 和第二次的梯度 8 加起来得到了 16 的结果

optimizer.zero_grad() # 使用优化器将梯度归 0
loss.backward()
optimizer.step() # 使用优化器来更新参数

## 继承Dataset类
class MYdata(Dataset):
	def __init__(self,a,b):
		self.a=a
		self.b=b
	def __len__(self):
        return len(self.a)
	def __getitem__(self,idx):
		?
		?
		return a,b,c,d
#调用	
dataSet_dict = MYdata(a, b)
#调用可以重构的函数
len(dataSet_dict)
a,b,c,d=getitem(dataSet_dict[idx])
dataLoader_dict = DataLoader(dataSet_dict, batch_size=args.batch_size,参数等 )

## tensorboard
from torch.utils.tensorboard import SummaryWriter
writer=SummaryWriter("logs")#保存路径
for i in range(100):
    writer.add_scalar("y=x",i,i)#名字，y，x
writer.close()
writer.add_image("名字"，图片矩阵，数字)
tensorboard --logdir logs#命令行，查看图像

## 常用的数据类型
torch.FloatTensor
troch.DoubleTensor
torch.ByteTensor
torch.IntTensor
torch.LongTensor
torch.cuda.FloatTensor
troch.cuda.DoubleTensor
torch.cuda.ByteTensor
torch.cuda.IntTensor
torch.cuda.LongTensor

a.type()返回torch.FloatTensor
type(a)返回torch.Tensor
isinstance(a,torch.FloatTensor)返回True或者False

## 标量：
一般用于loss
a=torch.tensor(2.2)

## 向量：
一般用在偏置b的表示，线性层的输入
torch.EloatTensor(2)生成一个长度为2的向量，数据是随机生成的。形式是tensor([3.212e-25,6.5e-20])

data=np.ones(2)
torch.from_numpy(data)生成长度为2，数据为1.1的向量。为tensor([1.,1.])

## dim为2的
带有偏置的线性层的输入
a=torch.randn(2,3)

## dim为3的
rnnd的输入
a=torch.rand(1,2,3)

## dim为4
图片的输入
a=torch.rand(2,3,28,28)

创建tensor

a.np.array([2,3.3])
torch.from_numpy(a)

torch.tensor([2.,3.3])现成数据
torch.Tensor(2,3)#shape
torch.FloatTensor([2.,3.3])现成数据
torch.FloatTensor(2,3)#shape

改变Tensor的默认数据类型,原始默认是FloatTensor
torch.set_default_tensor_type(torch.DoubleTensor)

随机初始化
torch.rand(shape) 为[0,1]均匀分布
torch.randn(shape) 为[0,1]是标准正态分布，均值为0，方差为1
torch.rand_like(a)生成和a一样分布，一样大小的
torch.randint(1,10,[3,3]),生成最小为1，最大不超过10的3*3的整型
torch.fall([shape],number)例如torch.fall([2,3],0)生成2*3全为0的

torch.arrange(min,max,steps)生成等差，不包括max
torch.linspace(min,max,num)生成num个数，从min到max（包括）等差
torch.logspace(min,max,steps,base)生成steps个已base（默认为10）为基地的log（10）min-max的数据
torch.ones(shape)全0
torch.zeros(shape)全1
torch.eye(shape)对角线1，其余0

## 切片和索引
a=torch.Tensor(4,2,28,28,28)
a[1:2(1到2采样) , :1（0到1采样） , 0:28:2（0到28隔行采样） , -1:20（28，0，到20采样） , ::2（0到28隔行采样）]    （start：end：step）

a.index_select(维度，多少(需要是tensor)，)
a.index_select(2,torch.arrange(8))此时shape为（4,2,8,28,28）

a[2:,1,...,10:]此时shape为(2,1,28,28,18)

## 维度变换
a=torch.rand(4,1,28,28)

view和reshape，相同的
a.view(4,28*28)
a.reshape(4,28*28)

维度增加维度减少
squeeze和unsqueeze(插入一个维度) 相反的
a.unsqueeze(1[范围在0到4]),在第1维之前插入一个维度，成为(4,1,1,28,28)
a.unsqueeze(-2[范围在-1到-5])在第负3维度之后插入一个维度，成为(4,1,28,1,28)

a.squeeze(1)成为(4,28,28)
a.squeeze()不给参数会压缩所有dim为1的维度

维度扩展
expand（不增加数据）和repeat（拷贝数据）
b=torch.rand(1,32,1,1)
c=torch.rand(4,32,14,14)

b.expand(4,32,14,14)
b.expand(-1,32,14,-1)成为(1,32,14,1),-1不改变
b.expand(4,33,14,14)不可以进行操作，只可以将1变为n，大于1的不可进行操作

b.repeat(4,32,1,1)变成(4,1024,1,1)在每个维度上进行拷贝的倍数

转置
d.t()只能对矩阵进行操作shape为(a,b)

transpose交换两个指定的维度
a.transpose(1,3)成为(4,28,28,1)，存在一个问题，原先的28*28是长宽，进行维度交换后是宽长

permute进行维度交换
a.permute(0,2,3,1)成为(4,28,28,1)此时28*28仍然是长宽，与transpose的28*28不同

## 合并与分割
cat合并
a=torch.rand(4,32,8)
b=torch.rand(5,32,8)

torch.cat([a,b],dim=0)合并后为(9，32，8)

stack创建一个新的维度
a1=torch.rand(4,3,16,32)
a2-torch.rand(4,3,16,32)
torch.stack([a1,a2],dim=2),shape变为(4,3,2,16,32)
a1=torch.rand(16,32)
a2-torch.rand(16,32)
torch.stack([a1,a2],dim=0),shape变为(2,16,32)

split根据长度进行拆分
a=torch.rand(8,32,32)

a1,a2=a.split(4,dim=0)拆分后为(4,32,32)和(4,32,32)
a1,a2=a.split([1,7],dim=0)拆分后为(1,32,32)和(7,32,32)

chunk按数量进行拆分
a=torch.rand(8,32,32)

a1,a2=a.schunk(2,dim=0)拆分后为(4,32,32)和(4,32,32)

## 运算
矩阵相乘
只对最后两维度进行运算
torch.matmul(a,b)
a@b

a=torch.rand(8,1,32,24)
b=torch.rand(8,1,24,64)
c=torch.rand(8,3,24,64)
a@b的shape为(8,1,32,64)
a@c的shape为(8,3,32,64)会进行广播

pow(a,n)求a的n次方
a.sprt()求a的次方
a.rsqrt()求a的倒数
torch.exp(a)求e的a
torch.logn(a)求logn的a，默认n为e

取整
a=torch.tensor(3.14)
print(a.floor())向下取整3
print(a.ceil())向上取整4
print(a.trunc())取整数3
print(a.frac())取小数0.14
print(a.round())四舍五入3

clamp进行数据限制
clamp(a,min)将a中的数据限制在min以上，小于min的会替换为min
clamp(a,min,max)将a中的数据限制在min到max，不符合要求的进行替换

dim和keepdim
argmax
argmin
topk(num,dim,largest=True)求dim维度上最大（默认为最大，最小改为False）的前num个数字

torch.where()
c=torch.tensor([[0.6,0.4],[0.8,0.7]])
a=torch.ones_like(c)
b=torch.zeros_like(c)
print(torch.where(c>0.5,a,b))输出为tensor([[1., 0.],[1., 1.]])

gather两个表的映射。将idx映射为label中的元素，idx的第0个是label中的第0个元素就是2，进行映射
idx=torch.tensor([[0,5,3],[2,5,4],[3,1,2],[1,2,3],[2,5,0]])
label=torch.tensor([2,6,1,4,8,3])
a=torch.gather(label.expand(idx.shape[0],label.shape[0]),dim=1,index=idx)
print(a)输出为tensor([[2, 3, 4],[1, 3, 8],[4, 6, 1],[6, 1, 4],[1, 3, 2]])

#初始化，对训练有帮助
torch.nn.init.kaiming_normal_(w1)
torch.nn.init.kaiming_normal_(w2)
torch.nn.init.kaiming_normal_(w3)

visdom用于可视化，
python -m visdom.server获得网页

#L2正则化,动量
device=torch.device('cuda:0')
net=MLP().to(device)
optimizer=optim.SGD(net.paramaters(),lr=learning_rate,weight_decay=0.01，momentum=args.momentum)#l2正则化weight_decay,动量momentum=args.momentum
criteon=nn.CrossEntropyLoss().to(device)

bs#L1正则化
regularization_loss=0
for param in model.paramaters():
  regularization_loss+=torch.sum(torch.abs(param))#求绝对值相加
classify_loss=criteon(logits,target)
loss=classify_loss+0.01*regularization_loss
optimizer.zero_grad() # 使用优化器将梯度归 0
loss.backward()
optimizer.step() # 使用优化器来更新参数