大模型训练，高效低成本打乱shuffle数据的新算法

已于 2024-01-18 19:37:38 修改
阅读量529 收藏 8
点赞数 10
文章标签： 算法 语言模型 金融 深度学习 数据挖掘 人工智能 机器学习
于 2024-01-18 19:30:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51484067/article/details/135680137
版权

如果训练数据很多的话，就不能够使用pytorch提供的Dataset类来实现数据的读取了，因为这个类会在训练前生成一个跟数据量成比例的缓存，如果数据量达到100亿个数据点以上的话，占用的内存可能达到1TB以上，而且代码的运行效率也会显著下降。

查了一下google，发现有很多人有类似的需求，但是没有人提出了解决方案。在pytorch的issue栏目中可以看到类似的需求，最后也是没有提出解决方案。

在这里插入图片描述

当数据量太大时，我们需要使用IterableDataset来从硬盘直接读取数据。可以参考如下的方式进行实现（ 效率上应该可以与tfrecord等数据存储结构 持平，不需要过度优化即可打满GPU IO ）：

import base64
import numpy as np

import torch
from torch.utils.data import DataLoader, Dataset
from torch.utils.data import IterableDataset
import torch.distributed as dist

class D(IterableDataset):

    def __init__(self, path, number_of_sample, num_workers=4, training=False):
        self.training = training
        self.num_workers = num_workers
        self.handles = [open(path, 'r') for _ in range(num_workers)] 
        self.LEN = number_of_sample

    def __len__(self):
        return self.LEN

    def __iter__(self):
        rank = dist.get_rank()
        world_size = dist.get_world_size()

        worker_info = torch.utils.data.get_worker_info()

        mod = world_size
        shift = rank

        if worker_info:
            mod *= worker_info.num_workers
            shift = rank * worker_info.num_workers + worker_info.id

        for i in range(self.LEN):
            if (i + shift) % mod == 0:
                yield self.__getitem__(i)
    def __getline__(self, idx):
    	# 按照这个思路即可
    	return idx * 32

    def __getitem__(self, idx, ):
        worker_id = torch.utils.data.get_worker_info().id
        
        # 读取数据
        self.handles_feat[worker_id].seek(self.__getline__(idx))
        data, label= self.handles_feat[d][worker_id].readline().strip().split('\t')
        
        data = np.frombuffer(base64.b64decode(data), dtype=np.float32).ravel()
        label = np.frombuffer(base64.b64decode(label), dtype=np.float32).ravel()

        data = torch.FloatTensor(data)
        label = torch.FloatTensor(label)

        return {'data': data, 'label': label}

IterableDataset不支持shuffle

如果使用IterableDataset的话，则会遇到它并不支持shuffle的窘境。如果在内存中尝试对list(self.__len__) 进行shuffle的话，会生成一个数TB大小的index array，再加上训练的内存消耗，还没开始训练电脑已经重启了！

有没有方案能够不占用大量的内存，也可以对数据进行充分shuffle呢？如果我们不考虑丢失数据的话，可以直接在 数据size 的范围内随机生成index，但是这样的话，会丢失数据显然不是我们希望的结果。但是如果数据不进行充分shuffle的话，训练出来的模型效果会显著得变差。

方案一

在训练前独立进行数据的shuffle，例如通过 Map-Reduce 对于数据进行shuffle，这里的操作比较基础，就不给出实现代码了。

方案二

对数据进行分块shuffle，或者使用一个较大的buffer进行shuffle。但是分块如果太细的话，shuffle不够充分；分块太大的话，效率上又会显著低一些。而且性能上始终无法比得上完全随机shuffle。从实际跑出来的效果上来看，模型的性能确实下降了很多。

最终解决方案

这里的主要问题是，我们没办法把所有的index都放进内存进行排序，如果能存在某种函数，能实现在任意范围内建立一个映射关系，映射后的序列与原序列是一一对应，同时又“均匀”分布的话，是不是就能够实现shuffle数据的目标了？我们这里给出如下的解决方案。我们知道素数只能够被自己或者1整除，利用这个特性，我们可以建立一种一一映射的关系。

import numpy as np
N = 200
a = np.arange(N)
sep = 200
primenumber = 11

a_shuffle = (a%sep)*primenumber%sep + a//sep*sep
print('打乱后数组和元素组的不同元素个数：', len(set(a)-set((a%sep)*primenumber%sep + a//sep*sep)))
print(a_shuffle )

输出的结果为

打乱后数组和元素组的不同元素个数：0
array([  0,  11,  22,  33,  44,  55,  66,  77,  88,  99, 110, 121, 132,
       143, 154, 165, 176, 187, 198,   9,  20,  31,  42,  53,  64,  75,
        86,  97, 108, 119, 130, 141, 152, 163, 174, 185, 196,   7,  18,
        29,  40,  51,  62,  73,  84,  95, 106, 117, 128, 139, 150, 161,
       172, 183, 194,   5,  16,  27,  38,  49,  60,  71,  82,  93, 104,
       115, 126, 137, 148, 159, 170, 181, 192,   3,  14,  25,  36,  47,
        58,  69,  80,  91, 102, 113, 124, 135, 146, 157, 168, 179, 190,
         1,  12,  23,  34,  45,  56,  67,  78,  89, 100, 111, 122, 133,
       144, 155, 166, 177, 188, 199,  10,  21,  32,  43,  54,  65,  76,
        87,  98, 109, 120, 131, 142, 153, 164, 175, 186, 197,   8,  19,
        30,  41,  52,  63,  74,  85,  96, 107, 118, 129, 140, 151, 162,
       173, 184, 195,   6,  17,  28,  39,  50,  61,  72,  83,  94, 105,
       116, 127, 138, 149, 160, 171, 182, 193,   4,  15,  26,  37,  48,
        59,  70,  81,  92, 103, 114, 125, 136, 147, 158, 169, 180, 191,
         2,  13,  24,  35,  46,  57,  68,  79,  90, 101, 112, 123, 134,
       145, 156, 167, 178, 189])

我们这里得到的结果是对于原数据的一一映射，且会按照素数作为间隔采样。但是我们可能认为它不够“随机”，我们可以用到这里给出的sep超参数来加以优化，让它更加“随机”。这里整理成一个新的shuffle函数：

def shuffle_zhou(a, N, depth=1, seed=10086):
    import random
    random.seed(seed)

    primes = [23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,]

    for d in range(depth):
        sep = N//10**(depth-d-1)
        primenumber = random.choice(primes)
        a = (a%sep)*primenumber%sep + a//sep*sep

    return a 

N = 1000
a = np.arange(N)

import matplotlib.pyplot as plt 
plt.plot(a, shuffle_zhou(a, N), '.')

输出如下，可以看出分布比较均匀，可以近似为随机分布。
在这里插入图片描述

总结

最终优化后的shuffleb版本IterableDataset如下，

import base64
import numpy as np

import torch
from torch.utils.data import DataLoader, Dataset
from torch.utils.data import IterableDataset
import torch.distributed as dist

def shuffle_zhou(a, N, depth=3, seed=10086):
    import random
    random.seed(seed)

    primes = [23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,]

    for d in range(depth):
        sep = N//10**(depth-d-1)
        primenumber = random.choice(primes)
        a = (a%sep)*primenumber%sep + a//sep*sep

    return a 
    
class D(IterableDataset):
    def __init__(self, path, number_of_sample, num_workers=4, training=False):
        self.training = training
        self.num_workers = num_workers
        self.handles = [open(path, 'r') for _ in range(num_workers)] 
        self.LEN = number_of_sample
        self.seed = 10086

    def __len__(self):
        return self.LEN

	def __setseed__(self, seed=10086):
		self.seed = seed
		
    def __iter__(self):
        rank = dist.get_rank()
        world_size = dist.get_world_size()

        worker_info = torch.utils.data.get_worker_info()

        mod = world_size
        shift = rank

        if worker_info:
            mod *= worker_info.num_workers
            shift = rank * worker_info.num_workers + worker_info.id
		
        for i in range(self.LEN):
        	i = shuffle_zhou(i, self.LEN, seed=self.seed)
            if (i + shift) % mod == 0:
                yield self.__getitem__(i)
                
    def __getline__(self, idx):
    	# 按照这个思路即可
    	return idx * 32

    def __getitem__(self, idx, ):
        worker_id = torch.utils.data.get_worker_info().id
        
        # 读取数据
        self.handles_feat[worker_id].seek(self.__getline__(idx))
        data, label= self.handles_feat[d][worker_id].readline().strip().split('\t')
        
        data = np.frombuffer(base64.b64decode(data), dtype=np.float32).ravel()
        label = np.frombuffer(base64.b64decode(label), dtype=np.float32).ravel()

        data = torch.FloatTensor(data)
        label = torch.FloatTensor(label)

        return {'data': data, 'label': label}
无敌叉烧包z
关注
  • 10
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
MATLAB算法实战应用案例精讲-【大模型】LLM算法（最终篇）
qq_36130719的博客
09-09 301
大型语言模型（LLM）经过大量文本数据的训练，使它们能够理解人类语言的含义和上下文。以前，大多数模型都是使用监督方法进行训练的，我们提供输入特征和相应的标签。与此不同的是，LLM是通过无监督学习进行训练的，他们接受大量没有任何标签和指令的文本数据。因此，LLM可以有效地学习语言单词之间的含义和关系。它们可用于各种任务，例如文本生成、问答、从一种语言翻译为另一种语言等等。下一步是加载和预处理数据。可以使用 pytorch 的 utils.data 模块中的 Dataset 类为数据集定义自定义类。
机器学习，深度学习模型训练阶段的Shuffle重要么？为什么？
热门推荐
NLP翟
03-28 2万+
模型训练中的Shuffle什么是Shuffle？模型训练过程中需要Shuffle么？Shuffle为什么重要？小结Reference 什么是Shuffle？ shuffle（中文意思：洗牌，混乱）。shuffle在机器学习与深度学习中代表的意思是，将训练模型的数据集进行打乱的操作。 原始的数据，在样本均衡的情况下可能是按照某种顺序进行排列，如前半部分为某一类别的数据，后半部分为另一类别的数据。但经...
浅谈深度学习shuffle问题
不忘初心，方得始终
11-10 2938
在模型训练前，我们往往对数据进行shuffle，即随机打乱数据，为什么要这么做呢？不这么做会出现什么问题？何时应该shuffle，何时不该shuffle呢？ 下面，本文就以上三个问题发表下自己的拙见。 Q1：为什么要进行shuffle？ A1：不论是机器学习还是深度学习，我们总是基于数据独立同分布的假设条件，也就是说，数据的出现应该是随机的，而不是按照某种顺序排列好的。以上就是需要shuffle的根本原因。因此，我们需要在每个epoch的开始把数据shuffle一下。 Q2：不shuffle会.
大规模训练数据的shuffle
DeepIndeed
12-24 1657
必要性12 以猫狗分类为例， 假如数据集是 Dog，Dog，Dog，… ，Dog，Dog，Dog，Cat，Cat，Cat，Cat，… ，Cat，Cat 所有的狗都在猫前面，如果不shuffle，模型训练一段时间内只看到了Dog，必然会过拟合于Dog，一段时间内又只能看到Cat，必然又过拟合于Cat，这样的模型泛化能力必然很差。 那如果Dog和Cat一直交替，会不会就不过拟合了呢？ Dog，C...
替换手机号中间4位（php，js）
mobeinight的专栏
12-24 1630
JS方法function hideMobile(num){ var mphone =num.substr(3,4); var lphone = num.replace(mphone,"****"); return lphone; } php方法 $phone=substr_replace($phone,'****',3,4);
python对训练数据集shuffle(打乱)的一些方式
这些个事儿
10-22 1万+
1.通过数组来shuffle image_list=[] # list of images label_list=[] # list of labels temp = np.array([image_list, label_list]) temp = temp.transpose() np.random.shuffle(temp) images = ...
从零实现ChatGPT:第四章在无标签数据上预训练
jiayoushijie的博客
06-11 1158
当语言模型生成文本时，它们一次输出一个token。默认情况下，下一个token是通过将模型输出转换为概率分数并从词汇表中选择对应于最高概率分数的token来生成的，这被称为贪婪解码。使用概率采样和温度缩放，我们可以影响生成文本的多样性和连贯性。训练集和验证集损失可用于衡量语言模型在训练期间生成的文本质量。预训练语言模型涉及改变其权重以最小化训练损失。语言模型的训练循环本身是深度学习中的标准程序，使用传统的交叉熵损失和AdamW优化器。
神经网络训练梯度算法详解
山里娃的博客
08-27 2907
目录 文章目录题目The basic definitionThe motivationPaper detailed introduction梯度下降变体批梯度下降随机梯度下降算法小批量梯度下降法MBGDChallengesGradient descent optimization algorithmsMomentumNesterov accelerated gradientAdaGradRMSPr...
使用YOLOv8训练自己的【目标检测】数据集
m0_54634272的博客
04-06 2662
答:为了让计算机学会正确地识别物体，我们需要提供大量的标注数据集，这些数集包含了图像或视频中物体的位置和类别信标注数据集的作用在干，它可以帮助计算机学习到如何识别不同种类的物体，并且能够正确地定位它们的位置。但是，如果我们有了标注数据集，计算机就可以通过学习这些数据来理解猫和狗之间的差异，并且可以在新的图像中准确地识别它们。这种方法可以提供一些特殊情况或无法通过其他方式获得的图像，但是合成图像通常无法完全代替真实场景的数据，可能会对模型的准确性产生一定的影响。需要注意的是，网络上的图像可能受到版权保护。
Python Pandas 如何shuffle（打乱）数据
09-18
主要介绍了Python Pandas 如何shuffle（打乱）数据，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
易语言数据打乱加解密算法模块
08-16
易语言数据打乱加解密算法模块源码 系统结构:数据倒序,数据打乱,动态算法_加密,动态算法_解密, ======程序集1 | | | |------ _启动子程序 | | | |------ _临时子程序 | | | |------ 数据倒序 | | |
python训练数据时打乱训练数据与标签的两种方法小结
12-30
print '-------第1种方法：通过打乱索引从而打乱数据,好处是1:数据量很大时能够节约内存,2每次都不一样----------' data = np.array([[1,1],[2,2],[3,3],[4,4],[5,5]]) data_num, _= data.shape #得到样本数 index =...
指针和数组
2301_77634163的博客
06-10 436
有3个指针，中间是一个数组arr，有个指针指向中间,其他两个指向两边，一个指向前面，一个人指向后面。虽然简化好，但是我们C语言要求是不允许这样写的,虽然大部分编译器是可以允许我这样写的。下面那个用数组名也是可以用的，因为他也表示一个地址，加1就会找后面那个元素的地址。我们C语言编译器中说指针允许往后比较大小，但不允许往前比面的指针比较大小。地址向后移，指针相比较，指针减减就是减去一个整数。同一指针相减的绝对值得到的是之间元素的个数。数组和指针的地址是一样的，说明是可以的。地址加地址，指针加指针没有意义。
力扣136. 只出现一次的数字
最新发布
LNsupermali的博客
06-15 441
力扣136. 只出现一次的数字
[力扣题解] 236. 二叉树的最近公共祖先
东皇太一在此的博客
06-10 440
用深度搜索的思想（好吧，前序、中序、后序都是深搜思想），保存寻找路径，看看找到2个节点的路径的重合部分，就可以找到最近公共祖先；
算法day25
2202_76101487的博客
06-11 386
正值少年的日常打卡
(第31天)【leetcode题解】404、左叶子之和
m0_73755059的博客
06-10 337
给定二叉树的根节点 root ，返回所有左叶子之和。
算法：位运算题目练习
一名还在努力学习技术的程序员的博客
06-10 675
本篇博客是关于滑动窗口算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
pytorch打乱数据集shuffle
06-28
### 回答1： 在PyTorch中打乱数据集可以使用torch.utils.data.DataLoader中的shuffle参数。将shuffle参数设置为True即可在每个epoch开始时随机打乱数据集。例如： ``` from torch.utils.data import DataLoader train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True) ``` 这样在每个epoch开始时，train_loader会自动将数据集打乱，以确保模型训练的随机性。 ### 回答2： 在深度学习中，数据集的顺序往往是很重要的，因为样本之间可能存在一定的相关性，如果按照固定的顺序进行训练，可能会影响模型的泛化能力。因此，在训练时需要对数据集进行随机化处理，也就是使其每次迭代获取的数据都是随机的。pytorch提供了一个shuffle函数来实现数据集的随机化处理。 在pytorch中，我们可以通过调用Dataset类的shuffle方法来实现数据的随机打乱。具体实现步骤如下： 1. 在定义数据集时，实现自己的get_item方法和len方法，get_item方法返回每个样本的数据和标签，len方法返回数据集的大小。 2. 构建DataLoader，通过设置参数shuffle=True来实现数据集的随机打乱。可以通过batch_size来设置每个批次中的数据量，num_workers来设置数据加载的并行度，pin_memory来设置是否使用固定大小的内存。 3. 迭代DataLoader，逐个获取样本的数据和标签，进行训练。 需要注意的是，每个epoch需要重新进行数据集的随机化处理，否则每次获取的数据仍然是固定的，不会对模型的训练产生任何影响。在实际的训练过程中，往往需要根据实际情况来设置batch_size和num_workers的大小，并进行多次的epochs训练。 总之，在进行深度学习训练时，数据集的随机化是非常重要的一步。通过pytorch提供的shuffle方法，可以很方便地实现数据集的随机化处理，从而有效地提高模型的泛化能力。 ### 回答3： 在深度学习训练过程中，数据的顺序会影响训练结果，因为有些模型会倾向于记忆先出现的数据。因此，我们需要将数据集中的样本打乱(shuffle)，以避免训练出的模型是有偏的。 在 PyTorch 中，可以通过使用 `torch.utils.data.DataLoader` 来加载数据集，并通过设置参数 `shuffle=True` 来自动打乱数据集顺序。 `DataLoader` 是一个用于迭代数据的工具，它可以将数据集分成多个 batch，并对每个 batch 打乱样本顺序。下面是一些具体的示例代码： ```python from torchvision import datasets, transforms from torch.utils.data import DataLoader # 定义数据的变换 transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) # 加载 MNIST 数据集，并打乱顺序 train_dataset = datasets.MNIST('data', train=True, download=True, transform=transform) train_loader = DataLoader(train_dataset, shuffle=True, batch_size=64) # 迭代数据集 for data, target in train_loader: pass ``` 在上面的代码中，我们首先定义了一个 `transform` 变换，它将数据转换为张量，并正则化数据。然后，我们加载了 MNIST 数据集，并将 `shuffle` 参数设置为 `True`，以打乱数据集的顺序。最后，我们使用 `DataLoader` 来迭代数据集。 除了 `shuffle` 参数之外，还可以使用 `torch.utils.data.RandomSampler` 和 `torch.utils.data.SequentialSampler` 来手动控制数据集的顺序。 `RandomSampler` 会随机打乱样本顺序，而 `SequentialSampler` 将样本按照原来的顺序排列。需要注意的是，如果手动设置了样本顺序，那么就不需要再将 `shuffle` 参数设置为 `True`。 综上所述，对于 PyTorch 来说，打乱数据集顺序非常简单，并且可以通过 `DataLoader` 的 `shuffle` 参数来实现。这可以帮助我们避免训练出有偏的模型，提高模型的泛化能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

无敌叉烧包z

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值