【深度学习8】Pytorch使用及使用小案例

最新推荐文章于 2024-05-23 09:31:09 发布
最新推荐文章于 2024-05-23 09:31:09 发布
阅读量2.2k 收藏 16
点赞数 2
分类专栏： 深度学习 文章标签： pytorch 深度学习 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NewbieJ_/article/details/124707797
版权

文章目录

八、PyTorch

8.1 相关定义

1 张量Tensor

优点：可以使用GPU加速

1）Tensor和numpy之间的转化

import torch
import numpy as np
np_data = np.arange(8).reshape((2,4)) #定义一个numpy的二维数组
torch_data = torch.from_numpy(np_data)
print(np_data)
print(torch_data)
np_data2 = torch_data.numpy() #转回numpy
print(np_data2)

2）矩阵运算

import torch
import numpy as np
np_data = np.array([[1,2],[3,5]])
torch_data = torch.from_numpy(np_data)
print(np_data)
print(np_data.dot(np_data))
print(torch_data.mm(torch_data))
2 Variable

Tensor是PyTorch中的基础组件，但是构建神经网络还远远不够，我们需要能够构建计算图的Tensor，也就是Variable（简单理解就是Variable是对Tensor的一种封装）。
其操作与Tensor是一样的，但是每个Variable都包含了三个属性

  • .dataVariable中的Tensor本身
  • .grad对应Tensor的梯度
  • .grad_fn创建这个Variable的Function的引用（该引用可用于回溯整个创建链路，如果是用户自己创建Variable，则其grad_fn为None）

image-20220504081841335

from torch.autograd import Variable
import torch
x_tensor = torch.randn(10, 5) #从标准正态分布中返回多个样本值
# 将Tensor变成Variable
x = Variable(x_tensor, requires_grad=True)
# 默认Variable是不需要求梯度的，所以用这个方式申明需要对其进行求梯度的操作
print(x.data)
print(x.grad)
print(x.grad_fn)

8.2 激活函数

import torch
from torch.autograd import Variable
import matplotlib.pyplot as plt
tensor = torch.linspace(-6,6,200)
tensor = Variable(tensor)
np_data = tensor.numpy()
#定义激活函数
y_relu = torch.relu(tensor).data.numpy()
y_sigmoid =torch.sigmoid(tensor).data.numpy()
y_tanh = torch.tanh(tensor).data.numpy()
plt.figure(1, figsize=(8, 6))
plt.subplot(221)
plt.plot(np_data, y_relu, c='red', label='relu')
plt.legend(loc='best')
plt.subplot(222)
plt.plot(np_data, y_sigmoid, c='red', label='sigmoid')
plt.legend(loc='best')
plt.subplot(223)
plt.plot(np_data, y_tanh, c='red', label='tanh')
plt.legend(loc='best')
plt.show()

8.3 损失函数

1）均方误差损失函数

PyTorch中均方差损失函数被封装成MSELoss函数，其调用方法如下：

torch.nn.MSELoss(size_average=None, reduce=None,reduction='mean')

调用方法中的参数及说明具体如下：
size_average(bool，optional)：基本弃用（参见reduction）。默认情况下，损失是批次（batch）中每个损失元素的平均值。请注意，对于某些损失，每个样本均有多个元素。如果将字段size_average设置为False，则需要将每个batch的损失相加。当reduce设置为False时忽略。默认值为True。

reduce(bool，optional)：基本弃用（参见reduction）。默认情况下，根据size_average，对每个batch中结果的损失进行平均或求和。当reduce为False时，返回batch中每个元素的损失并忽略size_average。默认值为True。

reduction(string，optional)：输出元素包含3种操作方式，即none、mean和sum。‘none’：不做处理。‘mean’：输出的总和除以输出中元素的数量。‘sum’：输出的和。注意：size_average和reduce基本已被弃用，而且指定这两个args中的任何一个都将覆盖reduce。默认值为mean。在PyTorch 0.4之后，参数size_average和reduce已被舍弃。

2）交叉熵损失函数

PyTorch中的交叉熵损失函数将nn.LogSoftmax()和nn.NLLLoss()合并在一个类中，函数名为CrossEntropyLoss()。CrossEntropyLoss是多分类任务中常用的损失函数，在PyTorch中其调用方法如下：

torch.nn.CrossEntropyLoss(weight=None, size_average=None,ignore_index=-100, reduce=None, reduction='mean')

调用方法中的参数及其说明具体如下。
weight(Tensor，optional)：多分类任务中，手动给出每个类别权重的缩放量。如果给出，则其是一个大小等于类别个数的张量。
size_average(bool，optional)：已基本弃用（参见reduction）。默认情况下，损失是batch中每个损失元素的平均值。请注意，对于某些损失，每个样本都包含了多个元素。如果将字段size_average设置为False，则将每个小批量的损失相加。当reduce为False时则忽略。默认值为True。
ignore_index(int，optional)：指定被忽略且不对输入梯度做贡献的目标值。当size_average为True时，损失则是未被忽略目标的平均。

reduce(bool，optional)：已基本弃用（参见reduction）。默认情况下，根据size_average，对每个batch中结果的损失进行平均或求和。当reduce为False时，返回batch中每个元素的损失并忽略size_average。默认值为True。
reduction(string，optional)：输出元素有3种操作方式，即none、mean和sum。

  • ‘none’：不做处理。

  • ‘mean’：输出的总和除以输出中的元素数量。

  • ‘sum’：输出的和。

注意：size_average和reduce正在被弃用，而且指定这两个args中的任何一个都将覆盖reduce。默认值为mean。

8.4 PyTorch实战

1 MNIST手写数字识别

PyTorch实战之MNIST分类第一个案例我们使用MNIST数据集来进行手写数字的识别。

1）数据准备

import torch
from torch.utils.data import DataLoader
import torchvision.datasets as dsets
import torchvision.transforms as transforms
batch_size = 100
# MNIST dataset
train_dataset = dsets.MNIST(root = '/pymnist', #选择数据的根目录
                           train = True, # 选择训练集
                           transform = transforms.ToTensor(), #转换成tensor变量
                           download = True) # 从网络上download图片
test_dataset = dsets.MNIST(root = '/pymnist', #选择数据的根目录
                           train = False, # 选择测试集
                           transform = transforms.ToTensor(), #转换成tensor变量
                           download = True) # 从网络上download图片
#加载数据
train_loader = torch.utils.data.DataLoader(dataset = train_dataset, 
                                           batch_size = batch_size, #使用批次数据
                                           shuffle = True)  # 将数据打乱
test_loader = torch.utils.data.DataLoader(dataset = test_dataset,
                                          batch_size = batch_size,
                                          shuffle = True)

2）创建神经网络模型

import torch.nn as nn
import torch

input_size = 784 #mnist的像素为28*28
hidden_size = 500
num_classes = 10 #输出为10个类别分别对应0-9

# 创建神经网络模型
class Neural_net(nn.Module):
#初始化函数，接受自定义输入特征的维数，隐含层特征维数以及输出层特征维数。
    def __init__(self, input_num,hidden_size, out_put):
        super(Neural_net, self).__init__()
        self.layer1 = nn.Linear(input_num, hidden_size)#从输入到隐藏层的线性处理
        self.layer2 = nn.Linear(hidden_size, out_put)#从隐层到输出层的线性处理

    def forward(self, x):
        out = self.layer1(x) #输入层到隐藏层的线性计算
        out = torch.relu(out) #隐藏层激活
        out = self.layer2(out) #输出层，注意，输出层直接接loss
        return out

net = Neural_net(input_size, hidden_size, num_classes)
print(net)

3）训练

# optimization
from torch.autograd import Variable
import numpy as np
learning_rate = 1e-1 #学习率
num_epoches = 5
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(), lr = learning_rate)#使用随机梯度下降
for epoch in range(num_epoches):
    print('current epoch = %d' % epoch)
    for i, (images, labels) in enumerate(train_loader): #利用enumerate取出一个可迭代对象的内容
        images = Variable(images.view(-1, 28 * 28))
        labels = Variable(labels)
        
        outputs = net(images) #将数据集传入网络做前向计算
        loss = criterion(outputs, labels) #计算loss
        optimizer.zero_grad() #在做反向传播之前先清除下网络状态
        loss.backward() #loss反向传播
        optimizer.step() #更新参数
        
        if i % 100 == 0:
            print('current loss = %.5f' % loss.item())
            
print('finished training')

4）评估

#做prediction
total = 0
correct = 0
for images, labels in test_loader:
    images = Variable(images.view(-1, 28 * 28))
    outputs = net(images)
    print(outputs)
    _, predicts = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicts == labels).sum()
print('Accuracy = %.2f' % (100 * correct / total))

全部代码

import torch
from torch.utils.data import DataLoader
import torchvision.datasets as dsets
import torchvision.transforms as transforms
batch_size = 100
# MNIST dataset
train_dataset = dsets.MNIST(root = '/pymnist', #选择数据的根目录
                           train = True, # 选择训练集
                           transform = transforms.ToTensor(), #转换成tensor变量
                           download = True) # 从网络上download图片
test_dataset = dsets.MNIST(root = '/pymnist', #选择数据的根目录
                           train = False, # 选择测试集
                           transform = transforms.ToTensor(), #转换成tensor变量
                           download = True) # 从网络上download图片
#加载数据
train_loader = torch.utils.data.DataLoader(dataset = train_dataset, 
                                           batch_size = batch_size, #使用批次数据
                                           shuffle = True)  # 将数据打乱
test_loader = torch.utils.data.DataLoader(dataset = test_dataset,
                                          batch_size = batch_size,
                                          shuffle = True)


import torch.nn as nn
import torch

input_size = 784 #mnist的像素为28*28
hidden_size = 500
num_classes = 10 #输出为10个类别分别对应0-9

# 创建神经网络模型
class Neural_net(nn.Module):
#初始化函数，接受自定义输入特征的维数，隐含层特征维数以及输出层特征维数。
    def __init__(self, input_num,hidden_size, out_put):
        super(Neural_net, self).__init__()
        self.layer1 = nn.Linear(input_num, hidden_size)#从输入到隐藏层的线性处理
        self.layer2 = nn.Linear(hidden_size, out_put)#从隐层到输出层的线性处理

    def forward(self, x):
        out = self.layer1(x) #输入层到隐藏层的线性计算
        out = torch.relu(out) #隐藏层激活
        out = self.layer2(out) #输出层，注意，输出层直接接loss
        return out

net = Neural_net(input_size, hidden_size, num_classes)
print(net)


# optimization
from torch.autograd import Variable
import numpy as np
learning_rate = 1e-1 #学习率
num_epoches = 5
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(), lr = learning_rate)#使用随机梯度下降
for epoch in range(num_epoches):
    print('current epoch = %d' % epoch)
    for i, (images, labels) in enumerate(train_loader): #利用enumerate取出一个可迭代对象的内容
        images = Variable(images.view(-1, 28 * 28))
        labels = Variable(labels)
        
        outputs = net(images) #将数据集传入网络做前向计算
        loss = criterion(outputs, labels) #计算loss
        optimizer.zero_grad() #在做反向传播之前先清除下网络状态
        loss.backward() #loss反向传播
        optimizer.step() #更新参数
        
        if i % 100 == 0:
            print('current loss = %.5f' % loss.item())
            
print('finished training')


#做prediction
total = 0
correct = 0
for images, labels in test_loader:
    images = Variable(images.view(-1, 28 * 28))
    outputs = net(images)
    print(outputs)
    _, predicts = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicts == labels).sum()
print('Accuracy = %.2f' % (100 * correct / total))
2 Cifar10分类

1）数据准备

import torch
from torch.utils.data import DataLoader
import torchvision.datasets as dsets
import torchvision.transforms as transforms
batch_size = 100

# MNIST dataset
train_dataset = dsets.CIFAR10(root = '/ml/pycifar', #选择数据的根目录
                           train = True, # 选择训练集
                           transform = transforms.ToTensor(), #转换成tensor变量
                           download = True) # 从网络上download图片
test_dataset = dsets.CIFAR10(root = '/ml/pycifar', #选择数据的根目录
                           train = False, # 选择测试集
                           transform = transforms.ToTensor(), #转换成tensor变量
                           download = True) # 从网络上download图片
#加载数据

train_loader = torch.utils.data.DataLoader(dataset = train_dataset, 
                                           batch_size = batch_size, 
                                           shuffle = True)  # 将数据打乱
test_loader = torch.utils.data.DataLoader(dataset = test_dataset,
                                          batch_size = batch_size,
                                          shuffle = True)

2）创建神经网络模型

from torch.autograd import Variable
import torch.nn as nn
import torch
# input_size = 3072
# hidden_size = 500
input_size = 784
hidden_size = 100
hidden_size2 = 200
num_classes = 10
num_epochs = 5
batch_size = 100
learning_rate = 0.001


#定义两层神经网络
class Net(nn.Module):
    def __init__(self,input_size,hidden_size,hidden_size2,num_classes):
        super(Net,self).__init__()
        self.layer1 = nn.Linear(input_size,hidden_size)
        self.layer2 = nn.Linear(hidden_size,hidden_size2)
        self.layer3 = nn.Linear(hidden_size2,num_classes)
    
    def forward(self,x):
        out = torch.relu(self.layer1(x))
        out = torch.relu(self.layer2(out))
        out = self.layer3(out)
        return out

net = Net(input_size,hidden_size,hidden_size2,num_classes)
print(net)

3）训练

# optimization
from torch.autograd import Variable
import numpy as np
learning_rate = 1e-1 #学习率
num_epoches = 5
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(), lr =
learning_rate)#使用随机梯度下降
for epoch in range(num_epoches):
    print('current epoch = %d' % epoch)
    for i, (images, labels) in enumerate(train_loader): #利 用enumerate取出一个可迭代对象的内容
        images = Variable(images.view(-1, 28 * 28))
        labels = Variable(labels)
        outputs = net(images) #将数据集传入网络做前向计算
        loss = criterion(outputs, labels) #计算Loss
        optimizer.zero_grad() #在做反向传播之前先清除下网络状态
        loss.backward() #Loss反向传播
        optimizer.step() #更新参数
        if i % 100 == 0:
            print('current loss = %.5f' % loss.item())
print('finished training')

4）评估

#做prediction total = 0
correct = 0
for images, labels in test_loader:
    images = Variable(images.view(images.size(0), -1))
    outputs = net(images)
    _, predicts = torch.max(outputs.data, 1) 
    total += labels.size(0)
    correct += (predicts == labels).sum()
print('Accuracy = %.2f' % (100 * correct / total))

最后我跑出来的结果是MINIST数据集的准确度为97.41%

而另一个复杂一些的彩色Cifar10数据集效果却不好，准确度只有48.35%。所以，浅层的神经网络keyi解决一部分简单的问题。深层的还是得看卷积神经网络。

JunLal
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
PyTorch深度学习实战（3）——使用PyTorch构建神经网络
盼小辉丶的博客
06-13 5万+
PyTorch 是一个用于构建深度神经网络的库，具有灵活性和可扩展性，可以轻松自定义模型。在本节中，我们将使用 PyTorch 库构建神经网络，利用张量对象操作和梯度值计算更新网络权重，并利用 Sequential 类简化网络构建过程，最后还介绍了如何使用 save、load 方法保存和加载模型，以节省模型训练时间。
深度学习框架pytorch入门与实践源代码.rar
11-21
PyTorch是Facebook开源的一个强大而灵活的深度学习框架，以其动态计算图模式和易于使用的特性受到了广大开发者和研究者的青睐。本篇将深入探讨PyTorch的核心概念、关键功能以及在实际项目中的应用。 一、PyTorch...
总结3-常见深度学习网络入门：pytorch实例
qimo601的专栏
09-15 3096
常见深度学习网络入门：pytorch实例
13个PyTorch深度学习案例简介
brucexia的专栏
05-23 422
新闻文本分类项目，中文新闻分类数据集，GPT-2模型。第15章 基于大语言模型的自然语言处理项目实战。第9章 空气质量识别分类与预测项目实战。第6章 迁移学习花朵识别项目实战。第17章 X光肺部感染识别项目实战。第18章 乐器声音音频识别项目实战。第12章 图像风格迁移项目实战。第14章 糖尿病预测项目实战。
pytorch基础教学简单实例（附代码）
热门推荐
Lizhi_Tech的博客
07-15 1万+
零基础pytorch深度学习安装使用代码实例新手教学
Pytorch经典入门案例
ygp12345的博客
12-05 8108
导入torch库，然后用torch.empty(5，3)初始化一个5*3的tensor。 这个tensor里的数字是随机的。 torch.rand(5,3)里创建的tensor里的数字是零到一的数字。 创建一个全是0的tensor，类型默认是torch.float32 还可以自己制定类型 还可以使用long()函数 还可以根据已有数据创建tensor。 也可以从一个已有的tensor建立新的tensor，新建的tensor会有之前的tensor的一些特征，如下图：我用new_ones(5,3)建
python pytorch教程-带你从入门到实战（代码全部可运行）
weixin_43327597的博客
06-23 1万+
其实这个教程以前博主写过一次，不过，这回再写一次，打算内容写的多一点，由浅入神，然后加入一些实践案例。下面是我们的内容目录： 1.先从数据类型谈起2.数据类型和其操作谈完，选择某一个方向开始学习和实践（深度学习）。1.先从数据类型谈起那如果从数据类型谈起，我们就要从下面几个角度去谈：1.1 如何生成pytorch的各种数据类型？1.2 pytorch的各种数据类型有哪些属性？1.3 pytorch的各种数据类型有哪些函数操作？首先，我们知道pytorch是一个计算库，也有人说是深度学习库，那么计算库呢，肯
python深度学习pytorch水稻图像分类完整案例
最新发布
05-31
本资源提供了一个完整的水稻图像分类案例，涵盖了从数据预处理、数据加载、模型定义、训练到评估的全过程。通过此案例，用户可以学习如何...此案例适合于图像分类任务的初学者以及希望掌握PyTorch深度学习框架的用户。
深度学习之Pytorch
03-27
这份“深度学习之Pytorch”的资料可能涵盖了PyTorch的基础教程、进阶技巧、实战项目案例等内容，有助于深入理解和掌握PyTorch的使用。通过学习，你可以逐步掌握如何搭建神经网络、实现模型训练、评估模型性能，并...
深度学习框架pytorch入门与实践源代码 + 个人案例
11-05
它的设计目标是提供一个灵活、高效、易于使用的平台，使研究人员能够快速实验新的深度学习模型，并且让开发者能够将这些模型轻松地部署到生产环境。本资料包包含了PyTorch入门与实践的源代码，以及一些个人案例，...
Python-介绍PyTorch的简单示例
08-09
介绍 PyTorch的简单示例
使用PyTorch进行深度学习 Deep Learning with PyTorch.zip
04-09
本教程将深入探讨如何使用PyTorch进行深度学习，涵盖从基础概念到高级应用的多个方面。 1. PyTorch的基本架构： PyTorch的核心是其动态计算图（Dynamic Computational Graph）机制，这使得在运行时构建和修改计算...
Pytorch100例 | 用深度学习处理分类问题【实战教程】
“365天深度学习训练营”报名进行中～
12-22 4401
和库是用于深度学习的两个最常用的 Python 库。PyTorch 是 Facebook 开发的，而 TensorFlow 是 Google 的项目。在本文中，你将看到如何使用 PyTorch 库来解决分类问题。分类问题属于机器学习问题的范畴，其中给定一组特征，任务是预测离散值。预测肿瘤是否癌变，或者学生是否可能通过考试，是分类问题的一些常见示例。在本文中，我们将根据银行客户的某些特征，预测客户是否有可能在 6 个月后离开银行。客户离开的现象也称为客户流失。
机器学习框架PyTorch详解和案列分析
Web3 & Basketball
08-03 4856
PyTorch 是一个基于 Python 的机器学习框架，由 Facebook 于 2016 年发布。它提供了一组灵活且高效的工具，可用于构建和训练各种深度学习模型。PyTorch 的核心组件是张量，它是一个多维数组，可以用于存储和处理数据。PyTorch 的张量与 NumPy 的数组类似，但也提供了 GPU 加速和自动微分等功能。PyTorch 使用动态计算图，这意味着在运行时可以修改计算图，从而允许更灵活的模型构建和调试。这与 TensorFlow 等框架的静态计算图不同。
pytorch简单神经网络搭建和训练实例
BernardDong的博客
06-28 4455
使用pytorch的框架搭建一个简单多分类神经网络模型，解决水果分类问题。
用Pytorch构建第一个神经网络模型（附案例实战）
zxb_1222的博客
03-14 1万+
PyTorch是一个基于python的科学计算包，主要针对两类人群：作为NumPy的替代品，可以利用GPU的性能进行计算作为一个高灵活性、速度快的深度学习平台在PyTorch中搭建神经网络并使用真实的天气信息预测明天是否会下雨。预处理 CSV 文件并将数据转换为张量使用 PyTorch 构建神经网络模型使用损失函数和优化器来训练模型评估模型并了解分类不平衡的危害在开始构建神经网络之前，首先了解一下几个重要概念。
pytorch入门示例
benben044的专栏
03-11 4135
pytorch入门示例，包含全连接网路、cnn网络的神经网络架构，最后通过混淆矩阵查看预测的准确性 from torchvision import datasets, transforms import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim train_set = datasets.FashionMNIST('D:\\temp\\
PyTorch实战案例（四）——利用PyTorch实现卷积神经网络LeNet-5
Wendy的博客
11-12 3803
目录一、案例描述二、代码详解2.1 定义模型2.2 检查模型2.3 构建加载数据集函数2.4 数据集可视化2.5 开始训练三、完整代码 一、案例描述 本文将介绍利用PyTorch实现卷积神经网络LeNet-5，关于卷积神经网络LeNet-5的介绍，可以参考：手写数字识别问题（3）——详解卷积神经网络LeNet-5。 二、代码详解 2.1 定义模型 LeNet-5结构如下： 首先，需要定义一下Reshape类，将图像转为(X,1,28,28)的形式，其中X为图像的数量，1* 28* 28为图像格式，1为通道
深度学习入门：PyTorch实战教程
"这是一份关于使用PyTorch进行深度学习的教程，旨在提供一个简单易懂的学习路径。教程覆盖了PyTorch的基础知识和深度学习应用，适合初学者和进阶者。" PyTorch是Facebook开源的一个强大的深度学习框架，它以其灵活...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值