pytorch第四课，第五课，记录

check pytorch type

a=torch.randn(2,3)
a.type()#torch.floattensor
isinstance(a,torch.FloatTensor)
data=data.cuda()
isinstance(data,torch.cuda.DoubleTensor)

0维度 loss 1维度 bias

torch.tensor(0.1) ##dimension=0 loss
torch.tensor([1.0,2.2]) #dinmension = 1 bias tensor #具体的数值

小写tensor接受的是具体的数据

大写Tensor和FloatTensor 一般是（shape）

torch.FloatTensor(2) ## dimension = 1随机生成 元素个数，类似np.random.random
a=torch.ones(2)

2维度 Linear Input batch

a=torch.randn(3,4) #dimension 2,二维 # 随机正态分布
a=torch.FloatTensor(3,4)

3维 RNN Input Batch

a=torch.rand(1,3,4) #3维 数组 1个 3行4列的数组，随机均匀分布
a.shape

dimension=4 CNN [bchw]图片输入

a=torch.rand(2,3,28,28) #四维
a.shape
a.numel() #### number element 2328*28
a.dim() ### 4

a=torch.tensor(1)
a.dim() #### 是0

创建tensor 从numpy 导入

a=np.array([2,3.3])
torch.from_numpy(a)
a=np.ones([2,3]) # or np.ones((2,3)) is same
torch.from_numpy(a) #默认 dtype=torch.float64

uninitialized

torch.empty(2,3) #this is shape torch.empty(1) #一个一维数据
torch.FloatTensor(1,3,32,32)
torch.tensor([2,3.2]).type() ###默认 torch.FloatTensor
torch.set_default_tensor_type(torch.DoubleTensor) #修改默认数据类型
torch.tensor([2,3.2]).type() ##### this is change torch.DoubleTensor

随机初始化 和np 的方法基本一样#############

torch.rand(3,3) #### 随机均匀分布 0-1之间的值 3行3列
a = torch.randn(3,3) #### 随机正太分布
b = torch.rand_like(a)
torch.randint(1,10,(3,3)) #same as np.random.randint(1,10,(3,3))

不太直观 生成 dimension=1，长度为10的随机正太分布，10个均值为0，10个对应方差，然后需要reshape

torch.normal(mean=torch.full([10],0),std=torch.arange(1,0,-0.1))
torch.full([2,3],7) #全部赋值为7，dimension=2
torch.full([3],7)##一维向量，三个元素
torch.full([],7) #dimension =0,的标量元素

torch.arange(0,10)
torch.linspace(0,10,steps=4) #闭区间等分切 4个数字
torch.eye(3) #接受一个参数 3*3

a = torch.rand(2,3)
idx = torch.randperm(2) #乱序索引
a[idx]

a=torch.rand(4,3,28,28) #bchw
a[0].shape #torch.Size([3,28,28])
a[0,0].shape #torch.Size([28,28]) 第0张图片的第0个通道
a[0,0,2,4] #取得具体的一个元素 tensor(0.6883)

a[:2] # 前两张图片
a[:2,:1,:,:]
a[2:,-1:,:,:]
a[2:,-1:,0:28:2,0:28:2] ## 间隔是2,a[2:,-1:,::2,::2] #开始是0，长度结束，0，28可以省略
a[2:,-1:,::2,::2] #0:28:1省略：1 ，0:28 ， 0:28:2可以省 ::2

a.index_select(0,torch.tensor([0,1])) #含义对 第一个参数4，维度进行操作，取得第1和2张图片
a.index_select(1,torch.tensor([1,2])) #第二个参数 3 操作取得通后两个图片的通道
a.index_select(2,torch.arange(8)).shape ## 第三个参数28 操作，shape是4，3，8，28，变成8行，其他不变
a[…].shape #所有元素都取
a[0] ## 等于a[0,…],###hwc 都取得
a[0,…,::2] #第一张图片 所有的ch ,w列隔2 采样 等价a[0,:,:,::2]##shape (3,28,14)
a[:,1,…] #shape(4,1,28,28)
a[…,:2] #shape (4,3,28,2) #列只取得前两个

x=torch.randn(3,4)
mask = x.ge(0.5) ##greater equal >=0.5 变成1，，对应位置元素返回0，1 这种int 数据，
torch.masked_select(x,mask) #>=0.5 对应元素取得，变成一个一维度向量,相当于数据打平进行处理的，x打平，索引mask打平
torch.take(x,torch.tensor([0,2,3])) #先将元素打平，打平后的对应索引的元素，得到一维向量

区别 a.index_select，没有进行打平操作，原有数据结构上进行操作

########维度变化###########

view和reshape一样的

a=torch.rand(4,1,28,28)
a.view(4,2828) #类似全连接层参数，图片数量，每张图片得到的参数，没有维度信息
a.view(41,28,28) #表示把多张图片通道融合到一起，得到一张图片大小的数值
a.view(4,784) #
a.view(4,1,28,28) #恢复维度

Squeeze#### unsqueeze 挤压展开

a=torch.rand(4,1,28,28)
a.unsqueeze(0).shape #参数是位置，大小是0-a.dim()，-a.dim()-1__0
#######就是(-5,4),分成两部分索引操作一样，（-5，-1），对应元素之后插入，， （0，4），对应元素前面插入一个组的数字含义（记得这个就可以了）
unsqueeze没有增加改变数据本身，但是增加了一个组的信息，注意参数是在数据的shape对应的位置做插入操作。

在数据的shape,位置插入数据，实际上改变了数据的维度，原本是一维数据，数据本身不改变

应用场景， 特征维度变化一致进行相加乘积等等计算

挤压 squeeze ,去除维度，unsqueeze 扩展维度

b=torch.rand(1,32,1,1)
b.squeeze().shape ##什么参数都不写是把1 的维度都删除，

b.squeeze(0).shape #索引对应维度的数字，【1，32，1，1】，分别对应0 1 2 3

只能删除，维度是1 的，否则源数据维度shape不变

unsqueeze 和 squeeze 维度的增加和减少，变化的只是1，例如shape （32）变成（1，32，1，1），而扩展 Expand 不增加数据，repeat 增数据，是将shape （32）变成（4，32，3，3），多个数据batch c h w

expand 速度更快，节省内存，首先前后dimension一样，其次只能针对1-》N变化
b.expand(4,32,14,14),不是1的数据一样例如32

b.repeat(4,32,1,1)是对应维度的数据 重复的次数，会改变原来的数据。占用内存，不推荐

转置操作应该只针对二维度，4D 3D都是报错

a=torch.randn(3,4)
a.t() # 转置

交换 transpose ,参数对应0 1 2 3 ,shape【4，3，32，32】bchw

a=torch.randn(4,3,32,32) #bchw 对应0123
a1=a.transpose(1,3).contiguous() #cw 交换 bwhc #存储由原来的连续变得不连续了，所以加 .contiguous()

a2 = a1.view(4,33232) #（4 32 32 3 ）变成（4 3072） 图片whc 变成一个向量
a2.view(4,3,32,32) #错误操作，c=3的信息已经丢掉了，恢复不过来view和reshape 一样，， 应该和原来的顺序一样，
a3 = a2.view(4,32，32，3) #b whc
a4 = a3.transpose(1,3) #变成 bchw
view 和reshape 必须记住之前的维度信息进行展开，否则是错位的结构
例如 a2.view(4,32，32，3) #b whc 展开的维度是 whc ，数据数据合并前的 维度结构

permute 也可以用，原先的bchw 0123 ,变成0231 对应bhwc，也要contituous(),打乱的顺序存储，变成连续，不是交换的意思，是索引对应原来的bchw 位置

简化操作API

1、unsqueeze expand 合并操作broadcasting

没有broadcasting，不同维度和一维数据操作，就要先unsqueeze再expand，这是个自动操作
都是一样只针对shape是1 的进行操作，否则前者维度都没有变化，后者报错不符合规则

2、合并分割 merge or split

bchw 图片个数，图片通道，图片的行，图片给的列

cat stack 合并 split chunk 分离

cat 第一个维度直接拼接，剩下的维度相等默认dim=0,dimension 第0维度
a1=torch.rand(4,3,32,32)
a2=torch.rand(5,3,32,32)
torch.cat([a1,a2],dim=0).shape

a2=torch.rand(4,1,32,32) # 注意是不同的地方是第1维,这个维度拼接
torch.cat([a1,a2],dim=0).shape #error
torch.cat([a1,a2],dim=1).shape #图片rgb三个通道变成rgba 四个通道的tensor

a1=torch.rand(4,3,16,32)
a2=torch.rand(4,3,16,32)
torch.cat([a1,a2],dim=2).shape #两张半张图片合并成一张图片

stack 多了一个分组的概念，插入位置和unsqueeze 一样
例如两个班级的学生，成绩，[32,8] , [32,8],如果是cat直接合并一个【64，8】,如果是stack,会插入一个新的维度几组这样的数据含义 【2，32，8】

torch.stack([a1,a2],dim=2).shape### [4,3,16,32]在3 和 32 之间（dimension=2的前面）插入2（2组数据），【4，3，2，16，32】
stack 两个维度完全一样才可以，cat 需要拼接的维度可以不一样，其他维度一样

split chunk 分离

split 长度拆分
a1=torch.rand(32,8)
a2=torch.rand(32,8)
c=torc.stack([a1,a2],dim=0) #【2，32，8】
aa,bb=c.split(1,dim=0) #第 0 个维度拆分 成长度为1 的个体
aa,bb=c.split([3,2],dim=0) #长度不一样写一个长度的list ，原来5个数据，3，2拆分
aa,bb=c.split([3,1,1],dim=0) # 原来5个数据，3，1，1拆分

chunk 数量拆分，拆分成多少个的意思
#如果 0维度的长度就是2个
aa,bb=c.chunk(2,dim=0) ，拆分成两个
aa,bb=c.split(2,dim=0) ，长度2，拆分源数据，报错，不能拆成原来长度一致的，要小于，dimension =0 的维度

基本运算

例如 【4，784】fc 和权重【784，512】 矩阵乘积，得到 【4，512】降维的数据

第一个元素 列等于第二个元素行，可以矩阵乘积， 得到的维度是 第一个元素行，第二个元素的列

torch.matmul（a,b) 矩阵乘积,
等价 a@b
x=torch.rand(4,784)
w=torch.rand(512,784) # pytorch 的W 第一个是输出，第二个是输入，所以，顺序不要写错了,转置
（ [email protected]() ）.shape #[4,512], 多维度转置用transpose

torch.mm(a,b)
#只能对2D 进行矩阵乘积，一般用torch.matmul()
如果是多维的数据就是最后两个维度计算，前面维度保持不变，所以结果会错，虽然不报错
但是 bchw ,如果正好bc 不变，只进行 hw 计算可以直接用torch.mm(a,b))

a=torch.full([2,2],3)
a.pow(2)
a.pow(3) #3次方
a2
a3
a.sqrt() #开平方 a0.5
a.rsqrt()#开立方a(1/3.0)

torch.exp(torch.ones(2,2))
torch.log(a) ##默认e 底 得到 torch.ones(2,2)的值

torch.log2(a)
torch.log10(a)

剪裁梯度的值 clamp

for w in []:
clamp(w.grad,10)

统计方法 API

1、norm 范数 不是normalize 正则化
有两个参数，a.norm(1,dim=1),1 是计算的指数，绝对值的和，2，绝对值的平方和之后再根号，取哪个维度的范数，那个维度就消失
a.norm(1) #没有dimension 参数，不管多少维度都是所有数据求和开根号，得到一个值

三个最后的维度都是对内部数据进行操作
dimension =1，列元素相加，类似二维向量操作axis=0,行的方向列元素加
dimension =2，行元素相加变成一个向量，类似二维向量操作axis=1，列的方向，行元素加
dimension=0 的元素相加注意，如下