Download do ffcv - Download do código fonte ffcv

ffcv

Pitão

V1.0.0

Baixar

Visão computacional para avanço rápido : modelos de trem por uma fração do custo com carga de dados acelerada!

[Install] [Quickstart] [Recursos] [Docs] [Support Slack] [Página inicial] [Paper]
METORNES: Guillaume Leclerc, Andrew Ilyas e Logan Engstrom

ffcv é um sistema de carregamento de dados que aumenta drasticamente a taxa de transferência de dados no treinamento do modelo:

Treine um modelo ImageNet em uma GPU em 35 minutos (98 ¢/modelo na AWS)
Treine um modelo CIFAR-10 em uma GPU em 36 segundos (2 ¢/modelo na AWS)
Treine um modelo $YOUR_DATASET $REALLY_FAST (por $WAY_LESS )

Mantenha seu algoritmo de treinamento o mesmo, basta substituir o carregador de dados! Olhe para essas acelerações:

ffcv também vem pré -embalado com código rápido e simples para benchmarks de visão padrão:

Instalação

Linux

 conda create -y -n ffcv python=3.9 cupy pkg-config libjpeg-turbo opencv pytorch torchvision cudatoolkit=11.3 numba -c pytorch -c conda-forge
conda activate ffcv
pip install ffcv

Solução de problemas Nota 1: Se os comandos acima resultarem em um erro de conflito do pacote, tente executar conda config --env --set channel_priority flexible no ambiente e executando o comando de instalação.

Solução de problemas Nota 2: Em alguns sistemas (mas raramente), você precisará adicionar o pacote compilers ao primeiro comando acima.

Solução de problemas Nota 3: Cortesia de @kschuerholt, aqui está um Dockerfile que pode ajudar com a instalação sem conda

Windows

Instale OpenCv4
- Adicionar ..../opencv/build/x64/vc15/bin to Path Environment Variável
Instale libjpeg-turbo, download libjpeg-turbo-xxx-vc64.exe, não gcc64
- Adicionar ..../libjpeg-turbo64/bin to path ambiente variável
Instale o Pthread, faça o download do último lançamento.zip
- Depois do zípe
- Abra pthread/include/pthread.h e adicione o código abaixo na parte superior do arquivo.
```
# define HAVE_STRUCT_TIMESPEC
```
- Adicionar ..../pthread/dll para variável de ambiente de caminho
Instale o Cupy, dependendo da sua versão CUDA Toolkit.
pip install ffcv

Citação

Se você usar o FFCV, cite -o como:

 @inproceedings{leclerc2023ffcv,
    author = {Guillaume Leclerc and Andrew Ilyas and Logan Engstrom and Sung Min Park and Hadi Salman and Aleksander Madry},
    title = {{FFCV}: Accelerating Training by Removing Data Bottlenecks},
    year = {2023},
    booktitle = {Computer Vision and Pattern Recognition (CVPR)},
    note = {url{https://github.com/libffcv/ffcv/}. commit xxxxxxx}
}

(Certifique -se de substituir xxxxxxx acima pelo hash do commit usado!)

Investir rápido

Acelere qualquer sistema de aprendizado com ffcv . Primeiro, converta seu conjunto de dados em formato ffcv ( ffcv converte os conjuntos de dados Pytorch indexados e WebDatasets):

 from ffcv . writer import DatasetWriter
from ffcv . fields import RGBImageField , IntField

# Your dataset (`torch.utils.data.Dataset`) of (image, label) pairs
my_dataset = make_my_dataset ()
write_path = '/output/path/for/converted/ds.beton'

# Pass a type for each data field
writer = DatasetWriter ( write_path , {
    # Tune options to optimize dataset size, throughput at train-time
    'image' : RGBImageField ( max_resolution = 256 ),
    'label' : IntField ()
})

# Write dataset
writer . from_indexed_dataset ( my_dataset )

Em seguida, substitua seu carregador antigo pelo carregador ffcv na hora do trem (em Pytorch, nenhuma outra alteração necessária!):

 from ffcv . loader import Loader , OrderOption
from ffcv . transforms import ToTensor , ToDevice , ToTorchImage , Cutout
from ffcv . fields . decoders import IntDecoder , RandomResizedCropRGBImageDecoder

# Random resized crop
decoder = RandomResizedCropRGBImageDecoder (( 224 , 224 ))

# Data decoding and augmentation
image_pipeline = [ decoder , Cutout (), ToTensor (), ToTorchImage (), ToDevice ( 0 )]
label_pipeline = [ IntDecoder (), ToTensor (), ToDevice ( 0 )]

# Pipeline for each data field
pipelines = {
    'image' : image_pipeline ,
    'label' : label_pipeline
}

# Replaces PyTorch data loader (`torch.utils.data.Dataloader`)
loader = Loader ( write_path , batch_size = bs , num_workers = num_workers ,
                order = OrderOption . RANDOM , pipelines = pipelines )

# rest of training / validation proceeds identically
for epoch in range ( epochs ):
    ...

Veja aqui um guia mais detalhado para implantar ffcv para o seu conjunto de dados.

Benchmarks de visão computacional pré -embalados

Desde a grade ao benchmarking até a iteração rápida da pesquisa, há muitas razões para querer treinamento de modelo mais rápido. Abaixo, apresentamos bases de código pré -fabricadas para treinamento no ImageNet e Cifar, incluindo (a) bases de código extensíveis e (b) inúmeras configurações de treinamento pré -fabricado.

Imagenet

Fornecemos um script independente para o treinamento do ImageNet rapidamente. Acima, plotamos o tempo de treinamento versus a fronteira de precisão e as velocidades de dados de dados, para 1-GPU Resnet-18 e 8-GPU ResNet-50 ao lado de algumas linhas de base.

Link para config	top_1	top_5	# Épocas	Tempo (minutos)	Arquitetura	Configurar
Link	0,784	0,941	88	77.2	Resnet-50	8 x A100
Link	0,780	0,937	56	49.4	Resnet-50	8 x A100
Link	0,772	0,932	40	35.6	Resnet-50	8 x A100
Link	0,766	0,927	32	28.7	Resnet-50	8 x A100
Link	0,756	0,921	24	21.7	Resnet-50	8 x A100
Link	0,738	0,908	16	14.9	Resnet-50	8 x A100
Link	0,724	0,903	88	187.3	Resnet-18	1 x A100
Link	0,713	0,899	56	119.4	Resnet-18	1 x A100
Link	0,706	0,894	40	85.5	Resnet-18	1 x A100
Link	0,700	0,889	32	68.9	Resnet-18	1 x A100
Link	0,688	0,881	24	51.6	Resnet-18	1 x A100
Link	0,669	0,868	16	35.0	Resnet-18	1 x A100

Treine seus próprios modelos ImageNet! Você pode usar nosso script de treinamento e configurações pré -fabricadas para treinar qualquer modelo visto nos gráficos acima.

Cifar-10

Também incluímos código pré-fabricado para treinamento eficiente no CIFAR-10 nos examples/ diretório, obtendo 93% de precisão TOP1 em 36 segundos em uma única GPU A100 (sem otimizações como a mistura, a batchnorm, etc., que têm potencial para aumentar ainda mais a precisão). Você pode encontrar o script de treinamento aqui.

Características

Visão computacional ou não, o FFCV pode ajudar a tornar o treinamento mais rápido em uma variedade de configurações com restrição de recursos! Nosso guia de desempenho tem uma conta mais detalhada das maneiras pelas quais o FFCV pode se adaptar a diferentes gargalos de desempenho.

Plug-and-Play com qualquer código de treinamento existente : em vez de alterar aspectos do treinamento de modelos, o FFCV se concentra na remoção de gargalos de dados , que acabam sendo um problema em todos os lugares, desde o treinamento de rede neural até a regressão linear. Isso significa que:
- O FFCV pode ser introduzido em qualquer código de treinamento existente em apenas algumas linhas de código (por exemplo, apenas trocando o carregador de dados e opcionalmente o pipeline de aumento);
- Você não precisa alterar o próprio modelo para torná -lo mais rápido (por exemplo, sinta -se à vontade para analisar modelos sem Cutmix, abandono, programação de momento, etc.);
- O FFCV pode acelerar muito mais além do treinamento de rede neural-de fato, quanto mais garnecada de dados o aplicativo (por exemplo, regressão linear, inferência em massa etc.), o FFCV mais rápido o fará!
Veja o nosso guia de início, exemplo a passo e exemplos de código para ver como é fácil começar!
Processamento rápido de dados sem a dor : o FFCV lida automaticamente na leitura de dados, pré-busca, cache e transferência entre dispositivos de uma maneira extremamente eficiente, para que os usuários não precisem pensar nisso.
Processamento de dados automaticamente fundido e compilado : usando transformações pré-escritas do FFCV ou escrevendo facilmente as habilidades personalizadas, os usuários podem aproveitar as habilidades de compilação e pipelines do FFCV, que se fundem automaticamente e compilam os aumentos simples do Python para o código da máquina usando o NUMBA e os agendam de maneira assífica para evitar atrasos.
Carregue os dados rapidamente da RAM, SSD ou disco em rede : o FFCV expõe opções amigáveis que podem ser ajustadas com base nos recursos disponíveis. Por exemplo, se um conjunto de dados se encaixar na memória, o FFCV poderá cache -o no nível do sistema operacional e garantir que vários processos simultâneos obtenham acesso rápido a dados. Caso contrário, o FFCV pode usar o cache rápido no nível do processo e otimizará o carregamento de dados para minimizar o número subjacente de leituras de disco. Consulte o guia médico do gargalo para obter mais informações.
Treinando vários modelos por GPU : graças ao carregamento de dados baseado em roscas totalmente assíncrono, agora você pode interlamear o treinamento vários modelos na mesma GPU com eficiência, sem qualquer sobrecarga de carga de dados. Veja este guia para obter mais informações.
Ferramentas dedicadas para manuseio de imagens : todos os recursos acima do trabalho são igualmente aplicáveis a todos os tipos de modelos de aprendizado de máquina, mas o FFCV também oferece alguns recursos específicos da visão, como codificação e decodificação JPEG rápidas, armazenando conjuntos de dados como misturas de imagens cruas e compactadas para trocar I/O Overhead e calcular a cabeça, etc. Veja o trabalho com os guia de imagens.