精华内容
下载资源
问答
  • pytorch 1.0 中文文档 + pytorch 使用教程
  • PyTorch使用教程-PyTorch数据读取

    千次阅读 2020-08-29 16:00:38
    PyTorch使用教程-PyTorch数据读取 前言 PyTorch作为一款深度学习框架,已经帮助我们实现了很多很多的功能了,包括数据的读取和转换了,那么这一章节就介绍一下PyTorch内置的数据读取模块吧 模块介绍 pandas 用于...

    PyTorch使用教程-PyTorch数据读取

    前言

    PyTorch作为一款深度学习框架,已经帮助我们实现了很多很多的功能了,包括数据的读取和转换了,那么这一章节就介绍一下PyTorch内置的数据读取模块吧

    模块介绍

    • pandas 用于方便操作含有字符串的表文件,如csv
    • zipfile python内置的文件解压包
    • cv2 用于图片处理的模块,读入的图片模块为BGR,N H W C
    • torchvision.transforms 用于图片的操作库,比如随机裁剪缩放模糊等等,可用于数据的增广,但也不仅限于内置的图片操作,也可以自行进行图片数据的操作,这章也会讲解
    • torch.utils.data.Dataset torch内置的对象类型
    • torch.utils.data.DataLoaderDataset配合使用可以实现数据的加速读取和随机读取等等功能
    import zipfile # 解压
    import pandas as pd # 操作数据
    import os # 操作文件或文件夹
    import cv2 # 图像操作库
    import matplotlib.pyplot as plt # 图像展示库
    from torch.utils.data import Dataset # PyTorch内置对象
    from torchvision import transforms  # 图像增广转换库 PyTorch内置
    import torch 
    

    初步读取数据

    数据下载到此处
    我们先初步编写一个脚本来实现图片的展示

    # 解压文件到指定目录
    def unzip_file(root_path, filename):
        full_path = os.path.join(root_path, filename)
        file = zipfile.ZipFile(full_path)
        file.extractall(root_path)
    unzip_file(root_path, zip_filename)
    
    # 读入csv文件
    face_landmarks = pd.read_csv(os.path.join(extract_path, csv_filename))
    
    # pandas读出的数据如想要操作索引 使用iloc
    image_name = face_landmarks.iloc[:,0]
    landmarks = face_landmarks.iloc[:,1:]
    
    # 展示
    def show_face(extract_path, image_file, face_landmark):
        plt.imshow(plt.imread(os.path.join(extract_path, image_file)), cmap='gray')
        point_x = face_landmark.to_numpy()[0::2]
        point_y = face_landmark.to_numpy()[1::2]
        plt.scatter(point_x, point_y, c='r', s=6)
        
    show_face(extract_path, image_name.iloc[1], landmarks.iloc[1])
    

    在这里插入图片描述

    使用内置库来实现

    实现MyDataset

    使用内置库是我们的代码更加的规范,并且可读性也大大增加
    继承Dataset,需要我们实现的有两个地方:

    1. 实现__len__返回数据的长度,实例化调用len()时返回
    2. __getitem__给定数据的索引返回对应索引的数据如:a[0]
    3. transform 数据的额外操作时调用
    class FaceDataset(Dataset):
        def __init__(self, extract_path, csv_filename, transform=None):
            super(FaceDataset, self).__init__()
            self.extract_path = extract_path
            self.csv_filename = csv_filename
            self.transform = transform
            self.face_landmarks = pd.read_csv(os.path.join(extract_path, csv_filename))
        def __len__(self):
            return len(self.face_landmarks)
        def __getitem__(self, idx):
            image_name = self.face_landmarks.iloc[idx,0]
            landmarks = self.face_landmarks.iloc[idx,1:].astype('float32')
            point_x = landmarks.to_numpy()[0::2]
            point_y = landmarks.to_numpy()[1::2]
            image = plt.imread(os.path.join(self.extract_path, image_name))
            sample = {'image':image, 'point_x':point_x, 'point_y':point_y}
            if self.transform is not None:
                sample = self.transform(sample)
            return sample
    

    测试功能是否正常

    face_dataset = FaceDataset(extract_path, csv_filename)
    sample = face_dataset[0]
    plt.imshow(sample['image'], cmap='gray')
    plt.scatter(sample['point_x'], sample['point_y'], c='r', s=2)
    plt.title('face')
    

    在这里插入图片描述

    实现自己的数据处理模块

    内置的在torchvision.transforms模块下,由于我们的数据结构不能满足内置模块的要求,我们就必须自己实现
    图片的缩放,由于缩放后人脸的标注位置也应该发生对应的变化,所以要自己实现对应的变化

    class Rescale(object):
        def __init__(self, out_size):
            assert isinstance(out_size,tuple) or isinstance(out_size,int), 'out size isinstance int or tuple'
            self.out_size = out_size
        def __call__(self, sample):
            image, point_x, point_y = sample['image'], sample['point_x'], sample['point_y']
            new_h, new_w = self.out_size if isinstance(self.out_size,tuple) else (self.out_size, self.out_size)
            new_image = cv2.resize(image,(new_w, new_h))
            h, w = image.shape[0:2]
            new_y = new_h / h * point_y
            new_x = new_w / w * point_x
            return {'image':new_image, 'point_x':new_x, 'point_y':new_y}
    

    将数据转换为torch认识的数据格式因此,就必须转换为tensor
    注意: cv2matplotlib读出的图片默认的shape为N H W C,而torch默认接受的是N C H W因此使用tanspose转换维度,torch转换多维度使用permute

    class ToTensor(object):
        def __call__(self, sample):
            image, point_x, point_y = sample['image'], sample['point_x'], sample['point_y']
            new_image = image.transpose((2,0,1))
            return {'image':torch.from_numpy(new_image), 'point_x':torch.from_numpy(point_x), 'point_y':torch.from_numpy(point_y)}
    

    测试

    transform = transforms.Compose([Rescale((1024, 512)), ToTensor()])
    face_dataset = FaceDataset(extract_path, csv_filename, transform=transform)
    sample = face_dataset[0]
    plt.imshow(sample['image'].permute((1,2,0)), cmap='gray')
    plt.scatter(sample['point_x'], sample['point_y'], c='r', s=2)
    plt.title('face')
    

    在这里插入图片描述

    使用Torch内置的loader加速读取数据

    data_loader = DataLoader(face_dataset, batch_size=4, shuffle=True, num_workers=0)
    for i in data_loader:
        print(i['image'].shape)
        break
    
    torch.Size([4, 3, 1024, 512])
    

    注意: windows环境尽量不使用num_workers会发生报错

    总结

    这节使用内置的数据读取模块,帮助我们规范代码,也帮助我们简化代码,加速读取数据也可以加速训练,数据的增广可以大大的增加我们的训练精度,所以本节也是训练中比较重要环节

    上节回归

    PyTorch使用教程-超详细PyTorch实现手写数字识别器

    预习

    PyTorch使用教程-迁移学习

    展开全文
  • PyTorch使用教程-安装与基本使用

    千次阅读 2020-08-28 07:46:01
    PyTorch使用教程-安装与基本使用 什么要学习PyTorch? 有的人总是选择,选择的人最多的框架,来作为自己的初学框架,比如Tensorflow,但是大多论文的实现都是基于PyTorch的,如果我们要深入论文的细节,就必须选择学习入门...

    PyTorch使用教程-安装与基本使用

    什么要学习PyTorch?

    • 有的人总是选择,选择的人最多的框架,来作为自己的初学框架,比如Tensorflow,但是大多论文的实现都是基于PyTorch的,如果我们要深入论文的细节,就必须选择学习入门PyTorch

    安装PyTorch

    pip install torch===1.6.0 torchvision===0.7.0 -f https://download.pytorch.org/whl/torch_stable.html
    

    时间较久,耐心等待

    测试自己是否安装成功

    运行命令测试

    import torch
    x = torch.rand(5,3)
    print(x)
    

    输出

    tensor([[0.5096, 0.1209, 0.7721],
            [0.9486, 0.8676, 0.2157],
            [0.0586, 0.3467, 0.5015],
            [0.9470, 0.5654, 0.9317],
            [0.2127, 0.2386, 0.0629]])
    

    开始学习PyTorch

    不初始化的创建张量

    import torch
    x = torch.empty([5,5])
    print(x)
    

    输出

    tensor([[0., 0., 0.],
            [0., 0., 0.],
            [0., 0., 0.],
            [0., 0., 0.],
            [0., 0., 0.]])
    

    随机创建一个0-1的张量

    import torch
    x = torch.rand(5,5)
    print(x)
    

    输出

    tensor([[0.3369, 0.5339, 0.8419, 0.6857, 0.6241],
            [0.4991, 0.1691, 0.8356, 0.4574, 0.0395],
            [0.9714, 0.2975, 0.9322, 0.5213, 0.8509],
            [0.3037, 0.8690, 0.3481, 0.2538, 0.9513],
            [0.0156, 0.9516, 0.3674, 0.1831, 0.6466]])
    

    创建全为0的张量

    import torch
    x = torch.zeros(5,5, dtype=torch.float32)
    print(x)
    

    创建的时候可以通过dtype指定数据类型
    输出

    tensor([[0., 0., 0., 0., 0.],
            [0., 0., 0., 0., 0.],
            [0., 0., 0., 0., 0.],
            [0., 0., 0., 0., 0.],
            [0., 0., 0., 0., 0.]])
    
    

    使用数据来直接创建张量

    import torch
    x = torch.zeros([5,5], dtype=torch.float32)
    print(x)
    

    输出

    tensor([5., 5.])
    

    使用原有tensor创建新的tensor

    import torch
    x = torch.tensor([5,5], dtype=torch.float32)
    x = x.new_zeros(5, 3)
    y = torch.rand_like(x)
    print(x)
    print(y)
    

    输出

    tensor([[0., 0., 0.],
            [0., 0., 0.],
            [0., 0., 0.],
            [0., 0., 0.],
            [0., 0., 0.]])
    tensor([[0.5552, 0.3333, 0.0426],
            [0.3861, 0.3945, 0.6658],
            [0.6978, 0.3508, 0.4813],
            [0.8193, 0.2274, 0.8384],
            [0.9360, 0.9226, 0.1453]])
    

    观察tensor的维度信息

    x = torch.rand(3,3)
    x.size()
    

    输出

    torch.Size([3, 3])
    

    一些简单的运算

    x = torch.tensor([1])
    y = torch.tensor([3])
    '''
    方式1
    '''
    z = x + y
    '''
    方式2
    ''' 
    z = torch.add(x, y)
    '''
    方式3
    '''
    result = torch.empty(1)
    # 不初始化数据
    torch.add(x, y, out=result)
    # 将结果返回到result中
    '''
    方式4
    '''
    x.add_(y)
    

    输出

    tensor([4])
    

    索引操作

    x = torch.rand(5,5)
    x[:,:]
    x[1,:]
    x[:,1]
    x[1,1]
    

    分别输出

    tensor([[0.4012, 0.2604, 0.1720, 0.0996, 0.7806],
            [0.8734, 0.9087, 0.4828, 0.3543, 0.2375],
            [0.0924, 0.9040, 0.4408, 0.9758, 0.2250],
            [0.7179, 0.7244, 0.6165, 0.1142, 0.7363],
            [0.8504, 0.0391, 0.0753, 0.4530, 0.7372]])
    tensor([0.8734, 0.9087, 0.4828, 0.3543, 0.2375])
    tensor([0.2604, 0.9087, 0.9040, 0.7244, 0.0391])
    tensor(0.9087)
    

    维度变换

    x = torch.rand(4,4)
    x.view(16)
    x.view(8,2)
    x.view(-1,8)
    

    分别输出

    tensor([0.9277, 0.9547, 0.9487, 0.9841, 0.4114, 0.1693, 0.8691, 0.3954, 0.4679,
            0.7914, 0.7456, 0.0522, 0.0043, 0.2097, 0.5932, 0.9797])
    tensor([[0.9277, 0.9547],
            [0.9487, 0.9841],
            [0.4114, 0.1693],
            [0.8691, 0.3954],
            [0.4679, 0.7914],
            [0.7456, 0.0522],
            [0.0043, 0.2097],
            [0.5932, 0.9797]])
    tensor([[0.9277, 0.9547, 0.9487, 0.9841, 0.4114, 0.1693, 0.8691, 0.3954],
            [0.4679, 0.7914, 0.7456, 0.0522, 0.0043, 0.2097, 0.5932, 0.9797]])
    

    注意:必须维度变换数据的数量必须保持一致

    预习:自动微分

    展开全文
  • PyTorch使用教程-PyTorch构建神经网络(下) 前言 上节我们使用PyTorch自己组建了一个线性回归模型,并且我们自己实现了一个网络和优化,如果这些你都了解了那这节我们就能顺其自然的使用PyTorch给我们的封装来实现一...

    PyTorch使用教程-PyTorch构建神经网络(下)

    前言

    上节我们使用了PyTorch自己组建了一个线性回归模型,并且我们自己实现了一个网络优化,如果这些你都了解了那这节我们就能顺其自然的使用PyTorch给我们的封装来实现一个简单的DNN模型了

    网络模型

    一个简单的DNN应该有这三部分组成输入,隐藏,输出
    在这里插入图片描述
    有个好玩的游乐场
    在这里插入图片描述
    可以自己组件DNN来拟合数据,其中的超参数有:
    Learning rate:学习率,上节有讲到
    Activation:激活函数,其作用让模型具有拟合非线性数据的能力
    Regularization:正则化非常著名的有l1正则和l2正则,l1用于生成稀疏矩阵,而l2可以用来防止过拟合
    Regularization rate:正则化的超参数
    Problem type:选择模型是分类模型,还是回归模型

    模型构建

    1. 模型定义
    import torch
    from torch import nn
    import torch.nn.functional as F
    import torch.optim as optim
    class DNN(nn.Module):
        def __init__(self):
            super(DNN, self).__init__()
            self.fc1 = nn.Linear(in_features=1,out_features=128)
            self.fc2 = nn.Linear(in_features=128,out_features=1)
        def forward(self, inputs):
            x = F.relu(self.fc1(inputs))
            x = self.fc2(x)
            return x
    

    类继承nn.Module类,这样我们的类就变成一个模型了,forward前向计算,并返回结果
    2. 数据的准备(依然使用上节例子方便画出图像)

    x = torch.rand(100, 1)
    real_out = torch.tensor(10.) * x + torch.tensor(8) + torch.rand(100,1)
    
    1. 准备优化器,计算损失,循环优化到最优值
    dnn = DNN() #实例化模型,每实例化一个模型,那么参数是不相互共享的,是单独存在的
    mse = nn.MSELoss() #实例化均方误差
    adam = optim.Adam(lr=0.00001, params=dnn.parameters())
    # 需要将需要优化的参数传入params中
    for i in range(100000):
        pre_out = dnn(x) # 输入值,计算到预测值
        adam.zero_grad() # 清除梯度,为什要清除上节我们有讲到
        loss = mse(pre_out, real_out) # 计算均方误差
        loss.backward() # 自动求grad并累积到可训练参数中
        adam.step() # 执行最小化
        if (i+1) % 1000==0:
            print(loss)
    

    上节自定义的优化,可以对比学习

    for i in range(100000):
        pre_out = w * x + b
        loss = ((pre_out-real_out)**2).mean()
        loss.backward() # 自动求grad并累积到可训练参数grad中
        w.data = w.data - lr*w.grad.data # 执行最小化
        b.data = b.data - lr*b.grad.data # 执行最小化
        w.grad.data = torch.tensor(0.) # 清除梯度
        b.grad.data = torch.tensor(0.) # 清除梯度
        if (i+1) % 10000==0:
            print(loss)
    

    拟合效果的展示

    import matplotlib.pyplot as plt
    pre_out = dnn(x)
    plt.scatter(x.detach().numpy(), pre_out.detach().numpy(), c='r')
    plt.scatter(x.detach().numpy(), real_out.detach().numpy(), c='b')
    plt.show()
    

    在这里插入图片描述

    总结

    这节我们使用了,torch自带的函数帮助我们实现梯度下降,找梯度的最小值,是不是非常顺利的就可以理解了呢?

    上节回顾

    PyTorch使用教程-PyTorch构建神经网络(上)

    预习

    小试牛刀实现手写数字识别器

    展开全文
  • PyTorch使用教程-PyTorch构建神经网络(上) 前言 我们已经了解到了Pytorch的基本用法,以及自动求导的使用,有了这些预备知识我们已经可以做一个最简单的逻辑回归模型了 准备 最简单的回归模型莫过于二元一次模型了 y =...

    PyTorch使用教程-PyTorch构建神经网络(上)

    前言

    我们已经了解到了Pytorch的基本用法,以及自动求导的使用,有了这些预备知识我们已经可以做一个最简单的逻辑回归模型了

    准备

    最简单的回归模型莫过于二元一次模型了
    y = w * x + b
    自定义准备wb,我们要做的就是学习样本数据,然后反推出wb的值,但是不一定是最准确的,但我们要尽可能找到最优的
    输入,使用均匀分布的100个0-1的随机数

    x = torch.rand(100, 1)
    

    输出,由于我们模拟真实环境,因此偏置上我们再随机的产生噪声让他去影响原数据

    real_out = w * x + b + torch.rand(100,1)
    

    画出样本数据的分布

    plt.scatter(x.numpy(), real_out.numpy())
    plt.show()
    

    在这里插入图片描述
    :我设置的wb分别是108.8

    初始化训练程序

    初始化wb

    w = torch.tensor(0.)
    w.requires_grad_(True)
    b = torch.tensor(0.)
    b.requires_grad_(True)
    lr = torch.tensor(0.001)
    

    注释:由于我们需要对wb求导,因此需要设置requires_gradTrue

    训练主程序

    for i in range(100000):
        pre_out = w * x + b
        loss = ((pre_out-real_out)**2).mean()
        loss.backward()
        w.data = w.data - lr*w.grad.data
        b.data = b.data - lr*b.grad.data
        w.grad.data = torch.tensor(0.)
        b.grad.data = torch.tensor(0.)
        if (i+1) % 10000==0:
            print(loss)
    

    注释:backward后自动将grad累积到requires_gradTrue的对应tensorgrad上,因此每算一步梯度更新参数后,都需要将累计的梯度清零,读者可以试试不清零会发生什么对应代码

    w.grad.data = torch.tensor(0.)
    b.grad.data = torch.tensor(0.)
    

    由于梯度计算出来的方向是,指向越来越大的方向的,因此需要加上负号
    对应代码

    w.data = w.data - lr*w.grad.data
    b.data = b.data - lr*b.grad.data
    

    其中lr是非常重要的超参数,意义是学习率
    在这里插入图片描述

    1. 学习率时间足够长那么我们的模型可以到达一个局部最优值,能收敛
    2. 学习率过大就会导致模型来回振荡而无法收敛

    训练结果

    print('pre_w:{} pre_b:{}'.format(w.detach().numpy(), b.detach().numpy()))
    pre_out = w * x + b
    plt.plot(x.detach().numpy(), pre_out.detach().numpy(), c='r')
    plt.scatter(x.detach().numpy(), real_out.detach().numpy(), c='b')
    plt.show()
    

    w=10b=8.8

    pre_w:9.886486053466797 pre_b:9.393828392028809
    

    蓝色圆点是原数据,红色直线为预测直线,效果还不错
    在这里插入图片描述

    总结

    本节使用了上节学到的backward就实现了一个简单的线性回归模型,优化器或梯度清零虽然有高层的api封装,但是我们也必须了解其原理才能更加深刻的理解梯度下降,帮助我们后面进行DIY

    上节

    PyTorch使用教程-导数应用

    预习

    PyTorch使用教程-PyTorch构建神经网络(下)

    展开全文
  • 学习笔记|Pytorch使用教程19 本学习笔记主要摘自“深度之眼”,做一个总结,方便查阅。 使用Pytorch版本为1.2 TensorBoard简介 TensorBoard安装 TensorBoard运行可视化 一.TensorBoard简介 二.TensorBoard安装 三....
  • 学习笔记|Pytorch使用教程23 本学习笔记主要摘自“深度之眼”,做一个总结,方便查阅。 使用Pytorch版本为1.2 正则化与偏差方差分解 pytorch中的L2正则项weight decay 一.正则化与偏差方差分解 Regularization:...
  • PyTorch使用教程-迁移学习 前言 如果你认为深度学习非常的吃GPU,或者说非常的耗时间,训练一个模型要非常久,但是你如果了解了迁移学习那你的模型可能只需要几分钟,而且准确率不比你自己训练的模型准确率低,本节...
  • 超详细PyTorch实现手写数字识别器 ...我们使用pytorch自带的包进行数据的预处理 import torch import torchvision import torchvision.transforms as transforms import numpy as np import matplotlib

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,137
精华内容 8,854
关键字:

pytorch使用教程