pytorch——不用包模拟简单线性预测，数据类型，创建tensor，索引与切片

常见的学习种类

 

线性回归，最简单的y=wx+b型的，就像是调节音量大小。逻辑回归，是否问题。分类问题，是猫是狗是猪

最简单的线性回归y=wx+b

目的：给定大量的（x,y）坐标点，通过机器学习来找出最符合的权重w和偏置b

损失指的是每个点进行wx+b-y然后平方累加，是用来估量模型的预测值f(x)与真实值Y的不一致程度。

根本的方法是首先要给出人工设定初始的w和b值，然后计算损失对于w和对于b的梯度，来找到下降梯度。

使得w和b往下降梯度变化来使得损失越来越小，w和b的值越来越精确的过程。

lr是学习效率，人为设定的值，学习效率乘以损失在w和b上的倒数相当于是下一代w和b所走的步长

通过迭代来使w和b往下降方向走，且每一次更新w‘和b'的值然后计算损失再迭代。

红字手写计算出w和b的更新值（w和b的倒数）得公式

对于手写数字的识别

 

对于数字1的正确对应的是[0,1,0,....,0]对于数字3正确对应的是[0,0,0,3,0,.....,0]

pytorch数据类型与创建tensor

import torch
import numpy as np
a=torch.tensor(3.33)
print(a)
print(a.type())  #使用type()来查看当前的数据类型
print(isinstance(a,torch.FloatTensor)) #查看是不是浮点型的
#注意数据类型是分cpu型和gpu型号的，不同的是不同的

#生成标量，维度是0的
b=torch.tensor(2.2)
print(b.shape)
print(b.size())

#生成向量，维度为1的
c=torch.tensor([2.2])
print('一维向量且只有一个元素',c)
c=torch.tensor([2.2,3.3,4.4])
print('一维向量3个元素',c)
c=torch.FloatTensor(1)
print('随机生成一维向量1个元素',c)
c=torch.FloatTensor(2)
print('随机生成一维向量两个元素',c)
numpydata=np.array([1,2,3])
c=torch.from_numpy(numpydata)
print('从numpy导入',c)

#生成向量，维度为2的  (二维的应用场景，比如(2,3)表示的是有两个数字，每个数字用一个三维向量表示)
d=torch.randn(2,3) #正态分布生成2行3列的浮点数阵
print(d)
print(d.size())
print('注意,size可以索引',d.size(0))

#生成向量，维度为3的 （三维德应用场景比如（3，3，3）。一个句子有有三个字，然后有三个句子，每一个字用一个三维向量表示）
e=torch.rand(3,3,3) #正态分布生成3行3列的浮点数阵
print(e)
print('注意,e可以索引',e[0])
#可以用list直接把e.shape转成

#生成向量，维度为4的 （四维德应用场景图片比如（3,3,4,4）。有三张照片，每个照片有三个通道（rgb），然后每一个通道的长宽是4*4）
f=torch.rand(2,2,4,4) #正态分布生成3行3列的浮点数阵
print(f)

#获取具体元素个数，所占大小
print(e.numel())
#获取维度
print(e.dim())
#torch.tensor()里面直接给numpy的数据
#torch.FloatTensor()里面给shape的形式如torch.FloatTensor(2，3)

#生成未初始化的
# 推荐使用的是torch.FloatTensor()类型，比如
cd=torch.FloatTensor(2,2,4,4)
print('这里是FloatTensor生成未初始化的',cd)
#推荐使用的是torch.IntTensor()类型，比如
cd=torch.IntTensor(2,2)
print('这里是IntTensor生成未初始化的',cd)

#设置成更加高精度的tensor类型
torch.set_default_tensor_type(torch.DoubleTensor)
#0---1之间生成随机数
a=torch.rand(3,3)
#把a的shape读出来然后再放进torch.rand
torch.rand_like(a)
#区间之间生成随机数
sd=torch.randint(1,9,(3,3))
print(sd)
#使用torch.normal生成,mean=torch.full([10],0)代表生成10个为0的数。std=torch.arange(1,0,-0.1)代表生成数的方差从1到0每次减0.1
# pc=torch.normal(mean=torch.full([10],0),std=torch.arange(1,0,-0.1))
# print(pc)

#生成全部为某个数的tensor
print(torch.full([2,3],5))
#arange生成区间内的数
print(torch.arange(0,10,2))
#linspace等分生成区间内的数,4为切成四块
print(torch.linspace(0,10,4))
#生成全部是1的
print(torch.ones(3,3))
#生产全部是0的
print(torch.zeros(3,3))
#生成对角阵
print(torch.eye(3,3))
#随机打乱生成区间
print('randperm打乱',torch.randperm(10))

 索引与切片

import torch
import numpy as np

a=torch.rand(3,3,5,5)
#假设是3张图片，3个通道，每个通道的长5宽5
print(a)
print('站在某一张图片的立场上看shape',a[0].shape)
print('站在开头到1图片的立场上看shape',a[:2].shape)
print('站在某一个通道的立场上看shape',a[0,0].shape)
print('看第一张图的第一个通道的（1，1）像素点',a[0,0,1,1])
print('看第一张图的第一个通道的（0，0）（0，1）（1，0）（1，1）像素点',a[0,0,:2,:2])
print('隔行采样看第一张图的第一个通道的（0，0）（0，2）（2，0）（2，2）像素点,步长为2',a[0,0,:3:2,:3:2])

#使用index_select索引
print('使用index_select索引',a.index_select(0,torch.tensor([0,1])))#第一个0代表的是对图片维度执行操作，采集的是第一个和第二个图片
print('使用index_select索引',a.index_select(1,torch.tensor([0,1])))#第一个0代表的是对通道执行操作，采集的是第一个和第二个通道

#mask掩码
sd=torch.rand(3,3)
print('未掩码前',sd)
sdmask=sd.ge(0.5) #筛选出大于0.5的
print('掩码后',sdmask)
print('筛选出大于0.5的',torch.masked_select(sd,sdmask))

 维度操作

#维度变换
import torch
import numpy as np

#改变形状
a=torch.rand(3,3,5,5)
print(a)
#假设是3张图片，3个通道，每个通道的长5宽5  元素的总大小是3*3*5*5=225
b=a.reshape(3,3*25) #只要元素的总大小不变都能reshape
print('改成3行75列的矩阵',b)  #将3张图片每张图片用75的向量来表示

#增加维度
a=torch.rand(3,3,5,5)
a=a.unsqueeze(0) #在a的0索引前面加上一个维度1。
#假设原来是3张图片，3个通道，每个通道的长5宽5 ，现在是1个组里有3张图片，3个通道，每个通道的长5宽5
print(a.shape)
a=a.unsqueeze(-1) #在a的-1索引后面加上一个维度1。
print(a.shape)

#减少维度
sd=torch.rand(1,5,1,1)
print('无输入数字时会把所有的1的维度全给他删除了',sd.squeeze().shape)
print('输入数字时会把指定的1的维度删除了',sd.squeeze(2).shape)

#增加维度内的元素，也就是[1,5,1,1]变成[4,5,3,3]的过程
#！！！！！注意1变N是可以的，但是5变N是不行的！！！！！
sd=torch.rand(1,5,1,1)
print(sd.expand(4,5,3,3).shape)

#矩阵转置，只能使用2d的
sd1=torch.rand(4,5)
print(sd1.t().shape)

#确认两个tensor的一致性
t1=torch.tensor([1,2,3])
t2=torch.tensor([1,2,3])
print('检查一致性',torch.all(torch.eq(t1,t2)))

#维度变化与恢复
a=torch.rand(3,3,5,5)
a1=a.transpose(1,2).contiguous().reshape(3,75).reshape(3,5,3,5).transpose(1,2) #transport变化时记得写contiguous
print('检查变化前后是否相同',torch.all(torch.eq(t1,t2)))

自动拓展示例

 

 

 四张图片，三个通道，每个通道32*32个像素点

在[4,3,32,32]上加[32,32]代表的是在每个通道的32*32的像素点上加上一组32*32的基地

在[4,3,32,32]上加[3,1,1]代表的是对每一个通道的每一个像素点都加上一个固定的值

在[4,3,32,32]上加[1,1,1,1]代表的是对所有的照片的所有的通道的长宽都加上一个固定的值