Como dividir um conjunto de dados em lotes com Python

Neste guia, você aprenderá:

• A definição de lote
• Por que processar conjuntos de dados em lote
• Como dividir conjuntos de dados em lotes no Python
• A abordagem da opção batch do mapa de conjuntos de dados

Vamos começar!

O que é um lote?

No mundo do aprendizado de máquina e do processamento de dados, um lote nada mais é do que um subconjunto de um Conjunto de dados. Os lotes são normalmente usados para lidar com grandes volumes de dados de maneira eficiente. Em vez de processar um Conjunto de dados inteiro de uma só vez, os dados são divididos em pedaços menores, também chamados de lotes. Cada lote pode ser processado independentemente, ajudando a reduzir o uso de memória e melhorar a eficiência computacional.

Por exemplo, suponha que você tenha alguns dados de amostra no formato CSV:

id,nome,idade,pontuação
1,John,28,85
2,Jane,34,90
3,Bob,25,72
4,Alice,30,88
5,Charlie,29,91
6,David,35,79
7,Eve,22,95
8,Frank,31,82
9,Grace,27,86
10,Hannah,26,80

Um lote do conjunto de dados acima é:

6, David, 35, 79
7, Eve, 22, 95
8, Frank, 31, 82
9, Grace, 27, 86
10, Hannah, 26, 80

Este lote divide o conjunto de dados original da linha 5 à 10.

Benefícios de usar o processamento de um conjunto de dados por meio de lotes

Suponha que você tenha um conjunto de dados criado usando algumas técnicas de obtenção de dados. Se você não estiver familiarizado com esse processo, siga nosso guia sobre como criar um conjunto de dados.

Agora, por que você desejaria processar esses conjuntos de dados em lotes? Porque isso traz os seguintes benefícios:

• Eficiência de memória: trabalhe com partes menores e mais gerenciáveis de cada vez, em vez de carregar todo o Conjunto de dados na memória
• Processamento mais rápido: o processamento em lotes pode ser paralelizado, reduzindo o tempo necessário para processar grandes conjuntos de dados.
• Melhor treinamento para modelos de ML: ajude no treinamento de modelos de aprendizado de máquina atualizando pesos incrementalmente, o que pode resultar em uma convergência mais estável e rápida.
• Escalabilidade aprimorada: facilite o dimensionamento do seu processamento para grandes Conjuntos de dados que podem não caber na memória de uma só vez.

Como dividir os Conjuntos de Dados em lotes: as 5 principais abordagens

Antes de explorar os melhores métodos Python para dividir um conjunto de dados em lotes, devemos identificar alguns critérios para avaliar essas abordagens. Aqui está uma lista significativa de aspectos a serem considerados:

• Implementação: um trecho de código para mostrar como usar a abordagem em um exemplo simples.
• Cenários: as situações do mundo real em que a abordagem de divisão de Conjuntos de dados é aplicável.
• Entrada: os tipos de arquivos de Conjuntos de dados e estruturas de dados que a estratégia de divisão suporta.
• Prós: os benefícios proporcionados pela abordagem.
• Contras: as limitações ou desvantagens do método.

É hora de analisá-los um por um!

Abordagem nº 1: Divisão de matrizes

O corte de matriz é um método simples para dividir um conjunto de dados em lotes menores e mais gerenciáveis. A ideia é dividir um conjunto de dados (representado por uma lista, matriz ou outra sequência) em pedaços, cortando-o.

👨‍💻 Implementação:

def create_batches(data, batch_size):
    return [data[i:i + batch_size] for i in range(0, len(data), batch_size)]

# exemplo de uso
data = list(range(1, 51))  # conjunto de dados de amostra
batches = create_batches(data, batch_size=5)

print(lotes) 

# saída: [[1, 2, 3, 4, 5], ..., [46, 47, 48, 49, 50]]

🎯 Cenários:

• Tarefas de pré-processamento de dados em que as limitações de memória são mínimas
• Tarefas de processamento de dados paralelo que exigem blocos gerenciáveis na memória
• Processamento em lote simples em pipelines de dados

🔠 Entrada:

• Listas, matrizes e tuplas em Python.
• Matrizes Numpy
• Dados CSV, carregados na memória como uma lista de linhas
• Pandas DataFrames, se convertidos em listas ou matrizes

👍 Prós:

• Simples e fácil de implementar
• Não requer bibliotecas externas
• Oferece controle direto sobre os tamanhos dos lotes

👎 Contras:

• Limitado pela memória disponível
• Não suporta Conjuntos de dados extremamente grandes ou estruturas de dados complexas
• Requer lógica personalizada para reorganização de dados

Abordagem nº 2: Geradores

Os geradores Python permitem dividir um conjunto de dados em lotes, produzindo um lote de cada vez. Se você não está familiarizado com esse mecanismo, um gerador é um tipo especial de função que se comporta como um iterador. Em vez de retornar dados diretamente, ele usa a palavra-chave yield para produzir um objeto iterador. Isso permite que os lotes sejam acessados sequencialmente usando um loop for ou a função next().

👨‍💻 Implementação:

def data_generator(data, batch_size):
    for i in range(0, len(data), batch_size):
        yield data[i:i + batch_size]

# exemplo de uso
data = list(range(1, 51))  # conjunto de dados de amostra
for batch in data_generator(data, batch_size=5):
    print(batch)

# saída: 
# [1, 2, 3, 4, 5]
# ...
# [46, 47, 48, 49, 50]

🎯 Cenários:

• Processamento em lote em pipelines de dados
• Tarefas de pré-processamento e aumento de dados em grande escala
• Do processamento em lote simples ao complexo em pipelines de dados

🔠 Entrada:

• Listas, matrizes e tuplas
• Matrizes NumPy
• Conjuntos de dados baseados em arquivos, nos quais é possível carregar cada lote do disco

👍 Prós:

• Podem lidar com grandes conjuntos de dados sem carregá-los totalmente na memória
• Configuração mínima e fácil de implementar
• Permite o carregamento controlado de dados sob demanda

👎 Contras:

• Limitado pela ordem dos dados, a menos que seja implementada uma reorganização adicional
• Menos eficaz para tamanhos de lote dinâmicos ou variáveis
• Pode não ser a melhor solução para processamento paralelo, especialmente em operações multithread

Abordagem nº 3: PyTorch DataLoader

A classe DataLoader do PyTorch ajuda a dividir Conjuntos de dados em lotes gerenciáveis de maneira eficiente. Como uma estrutura de dados especializada para lidar com Conjuntos de dados, ela também oferece recursos úteis, como embaralhamento e carregamento paralelo de dados.

Observe que o DataLoader funciona com o TensorDataset, outra estrutura de dados do PyTorch destinada a representar um Conjunto de dados. Especificamente, um TensorDataset aceita dois argumentos:

1. inps: os dados de entrada, normalmente na forma de um Tensor.
2. tgts: os rótulos ou valores-alvo, também normalmente como um tensor, correspondentes aos dados de entrada.

O TensorDataset emparelha os dados e o alvo, que podem então ser carregados pelo DataLoader para agrupamento e treinamento.

👨‍💻 Implementação:

from torch.utils.data import DataLoader, TensorDataset
import torch

# dados para definir um conjunto de dados simples
inputs = torch.arange(1, 51).float().reshape(-1, 1)  # um conjunto de dados tensor 1D (entrada)
targets = inputs ** 2  # quadrado dos valores de entrada (simulando uma tarefa de regressão)

# criar um TensorDataset e um DataLoader
dataset = TensorDataset(inputs, targets)
dataloader = DataLoader(dataset, batch_size=5, shuffle=True)

# iterar através do DataLoader
para batch no dataloader:
    imprimir(batch)

# amostra de saída:
# [tensor([[46.],
#         [42.],
#         [25.],
#         [10.],
#         [34.]]), tensor([[2116.],
#         [1764.],
#         [ 625.],
#         [ 100.],
#         [1156.]])]
# ...
# [tensor([[21.],
#         [ 9.],
#         [ 2.],
#         [38.],
#         [44.]]), tensor([[441.],
#         [  81.],
#         [   4.],
#         [1444.],
#         [1936.]])] 

🎯 Cenários:

• Treinamento e teste de modelos de aprendizado de máquina no PyTorch
• Embaralhamento de dados para lotes de treinamento imparciais
• Processamento de dados em grande escala para tarefas de aprendizado profundo

🔠 Entrada:

• Conjuntos de dados personalizados carregados no PyTorch TensorDatasets
• Dados tabulares e matrizes numéricas no formato Tensor

👍 Prós:

• Otimizado para grandes conjuntos de dados com agrupamento e embaralhamento
• Suporta carregamento paralelo de dados, acelerando a recuperação em lote
• Funciona perfeitamente com modelos PyTorch e loops de treinamento
• Compatível com processamento por GPU

👎 Contras:

• Requer PyTorch
• Requer conversão de dados para tensores.
• Não é ideal para tarefas de processamento em lote que não sejam de ML

Abordagem nº 4: Método TensorFlow batch()

O método TensorFlow Dataset batch() para dividir Conjuntos de dados em lotes. Esse método divide o conjunto de dados em partes menores, com recursos como paralelização, controle sobre a ordem de processamento e nomenclatura.

Como biblioteca de aprendizado de máquina, o TensorFlow também oferece recursos adicionais, como embaralhamento, repetição e pré-busca.

👨‍💻 Implementação:

import tensorflow as tf

# criar um conjunto de dados de amostra
inputs = tf.range(1, 51, dtype=tf.float32)  # um conjunto de dados de tensor 1D (entradas)
targets = inputs ** 2  # quadrado dos valores de entrada (simulando uma tarefa de regressão)

# converter as entradas e os alvos em tf.data.Dataset
inputs_dataset = tf.data.Dataset.from_tensor_slices(inputs)
targets_dataset = tf.data.Dataset.from_tensor_slices(targets)

# criar um conjunto de dados compactando as entradas e os alvos juntos
dataset = tf.data.Dataset.zip((inputs_dataset, targets_dataset))

# produzir um conjunto de dados em lote
batched_dataset = dataset.batch(batch_size=5)

para batch em batched_dataset:
    imprimir(batch)

# saída:
# (<tf.Tensor: shape=(5,), dtype=float32, numpy=array([1., 2., 3., 4., 5.], dtype=float32)>, <tf.Tensor: shape=(5,), dtype=float32, numpy=array([ 1.,  4.,  9., 16., 25.], dtype=float32)>)
# ...
# (<tf.Tensor: shape=(5,), dtype=float32, numpy=array([46., 47., 48., 49., 50.], dtype=float32)>, <tf.Tensor: shape=(5,), dtype=float32, numpy=array([2116., 2209., 2304., 2401., 2500.], dtype=float32)>)

🎯 Cenários:

• Treinamento e teste de modelos de aprendizado de máquina no PyTorch
• Embaralhamento de dados para lotes de treinamento imparciais
• Processamento de dados em grande escala para tarefas de aprendizado profundo

🔠 Entrada:

• Objetos TensorFlow tf.data.Dataset
• Matrizes NumPy (que podem ser convertidas para Conjuntos de dados)
• Arquivos TFRecord, um formato de arquivo binário especial comumente usado para armazenar grandes conjuntos de dados no TensorFlow

👍 Prós:

• Otimizado para uso eficiente da memória
• Integra-se perfeitamente ao ecossistema TensorFlow para treinamento e avaliação de modelos
• Suporta embaralhamento, pré-busca e outros recursos úteis
• Suporta uma ampla variedade de formatos de dados, incluindo imagens, texto e dados estruturados

👎 Contras:

• Requer o TensorFlow
• Para conjuntos de dados mais complexos, pode ser necessária uma configuração adicional para formatar e pré-processar os dados adequadamente
• Pode introduzir sobrecarga para o processamento em lote de conjuntos de dados menores

Abordagem nº 5: Formato HDF5

HDF5 é um formato de dados amplamente adotado para gerenciar grandes conjuntos de dados, especialmente quando se lida com estruturas de dados hierárquicas. Ele oferece suporte à divisão de um grande conjunto de dados em partes e ao armazenamento eficiente dessas partes.

A biblioteca Python h5py fornece ferramentas para trabalhar com arquivos HDF5 e carregá-los como estruturas de dados NumPy. Isso abre as portas para o processamento em lote de Conjuntos de dados, acessando fatias ou segmentos específicos de dados sob demanda.

👨‍💻 Implementação:

import h5py
import numpy as np

# carregar e agrupar os dados do arquivo HDF5
def load_data_in_batches(batch_size=10):
    # abrir um arquivo HDF5
    with h5py.File("dataset.h5", "r") as f:
        inputs = f["input"]
        targets = f["target"]

        # agrupar os dados com um iterador do disco
        for i in range(0, len(data), tamanho_do_lote):
            yield entradas[i:i+tamanho_do_lote], alvos[i:i+tamanho_do_lote]

# iterar pelos lotes
para batch_data, batch_target em load_data_in_batches():
    imprimir("Lote de entrada:", batch_input)
    imprimir("Lote de destino:", batch_target)

# saída:
# Lote de entrada: [[ 1]
#  [ 2]
#  [ 3]
#  [ 4]
#  [ 5]
#  [ 6]
#  [ 7]
#  [ 8]
#  [ 9]
#  [10]]
# Lote de destino: [[  1]
#  [  4]
#  [  9]
#  [ 16]
#  [ 25]
#  [ 36]
#  [ 49]
#  [ 64]
#  [ 81]
#  [100]]
#  ...
# Lote de entrada: [[41]
#  [42]
#  [43]
#  [44]
#  [45]
#  [46]
#  [47]
#  [48]
#  [49]
#  [50]]
# Lote de destino: [[1681]
#  [1764]
#  [1849]
#  [1936]
#  [2026]
#  [2116]
#  [2209]
#  [2304]
#  [2401]
#  [2500]]

🎯 Cenários:

• Ideal para conjuntos de dados muito grandes que não podem ser carregados inteiramente na memória
• Útil ao trabalhar com dados multidimensionais
• Adequado para armazenar e recuperar dados do disco em um formato eficiente e compactado para tarefas de aprendizado de máquina

🔠 Entrada:

• Arquivos HDF5

👍 Prós:

• O HDF5 suporta compactação e fragmentação de dados, reduzindo os requisitos de armazenamento para grandes Conjuntos de dados
• Permite acesso aleatório eficiente a partes de grandes Conjuntos de dados sem carregar tudo na memória
• Pode armazenar vários Conjuntos de dados em um único arquivo, tornando-o adequado para Conjuntos de dados complexos.
• Suportado por muitas bibliotecas científicas, incluindo NumPy, TensorFlow e PyTorch

👎 Contras:

• Requer configuração adicional e conhecimento do formato HDF5
• Para uma API completa para lidar com arquivos HDF5, depende da biblioteca h5py
• Nem todos os conjuntos de dados estão disponíveis no formato HDF5

Outras soluções

Embora as abordagens apresentadas acima estejam entre as melhores maneiras de dividir um conjunto de dados em lotes, também existem outras soluções viáveis.

Outra solução possível é usar a biblioteca de Conjuntos de Dados Hugging Face. Ela fornece tudo o que você precisa para aplicar transformações a um conjunto de dados inteiro enquanto o processa em lote. Ao definir batched=True, você pode definir transformações em nível de lote sem dividir manualmente o conjunto de dados, como no exemplo abaixo:

from Conjuntos de dados import load_dataset

# carregar um conjunto de dados de amostra
dataset = load_dataset("imdb", split="train")

# definir uma função de processamento em lote
def process_batch(batch):
    # tarefa simples de tokenização
    return {"tokens": [text.split() for text in batch["text"]]}

# aplicar processamento em lote
batched_dataset = dataset.map(process_batch, batched=True, batch_size=32)

A opção dataset map() batched=True é ideal quando você precisa aplicar transformações, como tokenização, em lotes.

Observe que usar map(batched=True) é altamente eficiente para processar lotes, pois minimiza o uso de memória e acelera os fluxos de trabalho de transformação. Esse método é particularmente útil para lidar com texto e dados tabulares em tarefas de NLP e aprendizado de máquina.

Conclusão

Neste guia sobre como dividir um conjunto de dados em lotes, você explorou as melhores abordagens, bibliotecas e soluções para dividir dados em Python. O objetivo é dividir um grande conjunto de dados em partes mais gerenciáveis para simplificar e acelerar o processamento de dados.

Independentemente da abordagem escolhida, todas as soluções acima dependem do acesso a um conjunto de dados com as informações de interesse. Embora alguns conjuntos de dados estejam disponíveis gratuitamente para pesquisa científica, nem sempre é esse o caso.

Se você precisar de conjuntos de dados que abranjam categorias que vão desde finanças até dados de filmes, dê uma olhada no Dataset Marketplace da Bright Data. Ele fornece acesso a centenas de conjuntos de dados de sites populares, categorizados em:

• Conjuntos de dados comerciais: dados de fontes importantes como LinkedIn, CrunchBase, Owler e Indeed.
• Conjuntos de dados de comércio eletrônico: dados da Amazon, Walmart, Target, Zara, Zalando, Asos e muitos outros.
• Conjuntos de dados imobiliários: dados de sites como Zillow, MLS e outros.
• Conjuntos de dados de mídias sociais: dados do Facebook, Instagram, YouTube e Reddit.
• Conjuntos de dados financeiros: dados do Yahoo Finance, Market Watch, Investopedia e muito mais.

Se essas opções pré-definidas não atenderem às suas necessidades, considere nossosserviços personalizados de coleta de dados.

Além disso, a Bright Data oferece uma ampla gama de ferramentas poderosas de scraping, incluindo APIs de Scraping de dados e Navegador de scraping.

Crie uma conta Bright Data gratuitamente para começar a explorar esses Conjuntos de dados!