pytorch学习

最新推荐文章于 2024-10-31 16:18:03 发布

与风共舞true

最新推荐文章于 2024-10-31 16:18:03 发布

阅读量1k

点赞数

文章标签： pytorch 学习深度学习

本文链接：https://blog.csdn.net/qq_44717133/article/details/129260310

版权

文章介绍了PyTorch的基本概念，包括Tensor、Variable、nn.Module，详细阐述了Tensor的创建、属性、运算以及各种操作，如广播机制、裁剪运算、索引筛选。此外，还涉及神经网络的基本组成模块，如卷积层、激活层、池化层、全连接层，以及训练过程中的损失函数和优化器。同时，文章讨论了计算机视觉的基础知识和卷积神经网络的应用。

摘要由CSDN通过智能技术生成

一、分类和回归

分类（离散值）：预测10类别就是十维的向量，哪一个向量对应的最大就是该类，概率加起来就是1
在这里插入图片描述
预测（连续值）

二、 pytorch的基本概念

Tensor: 张量（一个个数字）可以描述任意维度的物体，例如0阶的标量（0，1，2），1阶的向量【1，2，3】，2阶的矩阵
Variable：变量，用变量来表示参数
nn.Module：封装网络结构
在这里插入图片描述
样本：数据，使用tensor来对数据进行描述
模型：y=wx+b

三、Tensor的基本概念

类型

在这里插入图片描述

创建

在这里插入图片描述

属性

内存中如何排布：
在这里插入图片描述
torch.dtype：类型
torch.device：设备
torch.layout: 内存布局对象，稠密的张量（内存中一块集中的区域），稀疏的张量（记录非零响亮的坐标）
加粗样式
稀疏的张量：可以减少在内存中的占用

运算

加减乘除：
加法
在这里插入图片描述
sub减法
mul乘法：点乘

div除法
矩阵运算等
矩阵
高维

幂运算
在这里插入图片描述

对数运算等
在这里插入图片描述

开方运算
在这里插入图片描述

pytorch中的in-place操作

就地操作，就是不允许使用临时变量，也称为原位操作
x=x+y
add_ sub_ mul_等

pytorch中的广播机制

在这里插入图片描述

tensor的取正取余运算

在这里插入图片描述

tensor的比较运算

在这里插入图片描述

Tensor三角函数

其他函数

统计
在这里插入图片描述

torch.distributions

在这里插入图片描述

随机抽样函数

定义随机种子（通过随机种子，随机数一样）

定义随机数满足的分布
在这里插入图片描述

范数运算

在这里插入图片描述
矩阵分解

特征向量和特征值
在这里插入图片描述

SVD奇异值分解

Tensor 裁剪运算

对Tensor中的元素进行范围过滤
常用于梯度裁剪（gradient clipping），即在发啥呢个梯度离散或者梯度爆炸时对梯度的处理

a.clamp(2,10) 2-10之间

Tensor 索引和数据筛选

在这里插入图片描述

Tensor 组合拼接

在这里插入图片描述

autograd

导数
在这里插入图片描述
每个tensor通过requires_grad来设置是否计算梯度，来冻结某些层的参数

autograd的几个概念
叶子张量：leaf

backward函数：自动计算梯度

在这里插入图片描述

torch.nn

是专门为神经网络设计的模块化接口
在这里插入图片描述
nn.parameter定义可训练参数

nn.Sequential

模型加载和保存

visdom可视化

在这里插入图片描述
安装

tensorboardx 数据可视化工具

在这里插入图片描述

trochvision

在这里插入图片描述

神经网络的基本概念

在这里插入图片描述

前向运算（参数已知）

过拟合和欠拟合

如何防止过拟合和欠拟合

正则化问题

pytorch搭建神经网络基本组成模块

在这里插入图片描述
案例一：解决波士顿房价预测模型搭建，506个数据点，14种特征信息
http://t.cn/RFHTAgY
损失函数：MSE-LOSS

案例二、

模型的幸能评价——交叉验证

在这里插入图片描述

#data 拿数据
import numpy as np
import re  #通过正则表达式来将空格进行压缩成一个
ff=optn("housing.data").readlines()
for item in ff:
	out=re.sub(r"\s{1,}"," ",item).strip()
	print(out)
	out.split(" ")#以空格来进行分割
	data.append(out.split(" "))
data=np.array(data).astype(np.float)

y=data[:,-1]
x=data[:,0:-1]

y_train=data[0:496,...]
x_train=data[0:496,...]
y_test=data[496:,...]
x_test=data[496:,...]



#net 搭建网络
class Net(torch.nn.Module):
	def __init__(self,n_feature,n_output):
		super(Net,self).__init__()
		self.hidden=torch.nn.Linear(n_feature,100)
		self.predict=torch.nn.Linear(100,n_output)
	def forward(self,x):
		out=self.hidden(x)
		out=torch.relu(out)
		out=self.predict(x)
		return out
net=Net(13,1)

#loss 损失函数

loss_func=torch.nn.MSELoss()
#optimiter 优化器
optimizer=torch.optim.SGD(net.parameters(),lr=0.0001)
#training 训练
for i in range(1000):
	x_data=torch.tensor(x_train,dtype=torch.float32)
	y_data=torch.tensor(y_train,dtype=torch.float32)
	pred=net.forward(x_data)
	pred=torch.squeeze(pred)
	loss=loss_func(pred,y_data)*0.001
	
	optimizer.zero_grad(0)
	loss.backward()
	optimizer.step()
	print("ite:{},loss:{}".format(i,loss))
	print(pred[0:10])
	print(y_data[0:10])
	
#test 
    x_data=torch.tensor(x_test,dtype=torch.float32)
	y_data=torch.tensor(y_test,dtype=torch.float32)
	pred=net.forward(x_data)
	pred=torch.squeeze(pred)
	loss_test=loss_func(pred,y_data)*0.001
	print("ite:{},loss_test:{}".format(i,loss_test))

训练字体

data层
在这里插入图片描述
batchsize使用的是进行每次提取一部分数据

net层

class CNN(torch.nn.Module):
	def __init__(self):
		super(CNN,self).__init__()
		self.conv=torch.nn.Sequential(
	        torch.nn.Conv2d(1,32,kernel_size=5,padding=2),
	        torch.nn.BatchNorm2d(32),
	        torch.nn.ReLu(),
	        torch.nn.MaxPool2d(2)
	)
	self.fc=torch.nn.Linear(14*14*32,10)
	def forward(self,x):
	   out=self.conv(x)
	   out=out.view(out.size()[0],-1)
	   out=self.fc(out)
	   return out
# 初始化类
cnn=CNN()
cnn=cnn.cuda()

损失函数

loss_func=torch.nn.CrossEntropyLoss()#交叉熵函数

优化器

optimizer=torch.optim.Adam(cnn.parameters(),lr=0.01)

训练
epoch每次将所有样本训练一次叫一个epoch，需要多次拿出来训练训练几遍

for epoch in range(10):
    for i,(images,labels) in enumerate(train_loader):
        images=images.cuda()
        labels=labels.cuda()
        outputs=cnn(images)
       loss=loss_func(outputs,labels)
       
       optimizer.zero_grad()
       loss.backward()
       optimizer.step()
       print()"epoch is {},ite is" "{}/{},loss is{}".format(epoch+1,i,len(train_data)//64,loss.item)

计算一下在测试集上的精度
eval/test

loss_test=0
accuracy=0
 for i,(images,labels) in enumerate(test_loader):
	  images=images.cuda()
      labels=labels.cuda()
      outputs=cnn(images)
      loss+=loss_func(outputs,labels)
      #算出概率分布最大的值
      _,pred=outputs.max(1)
      accuracy+=(pred==labels).sum().item()
    accuracy=accuracy/len(test_data)
    loss_test= loss_test/(len(test_data)//64)
    print()"epoch is {},ite is" "{}/{},loss is{}".format(epoch+1,i,len(test_data)//64,loss.item)

（1）batchsize：批大小。在深度学习中，一般采用SGD训练，即每次训练在训练集中取batchsize个样本训练；
（2）iteration：1个iteration等于使用batchsize个样本训练一次；
（3）epoch：1个epoch等于使用训练集中的全部样本训练一次；
举个例子，训练集有1000个样本，batchsize=10，那么：
训练一个epoch是100个batch，也就是这1个epoch中iteration是100。