PyTorch入门

PyTorch快速入门

1.安装Pytorch

https://pytorch.org/get-started/locally/

 

2.Pytorch和Numpy

# 引入torch模块(这就是我们的pytorch)        
import torch   
import numpy    
# 创建一个Tensor
torch_data = torch.Tensor([1,2,3]) 
# Torch ---> array 
np_data = torch_data.numpy()
# array ---> Torch
torch_data = torch.from_numpy(np_array)
# 求绝对值
torch.abs(torch_data)
# 创建一个全为1的矩阵
torch.ones((2,2))

3 激活函数

  • 没有激活函数,我们的神经网络就永远只能处理线性问题,对于非线性问题,我们需要激活函数,来让我们的神经网络更好的处理非线性问题。

  • torch.nn.function中引用 很多的激活函数都可以从中引用,但有也有一小部分常用的需要我们从torch中引用

import torch.nn.functional as F 
import torch
# 引用方法
torch.rule() 
​
F.sigmoid()
F.tanh()
F.softplus()

4.误差反向传播

误差反向传播,是神经网络中的一个重要的功能,让我们不断更新我们神经元的权重,从而使我们的神经网络不断优化

import torch
from torch.autograd import Variable
​
x = torch.Tensor([[1,2],[3,4]])
# 开启反向传播的功能
x.requires_grad=True
​
y = torch.mean(x*x)  # v^2
# 进行误差反向传播
y.backward()
# 查看误差
print(x.grad)

OUT

tensor([[0.5000, 1.0000],
        [1.5000, 2.0000]])

5.搭建一个简单的神经网络

 

import torch
import torch.nn.functional as F 
import numpy as np 
​
class Net(torch.nn.Module):
    def __init__(self , n_feature , n_hidden , n_output):
        super(Net ,self).__init__() #调用父类
        ##隐含层 
        self.hidden = torch.nn.Linear( n_feature , n_hidden)
        ##输入层
        self.predict = torch.nn.Linear(n_hidden , n_output)
​
    def forward(self , x):
        #在隐藏层和输入层之间 加上激活函数
        x = F.relu(self.hidden(x))
        x = self.predict(x)
        return x
​
##一个输入神经元 10 个隐藏神经元 1个输出神经元
net = Net( 1,10 ,1)
##打印这个神经网路
print(net)
  • 快速定义我们的神经网路的方法

net2 = torch.nn.Sequential(
        torch.nn.Linear(1,10),
        torch.nn.ReLU(),
        torch.nn.Linear(10,1)
)
print(net2) # 和第一个的结果是一样的

OUT

Sequential(
  (0): Linear(in_features=1, out_features=10, bias=True)
  (1): ReLU()
  (2): Linear(in_features=10, out_features=1, bias=True)
)

6.优化器与误差函数

  • 损失函数 (通过计算损失,来让我门优化我们的神经网路)

  • 均方差 做误差函数

 

loss_func = torch.nn.MSELoss()
# 对于分类的任务  使用交叉熵作为误差函数会更好一些
loss_func = CrossEntropyLoss()

优化器

# 随机梯度下降的优化器
# Net是我们上节的神经网络 # Net.parameters() 是我们的神经网络的参数
net_SGD = Net() 
# 里面的的参数是: 我们神经网络的参数,和学习率,学习率,是我们更新参数的幅度
torch.optim.SGD(net_SGD.parameters(),lr=0.01)
 学习率 大学习率 小
收敛速度
缺点容易在最优点震荡容易过拟合

 

 

链接:https://morvanzhou.github.io/tutorials/machine-learning/torch/

### PyTorch 入门教程 #### 加载库并准备数据集 为了开始使用 PyTorch 进行机器学习模型训练,加载必要的库是第一步。这包括 `torch` 及其子模块 `nn`(神经网络),以及用于获取标准图像分类数据集的 `datasets` 和转换工具 `ToTensor`。 ```python import torch from torch import nn from torch.utils.data import DataLoader from torchvision import datasets, transforms ``` 接着定义如何预处理输入图片的数据变换链——这里仅简单地将其转成张量形式: ```python transform = transforms.ToTensor() ``` 创建一个实例化后的 Dataset 对象来存储样本及其对应标签,并通过指定根目录、是否作为测试集以及其他参数完成初始化工作;最后利用 DataLoader 来封装这个自定义或内置的数据源类以便后续取用批次化的训练/验证数据[^1]。 ```python training_data = datasets.FashionMNIST( root="data", train=True, download=True, transform=ToTensor(), ) test_data = datasets.FashionMNIST( root="data", train=False, download=True, transform=ToTensor(), ) ``` 构建好上述组件之后就可以轻松获得批量大小为 64 的迭代器了: ```python train_dataloader = DataLoader(training_data, batch_size=64) test_dataloader = DataLoader(test_data, batch_size=64) ``` #### 定义模型结构 接下来要做的就是设计具体的网络架构,在此以简单的全连接层为例展示基本操作方法。当然实际应用中可能还会涉及到卷积核池化等更复杂的运算单元组合方式。 ```python class NeuralNetwork(nn.Module): def __init__(self): super(NeuralNetwork, self).__init__() self.flatten = nn.Flatten() # 展平多维特征向量 self.linear_relu_stack = nn.Sequential( # 构建线性层序列 nn.Linear(28*28, 512), nn.ReLU(), # 非线性激活函数 nn.Linear(512, 512), nn.ReLU(), nn.Linear(512, 10), # 输出维度等于类别数 ) def forward(self, x): # 正向传播过程描述 x = self.flatten(x) logits = self.linear_relu_stack(x) return logits model = NeuralNetwork().to('cuda' if torch.cuda.is_available() else 'cpu') print(model) # 打印查看当前设备上的模型配置详情 ``` 这段代码实现了两件事:一是继承基类 `Module` 并重写构造函数与前馈计算逻辑;二是根据硬件条件自动选择运行平台从而提高效率。 #### 训练循环设置 有了前面几步打下的基础,现在可以着手编写完整的训练流程啦! ```python loss_fn = nn.CrossEntropyLoss() # 设置损失函数类型 optimizer = torch.optim.SGD(model.parameters(), lr=1e-3) def train(dataloader, model, loss_fn, optimizer): size = len(dataloader.dataset) for batch, (X, y) in enumerate(dataloader): X, y = X.to(device), y.to(device) pred = model(X) # 调用模型预测输出 loss = loss_fn(pred, y) # 计算误差值 optimizer.zero_grad() # 清除梯度缓存区中的旧记录以免累积影响新一次更新 loss.backward() # 自动求导机制反传误差信号调整权重参数 optimizer.step() if batch % 100 == 0: current = batch * len(X) print(f"loss: {loss:>7f} [{current:>5d}/{size:>5d}]") device = 'cuda' if torch.cuda.is_available() else 'cpu' for t in range(epochs): print(f"Epoch {t+1}\n-------------------------------") train(train_dataloader, model, loss_fn, optimizer) print("Done!") ``` 以上部分展示了怎样设定优化算法超参选项并通过遍历 epoch 数目实现多次迭代直至收敛稳定状态为止的过程。 #### 测试评估性能指标 当所有准备工作都完成后自然少不了检验成果好坏的重要环节咯~下面给出了一种简易版的方法供参考借鉴: ```python def test(dataloader, model, loss_fn): size = len(dataloader.dataset) num_batches = len(dataloader) model.eval() test_loss, correct = 0, 0 with torch.no_grad(): for X, y in dataloader: X, y = X.to(device), y.to(device) pred = model(X) test_loss += loss_fn(pred, y).item() correct += (pred.argmax(1)==y).type(torch.float).sum().item() test_loss /= num_batches correct /= size print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n") test(test_dataloader, model, loss_fn) ``` 该片段主要围绕着关闭 dropout 等随机因素干扰的前提下统计正确率和平均交叉熵得分来进行最终评判。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值