Download cifar10 airbench - download do código-fonte cifar10 airbench

cifar10 airbench

Outro código-fonte

1.0.0

Baixar

Banco de ar CIFAR-10 ?

Uma coleção de scripts de treinamento rápidos e independentes para CIFAR-10.

Roteiro	Precisão média	Tempo	PFLOPs
`airbench94_compiled.py`	94,01%	3,09s	0,36
`airbench94.py`	94,01%	3,83s	0,36
`airbench95.py`	95,01%	10,4s	1.4
`airbench96.py`	96,03%	34,7s	4.9
`airbench94_muon.py`	94,01%	2,59s	0,29
`airbench96_faster.py`	96,00%	27,3s	3.1

Para efeito de comparação, o treinamento padrão usado na maioria dos estudos sobre CIFAR-10 é muito mais lento:

Linha de base	Precisão média	Tempo	PFLOPs
Treinamento padrão ResNet-18	96%	7 minutos	32,3

Todos os tempos estão em uma única GPU NVIDIA A100.

Nota: airbench96 foi melhorado desde o papel de 46s para 35s. Além disso, airbench96_faster é um método aprimorado (mas mais complicado) que usa filtragem de dados por um pequeno modelo de proxy. E airbench94_muon é um método aprimorado que usa uma variante do otimizador Muon.

O conjunto de métodos utilizados para obter essas velocidades de treinamento está descrito no artigo.

alternativo curva

Como correr

Para treinar uma rede neural com 94% de precisão, execute

 git clone https://github.com/KellerJordan/cifar10-airbench.git
cd airbench && python airbench94.py

ou

 pip install airbench
python -c "import airbench; airbench.warmup94(); airbench.train94()"

Nota: airbench94_compiled.py e airbench94.py são equivalentes (ou seja, produzem a mesma distribuição de redes treinadas) e diferem apenas porque o primeiro usa torch.compile para melhorar a utilização da GPU. O primeiro é destinado a experimentos onde muitas redes são treinadas ao mesmo tempo, a fim de amortizar o custo único de compilação.

Motivação

O CIFAR-10 é um dos conjuntos de dados mais utilizados em aprendizado de máquina, facilitando milhares de projetos de pesquisa por ano. Este repositório fornece linhas de base de treinamento rápidas e estáveis para CIFAR-10, a fim de ajudar a acelerar esta pesquisa. Os treinamentos são fornecidos como scripts PyTorch facilmente executáveis e livres de dependências e podem substituir linhas de base clássicas, como treinamento ResNet-20 ou ResNet-18.

Usando o dataloader acelerado por GPU de forma independente

Para escrever experimentos ou treinamentos CIFAR-10 personalizados, pode ser útil usar o carregador de dados acelerado por GPU de forma independente.

 import airbench
train_loader = airbench.CifarLoader('/tmp/cifar10', train=True, aug=dict(flip=True, translate=4, cutout=16), batch_size=500)
test_loader = airbench.CifarLoader('/tmp/cifar10', train=False, batch_size=1000)

for epoch in range(200):
    for inputs, labels in train_loader:
        # outputs = model(inputs)
        # loss = F.cross_entropy(outputs, labels)
        ...

Se você deseja modificar os dados no carregador, pode fazer assim:

 import airbench
train_loader = airbench.CifarLoader('/tmp/cifar10', train=True, aug=dict(flip=True, translate=4, cutout=16), batch_size=500)
mask = (train_loader.labels < 6) # (this is just an example, the mask can be anything)
train_loader.images = train_loader.images[mask]
train_loader.labels = train_loader.labels[mask]
print(len(train_loader)) # The loader now contains 30,000 images and has batch size 500, so this prints 60.

Exemplo de experimento de seleção de dados

O Airbench pode ser usado como plataforma para experimentos de seleção de dados e aprendizagem ativa. A seguir está um exemplo de experimento que demonstra o resultado clássico de que exemplos de baixa confiança fornecem mais sinais de treinamento do que exemplos aleatórios. Funciona em <20 segundos em um A100.

 import torch
from airbench import train94, infer, evaluate, CifarLoader

net = train94(label_smoothing=0) # train this network without label smoothing to get a better confidence signal

loader = CifarLoader('cifar10', train=True, batch_size=1000)
logits = infer(net, loader)
conf = logits.log_softmax(1).amax(1) # confidence

train_loader = CifarLoader('cifar10', train=True, batch_size=1024, aug=dict(flip=True, translate=2))
mask = (torch.rand(len(train_loader.labels)) < 0.6)
print('Training on %d images selected randomly' % mask.sum())
train_loader.images = train_loader.images[mask]
train_loader.labels = train_loader.labels[mask]
train94(train_loader, epochs=16) # yields around 93% accuracy

train_loader = CifarLoader('cifar10', train=True, batch_size=1024, aug=dict(flip=True, translate=2))
mask = (conf < conf.float().quantile(0.6))
print('Training on %d images selected based on minimum confidence' % mask.sum())
train_loader.images = train_loader.images[mask]
train_loader.labels = train_loader.labels[mask]
train94(train_loader, epochs=16) # yields around 94% accuracy => low-confidence sampling is better than random.