Pytorch基础语法

Pytorch入门学习（第一周）

目标：使用pytorch实现数据预处理，模型构建，模型训练，完成NLP,CV子任务等。

---

一、张量类型检查，维度，生成

1.数据类型：

Int —> IntTensor —> torch.IntTensor —> torch.cuda.IntTensor
Float —> FloatTensor —> torch.FloatTensor —> torch.cuda.FloatTensor
Double —> DoubleTensor —> torch.DoubleTensor —> torch.cuda.DoubleTensor
Byte —> ByteTensor —> torch.ByteTensor —> torch.cuda.ByteTensor

2.类型检查：

a.type() 返回’torch.xxxTensor’，返回具体数据类型
type(a) 返回’torch.Tensor’，不返回具体数据类型
isinstance(a,torch.floatTensor) ，返回True or Flase
a.cuda() —>放入cuda，torch.FloatTensor—>torch.cuda.FloatTensor

3.张量维度：

a.shape 返回torch.size()，shape为成员变量
a.size() 返回torch.size()，size()为成员函数
a.dim() 返回a的维度

4.张量生成：

直接定义：

torch.tensor([1,1])，torch.FloatTensor([1,1])，torch.tensor(1)

类型转换：

torch.from_numpy(data)，data为numpy数据类型

随机生成：

torch.rand(dim_1,dim_2,…)，随机[0,1)
torch.randn(dim_1,dim_2,…)，随机[0,1)的正态分布

其他方法：

a.numel()，计算总大小
.xxxTensor()，用于接收维度（给shape）OR 现成数据(少用)
.Tensor()，用于接收现成数据（给List）
.empty()，未初始化数据
.set_default_tensor_type()，设置默认tensor类型
.rand_like()，模仿形状
.randint()，随机Int
.normal(mean=torch.full([10],0),std=torch.arange(1,0,-0.1))，指定均值和方差的随机张量
.full(size=,value=)，.arange()，
.linespace(0,10,steps=11)，.logspace(0,1,steps=10)，生成指定函数空间数据，可指定步长
.randperm(10)，相当于shuffle但可以保持配对

二、索引与切片

假设：a = torch.rand(4,3,28,28)，图片样本数据
a[0]第一张图片，a[0,0]第一张图片的R通道，a[0,0,0]第一张图片上的R通道上的像素点
a[:2]前两张图片，a[:2,:1,:,:]前两张图片R通道上的所有数据，
a[:2,1:,:,:]前两张图片G,B通道上的所有数据

a[:,:,0:28,0:28:2]隔行隔列采样，a[:,:,::2,::2]（省略用法）

a.index_select (0,torch.tensor([0,2]))，具体采样
a.index_setect(1,torch.tensor([1,2]))，第二张图片的G,B通道
a[0,…]，torch.size([3,28,28])
a[…]，torch.size([4,3,28,28])
a[:,1,…]，torch.size([4,28,28])
a[…,:2]，torch.size([4,3,28,2])

.masked_select(a,mask)，默认打平（flatten）
mask=a.ge(0.5)–mask返回ByteTensor类型
.take(a,torch.tensor([0,2,5]))，同样打平后按索引取值

---

三.维度变换

1.view/reshape

两者用法一致，变换时需保持 prod(a.size) = prod(b.size)，其次也要符合物理意义
例如：b.view(4,28,28,1) --> b.view(4,1,28,28)虽然能够变换，但丢失了物理意义

2.Squeeze/unsqueeze

b.squeeze()，自动压缩所有维度矩阵数为1的维度，不为1则无变化
b.squeeze(0)，指定某一维度压缩（也只能压缩维度矩阵数为1的维度）

a.unsqueeze(0).shape --> torch.size([1,4,1,28,28])
a.unsqueeze(-1).shape -->torch.size([4,1,28,28,1])
两个不同维度的数据相加：
f = torch.rand(4,32,14,14)
b = torch.rand(32)
b.unsqueeze(1).unsqueeze(2).unsqueeze(0) —>torch.size([1,32,14,14])后续需要expand操作才能相加

3.Transpose/t/permute

Transpose

transpose()接收两个参数，表示需要交换的两个维度
使用前需要将数据变为连续，使用contiguous()操作，因为transpose默认是在原数组上进行操作，需要进行contiguous()深拷贝后，再view为交换后的tensor形状。
例如：b = a.transpose(1,3).contiguous().view(4,33232).view(4,32,32,3).transpose(1,3)
eq(a,b) ----> True

t

仅可适用于2D tensor （矩阵）
.t()即可完成转置（twist）

permute

permute可以一次进行多次交换，参数个数与张量维度数相同
例如：.permute(0,2,3,1)

4.Expand/repeat

b:[1,32,1,1]

Expand

不增加数据（节省内存）。参数为扩展之后的形状，前后不为1的维度必须相等否则报错！
b.expand(4,32,14,14)，b:[1,32,1,1] —> [4,32,14,14]

repeat

用已有数据拷贝后，填充新位置。参数为每个维度需要拷贝的次数
b.repeat(4,32,1,1)，b:[1,32,1,1] —> [4,1024,1,1]

5.broadcasting

官方文档描述：
1.insert 1 dim ahead
2.Expand dims with size 1 to same size
if current dim=1 ,expand to same
if either has no dim, insert one dim and expand to same
otherwise, not broadcasting-able
(match from last dim)

“小维度指定，大维度随意”，对于要操作的两个张量，从尾部开始向前匹配，维度为1则扩展到相同，维度不存在则添加一个维度1扩展至相同维度，如果维度存在且不为1也不像同则无法自动扩展

四.合并与分割

1.合并

cat

使用条件：合并维度以后的维度值需要一致

a = torch.rand(4,32,8)        
b = torch.rand(5,32,8)
torch.cat([a,b],dim=0).shape
---->torch.size([9,32,8])

stack

将两个张量按维度拼接，如果需要再dim=2上进行stack，则会在dim=2上添加一个矩阵数为2的维度

a = torch.rand(4,3,16,32)        
b = torch.rand(4,3,16,32)
c1 = torch.cat([a,b],dim=2)
c2 = torch.stack([a,b],dim=2)

c1:torch.size([4,3,32,32])
c2:torch.size([4,3,2,16,32])

当维度不一样时，只能使用cat

2.分割

split

按长度拆分(by len)，split(split_len,dim)，需要两个参数：拆分的长度和需要拆分的维度
如果拆分成一样的长度则给定统一的长度，如果拆分成不同的长度则给予存储拆分长度的list
例如：
5 —> 3 2 split([3,2],dim=)
6 —> 3 3 split(3,dim=)

chunk

按数量拆分(by nums)，chunk(chunk_num,dim)，需要两个参数：拆分的数量和需要拆分的维度
如果拆分的维度值刚好够整除拆分的数量则拆分后该维度数相同，如果不够则最后一个为余数
例如：
a.shape —> torch.size([3,28,8])
a.chunk(2,dim=0) —> torch.size([2,32,8])，torch.size([1,32,8])

五.数学运算

matmul or @

.matmul 矩阵相乘（matrix x）

a = ([4,3,28,64])
b = ([4,1,64,32])
torch.matmul(a,b).shape ---> ([4,3,28,32]) #这里默认使用了broadcasting

*(数值相乘)

element-wise

.pow() .sqrt() .log()

.floor() 向下取整 .ceil()向上取整

.trunc()取整数部分 .frac()取小数部分 .round()四舍五入

六.统计属性

范数norm-p

.norm(i,dim=j)
norm()的两个输入参数，在第j个维度上取norm-i范数

mean，sum，min，prod(累乘)

argmax()，argmin()，max()，min()

argmax(dim=,keepdim=)与argmin(dim=,keepdim=)不指定维度会自动flatten向量，对哪个维度求哪个维度就会消掉，可以设置keepdim=True保持维度不变，max()会返回最大值和最大值元素位置，argmax()只会返回最大值元素位置

Top-k or k-th，.eq(a,b)，.equal(a,b)

.topk(i,dim=j)在第j维度取前i大的值
.kthvalue(k,dim=j)在j维度取前k小的值
.eq(a,b)返回ByteTensor矩阵
.equal(a,b)返回True or False

七.进阶操作

1.where

torch.where(condition,x,y) —> Tensor
cond为条件矩阵，condition元素为一是选取x对应标号的元素，零则选择y对应标号的元素
例如：torch.where(cond>0.5,a,b)

2.gather

toch.gather(input,dim,index)，
当dim=0时代表index的索引为行号，index的元素所在列锁定列号，由index当前元素值确定第几行来索引元素
当dim=1时代表index的索引为列号，index的元素所在行锁定行号，由index当前元素值确定第几列来索引元素
例如：

input:
 tensor([[ 0,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  9],
        [10, 11, 12, 13, 14]])
index:
 tensor([[1, 0, 0, 0, 0],
        [0, 0, 1, 2, 1]])
dim=0时:
 tensor([[ 5,  1,  2,  3,  4],
        [ 0,  1,  7, 13,  9]])

dim=0，锁定列，索引行
index第一个元素在第一列，值为1，则索引input第一列第二行，其值为5
index第二个元素在第二列，值为0，则索引input第二列第一行，其值为1
index第三个元素在第三列，值为0，则索引input第三列第一行，其值为2
…
index第二行第一个元素在第一列，值为0，则索引input第一列第一行，其值为0
…
index第二行第三个元素在第三列，值为1，则索引input第三列第二行，其值为7
…以此类推

input:
 tensor([[ 0,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  9],
        [10, 11, 12, 13, 14]])
index:
 tensor([[1, 0],
        [0, 0],
        [1, 2]])
dim=1时:
 tensor([[ 1,  0],
        [ 5,  5],
        [11, 12]])

dim=1，锁定行，索引列
index第一个元素在第一行，值为1，则索引input第一行第二列，其值为1
…
index第三行第二个元素，值为2，则索引input第三行第三列，其值为12
…以此类推

总结

标题说的pytorch的基础语法其实是对Tensor的基础操作。
对于范数而言小节所说的范数计算式是次要的，更重要的是范数的相关应用，如均方差损失函数等等，应该会写入后几周的笔记。
下周详细实践一下激活函数，损失函数，梯度传播以及动量学习率衰减等神经网络基础知识的应用。