Descargar cifar10 airbench - cifar10 airbench Descarga del código fuente

cifar10 airbench

Otro código fuente

1.0.0

Descargar

Banco de aire CIFAR-10 ?

Una colección de guiones de formación rápidos e independientes para CIFAR-10.

Guion	Precisión media	Tiempo	PFLOP
`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

A modo de comparación, el entrenamiento estándar utilizado en la mayoría de los estudios sobre CIFAR-10 es mucho más lento:

Base	Precisión media	Tiempo	PFLOP
Entrenamiento estándar ResNet-18	96%	7 minutos	32.3

Todos los tiempos están en una única GPU NVIDIA A100.

Nota: airbench96 se ha mejorado desde el documento de 46 a 35 segundos. Además, airbench96_faster es un método mejorado (pero más complicado) que utiliza el filtrado de datos mediante un pequeño modelo proxy. Y airbench94_muon es un método mejorado que utiliza una variante del optimizador Muon.

El conjunto de métodos utilizados para obtener estas velocidades de entrenamiento se describen en el artículo.

alternativo curva

como correr

Para entrenar una red neuronal con una precisión del 94%, ejecute:

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

o

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

Nota: airbench94_compiled.py y airbench94.py son equivalentes (es decir, producen la misma distribución de redes entrenadas) y solo difieren en que el primero usa torch.compile para mejorar la utilización de la GPU. El primero está destinado a experimentos en los que se entrenan muchas redes a la vez para amortizar el costo único de compilación.

Motivación

CIFAR-10 es uno de los conjuntos de datos más utilizados en aprendizaje automático y facilita miles de proyectos de investigación al año. Este repositorio proporciona líneas de base de capacitación rápidas y estables para CIFAR-10 con el fin de ayudar a acelerar esta investigación. Las capacitaciones se proporcionan como scripts de PyTorch libres de dependencias y fácilmente ejecutables y pueden reemplazar las líneas de base clásicas como la capacitación de ResNet-20 o ResNet-18.

Uso independiente del cargador de datos acelerado por GPU

Para escribir experimentos o entrenamientos CIFAR-10 personalizados, puede resultarle útil utilizar el cargador de datos acelerado por GPU de forma independiente.

 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)
        ...

Si desea modificar los datos en el cargador, puede hacerlo así:

 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.

Ejemplo de experimento de selección de datos

Airbench se puede utilizar como plataforma para experimentos de selección de datos y aprendizaje activo. El siguiente es un experimento de ejemplo que demuestra el resultado clásico de que los ejemplos de baja confianza proporcionan más señales de entrenamiento que los ejemplos aleatorios. Se ejecuta en <20 segundos en un 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.