timm documentation
Dados
Dados
Esta página contém a documentação de referência da API do subpacote timm.data, bem como uma visão geral do pipeline de entrada que ele fornece: resolução da configuração de pré-processamento de um modelo, construção de transforms, criação de datasets e loaders, Mixup / CutMix e o loader de resolução variável NaFlex.
Uso
Um pipeline é construído em quatro etapas: resolve_model_data_config lê a configuração de pré-processamento do modelo, create_transform cria a transformação de treino ou avaliação, create_dataset cria um dataset por nome e raiz, e create_loader constrói a transformação e um data loader para um dataset.
import os
import tempfile
import torch
from PIL import Image
import timm
from timm.data import create_dataset, create_loader, create_transform, resolve_model_data_config
model = timm.create_model('resnet50', pretrained=False).eval()
# Preprocessing config from the model's pretrained_cfg, the default pretrained tag's config is attached to the model
# with or without pretrained weights.
data_config = resolve_model_data_config(model)
print(data_config)
# {'input_size': (3, 224, 224), 'interpolation': 'bicubic', 'mean': (0.485, 0.456, 0.406),
# 'std': (0.229, 0.224, 0.225), 'crop_pct': 0.95, 'crop_mode': 'center'}
# Eval transform for a PIL image, resize to 224 / crop_pct, center crop 224, to tensor and normalize.
transform = create_transform(**data_config, is_training=False)
img = Image.new('RGB', (320, 240), color=(200, 120, 40))
with torch.no_grad():
output = model(transform(img).unsqueeze(0)) # (1, 1000)
# A folder dataset, <root>/<split>/<class>/<image>, two classes w/ four generated images each.
root = tempfile.mkdtemp()
for i, cls in enumerate(('cat', 'dog')):
os.makedirs(os.path.join(root, 'validation', cls))
for j in range(4):
path = os.path.join(root, 'validation', cls, f'{j}.jpg')
Image.new('RGB', (300, 200), color=(60 * i, 40 * j, 128)).save(path)
dataset = create_dataset('', root=root, split='validation') # finds the 'validation' sub-folder
print(len(dataset), dataset.reader.class_to_idx) # 8 {'cat': 0, 'dog': 1}
# The loader creates the transform from the same config and assigns it to the dataset.
loader = create_loader(dataset, **data_config, batch_size=4, use_prefetcher=False, num_workers=0)
with torch.no_grad():
for images, targets in loader:
output = model(images) # images (4, 3, 224, 224), targets (4,)O quickstart percorre a configuração para as etapas de transformação para inferência.
O script de treinamento (train.py) expõe essas opções para cada parte do pipeline.
Substituições de configuração de entrada (resolve_input_data_config):
--input-sizedefine a forma de entrada(C, H, W).--img-sizeé o atalho quadrado para--input-size, mantendo a contagem de canais do modelo.--in-chansdefine os canais de entrada.--interpolationdefine a interpolação de redimensionamento.--meandefine a média de normalização.--stddefine o desvio padrão da normalização.--crop-pctdefine a fração de recorte para avaliação.
Criação do dataset (create_dataset) e configuração do alvo:
--datasetseleciona o conjunto de dados e o leitor.--data-dirdefine a raiz do conjunto de dados.--train-splitseleciona o split de treinamento.--val-splitseleciona a divisão de validação.--class-mapfornece o mapeamento de classes.--input-img-modedefine o modo de conversão de cor da imagem.--input-keyseleciona o campo da imagem.--target-keyseleciona o campo ou os campos de rótulo.--target-formatseleciona índices de classe ou alvos multi-hot densos.
As opções de carregador e aumento de dados (create_loader) incluem:
--aaseleciona a política de auto-aumento.--reprobdefine a probabilidade de apagamento aleatório.--remodeseleciona o modo de preenchimento do apagamento aleatório.--scaledefine o intervalo de escala para o recorte redimensionado aleatório.--ratiodefine o intervalo da proporção de aspecto para o recorte redimensionado aleatório.--hflipdefine a probabilidade de inversão horizontal.--color-jitterdefine a intensidade da variação de cor.--train-interpolationdefine a interpolação de redimensionamento para o treinamento.--workersdefine o número de workers do loader.--no-prefetcherdesativa o prefetcher.
Mixup e CutMix (Mixup):
--mixupdefine o alpha do Mixup.--cutmixdefine o alpha do CutMix.--cutmix-minmaxdefine o intervalo de tamanho da caixa do CutMix.--mixup-probdefine a probabilidade de mistura.--mixup-switch-probdefine a probabilidade de escolher o CutMix quando ambos os métodos estão habilitados.--mixup-modeseleciona a mistura por lote, por par ou elemento a elemento.--smoothingdefine o suavização de rótulos.
Veja Scripts para exemplos.
Configuração de dados
resolve_data_config retorna um dict com as chaves abaixo, que correspondem aos
argumentos de create_transform e create_loader. Os valores definidos em args (um dict, por exemplo, vars(args) de
argumentos de linha de comando analisados) têm precedência sobre o argumento pretrained_cfg, que por padrão é model.pretrained_cfg. resolve_model_data_config é o mesmo, com o modelo como primeiro argumento.
Ambos leem o tamanho da entrada e os canais do cfg pré-treinado, que descreve o checkpoint de origem, e não um modelo criado ou alterado para usar um img_size ou in_chans diferente. resolve_input_data_config, usado pelos scripts de treinamento, validação e inferência, resolve em relação à entrada atual do modelo: um modelo com tamanho de entrada fixo sempre recebe seu tamanho atual, args explícitos que conflitam com os canais ou o tamanho fixo do modelo geram um erro, e uma média / desvio padrão que não corresponde à contagem de canais é substituída pela sua média (com um aviso).
| Chave | chaves de args | Descrição | Padrão |
|---|---|---|---|
input_size | input_size, img_size, in_chans | (C, H, W) tamanho de entrada. Com use_test_size=True, o test_input_size da configuração é usado, se houver | (3, 224, 224) |
interpolation | interpolation | Interpolação de redimensionamento, bilinear, bicubic, … | bicubic |
mean, std | mean, std | Normalização, um único valor é repetido para cada canal | Média / desvio padrão do ImageNet |
crop_pct | crop_pct | No modo de avaliação por recorte, a imagem é redimensionada para size / crop_pct antes de ser recortada para size (test_crop_pct com use_test_size=True) | 0.875 |
crop_mode | crop_mode | Modo de recorte de avaliação, center, squash ou border | center |
Os modos de recorte de avaliação, para um size de saída e scale_size = floor(size / crop_pct):
crop_mode | Comportamento |
|---|---|
center | Redimensione a aresta mais curta para scale_size (mantendo a proporção) e faça um recorte centralizado para size |
squash | Redimensione ambas as bordas para scale_size (a proporção não é preservada), faça um recorte centralizado para size |
border | Redimensione a aresta mais longa para scale_size, faça um recorte central e preencha com a cor média; a imagem inteira é mantida em crop_pct=1.0 |
Transformações
create_transform retorna um Compose do torchvision. O transform de avaliação redimensiona e recorta conforme descrito acima, em seguida converte para tensor e normaliza. O transform de treinamento é um recorte redimensionado aleatório (scale=(0.08, 1.0), ratio=(3/4, 4/3) por padrão), inversão horizontal (hflip=0.5), jitter de cor (color_jitter=0.4), a política opcional auto_augment, conversão para tensor e normalização, e apagamento aleatório.
train_crop_mode='rkrc'ou'rkrr'substitui o recorte redimensionado aleatório por um redimensionamento aleatório que preserva a proporção, seguido por um recorte ou preenchimento central (rkrc) ou aleatório (rkrr).interpolation='random'(o padrão dotrain.pypara treinamento) seleciona bilinear ou bicúbico para cada imagem.no_aug=Truereduz o treinamento a um redimensionamento e um recorte centralizado.
auto_augment | Aumento |
|---|---|
rand-m9-mstd0.5-inc1 | RandAugment via rand_augment_transform |
augmix-m5-w4-d2 | AugMix via augment_and_mix_transform |
original, originalr, v0, v0r, 3a | Política AutoAugment via auto_augment_transform |
Tokens de opções de RandAugment:
mdefine a magnitude (padrão 10).ndefine o número de operações por imagem (padrão 2).pdefine a probabilidade por operação (padrão 0.5).mstddefine o desvio padrão do ruído de magnitude.inc1seleciona operações cuja severidade aumenta com a magnitude.t<name>seleciona o conjunto de operações (weights,3a,3aw).
Tokens de opções do AugMix:
mdefine a severidade (padrão 3).wdefine a largura (padrão 3).ddefine a profundidade (padrão -1, aleatório 1-3).b1permite a ampliação mista.mstddefine o desvio padrão do ruído de magnitude.
AutoAugment aceita mstd, por exemplo, original-mstd0.5.
Comportamento do Transform:
- O ajuste de cor (color jitter) é desativado quando
auto_augmentestá definido, a menos que a string contenha3a. RandomErasing(re_prob,re_count) é executado no tensor normalizado.re_modepreenche com zeros (const, o padrão), uma cor normal aleatória por região (rand) ou pixels normais aleatórios (pixel, o padrão dotrain.py).use_prefetcher=Trueencerra a transformação em um tensoruint8, e a normalização e o apagamento aleatório são então executados pelo loader no dispositivo.create_transformecreate_loaderusam por padrão a interpolaçãobilineare a média / desvio padrão do ImageNet, e não os valores do modelo. Passe a configuração de dados resolvida para corresponder ao pré-treinamento do modelo.
Conjuntos de dados
create_dataset seleciona a implementação do conjunto de dados e o leitor a partir de um prefixo de name:
name | Conjunto de dados | root | Exige |
|---|---|---|---|
'' ou sem prefixo | ImageDataset, imagens em subpastas de classes (busca recursiva, o nome da pasta folha é a classe) ou um único arquivo .tar com o mesmo | Pasta de dataset ou arquivo .tar | |
torch/<name> | torchvision cifar10, cifar100, mnist, kmnist, fashion_mnist, qmnist, inaturalist (inat), places365, imagenet ou image_folder (folder) | raiz do dataset torchvision | |
hfds/<name> | ImageDataset em um dataset do Hugging Face Hub (ou caminho local) via datasets.load_dataset | Diretório de cache (opcional) | datasets |
hfids/<name> | IterableImageDataset, o dataset do Hugging Face transmitido em streaming, ou baixado e preparado primeiro com download=True | Diretório de cache (opcional) | datasets |
tfds/<name> | IterableImageDataset no TensorFlow Datasets, download=True baixa e cria | Diretório de dados do TFDS | tensorflow, tensorflow-datasets |
wds/<name> | IterableImageDataset em shards tar do WebDataset | Pasta de shards com um _info.json (ou info.json) descrevendo as divisões | webdataset |
Opções de dataset:
splitseleciona o split do dataset (padrãovalidation). Para WebDataset, também pode ser um padrão de shard com uma contagem de amostras,'imagenet-train-{0000..1023}.tar|1281167'.search_split=True(padrão) faz com que os conjuntos de dados em pastas procurem a subpasta derootchamadasplitou, na ausência dessa, um sinônimo de um split de treino (train,training) ou de avaliação (val,valid,validation,eval,evaluation).add_img_extensionsadiciona às extensões de imagem padrão (.png,.jpge.jpeg).class_mapremapeia nomes de classes para índices usando um dict, um arquivo.txt(uma classe por linha) ou um arquivo.pkl.
Conjuntos de dados iteráveis (hfids, tfds, wds) também aceitam:
is_traininghabilita a embaralhamento.batch_sizearredonda para cima a parte de cada worker dos exemplos para lotes inteiros durante o treinamento.num_samplesdefine a contagem de amostras, necessária quando o leitor não consegue determiná-la (hfidssem informações de divisão).seeddefine a semente aleatória.repeatsmultiplica as amostras por época, fazendo com que os leitores percorram os dados tantas vezes.
Chame dataset.set_epoch() a cada epoch para reembaralhar.
Outros argumentos de palavra-chave são repassados ao leitor. Para os leitores Hugging Face, TFDS e WebDataset:
input_keyseleciona o campo de imagem (por padrão,image; parawds, uma imagemjpg,pngouwebp).target_keyseleciona o campo de rótulo (por padrão,label; parawds, o arquivo.clsou um campo lateral.jsonnomeado portarget_key). Um valor separado por vírgulas lê um campo binário por classe.target_format='multihot'lê vetores multi-hot densos em vez de listas de índices de classes para dados multirótulo.target_transform=MultiLabelTarget(num_classes)codifica os alvos como tensores multi-hot em ponto flutuante. Passedense=TrueparaMultiLabelTargetpara campos multi-hot.
Os leitores de pasta e tar retornam índices de uma única classe. Consulte classificação multirrótulo para mais detalhes.
Carregadores
create_loader cria o transform com create_transform a partir de seus próprios argumentos,
atribui-o a dataset.transform (substituindo qualquer transform existente) e retorna um DataLoader. Os loaders de treinamento
(is_training=True) embaralham e descartam o último lote incompleto.
- Prefetcher. Com
use_prefetcher=True(padrão), o dataset gera tensoresuint8, os lotes são movidos para odevice(padrãocuda, em um stream lateral para CUDA), convertidos paraimg_dtype, normalizados e aleatoriamente apagados ali. Definadevicepara o dispositivo de treinamento, ouuse_prefetcher=Falsepara umDataLoadersimples de tensores normalizados. - Distribuído.
distributed=Trueusa umDistributedSamplerpara conjuntos de dados de treinamento em estilo mapa (ou um sampler de aumento repetido comnum_aug_repeats) e um sampler ordenado para avaliação que preenche cada processo até o mesmo número de amostras, o que pode alterar ligeiramente os resultados de validação. Conjuntos de dados iteráveis se dividem entre processos e workers. - Collate.
collate_fnsubstitui o padrão (fast_collatecom o prefetcher,default_collatesem), por exemplo, por umFastCollateMixup. - Divisões de aumento. Para o AugMix com a perda JSD (
--aug-splits), envolva o dataset emAugMixDataset(dataset, num_splits=n)e passenum_aug_splits=n. Cada lote contém uma divisão limpa en - 1divisões aumentadas, concatenadas ao longo da dimensão do lote pelo prefetcher. - Resolução agendada.
input_size_choices(--train-img-sizes) seleciona o tamanho de entrada por lote, opcionalmente com um tamanho de lote por escolha (batch_size_choices) e um agendamentoprogressiveda primeira à última escolha.
Mixup e CutMix
Mixup mistura um lote de imagens normalizadas no dispositivo, após o loader. FastCollateMixup aceita os mesmos argumentos e mistura imagens uint8 durante a colagem nos workers do loader, exigindo o prefetcher. Ambos retornam alvos densos (batch_size, num_classes) com label_smoothing (padrão 0.1) aplicado, para uso com uma perda de alvo suave, como timm.loss.SoftTargetCrossEntropy, e exigem um tamanho de lote par.
from timm.data import Mixup, FastCollateMixup
# Continuing the example above.
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
mixup_args = dict(mixup_alpha=0.8, cutmix_alpha=1.0, label_smoothing=0.1, num_classes=1000)
# Prefetcher enabled (default), mixed in the loader's collate.
loader = create_loader(
dataset,
**data_config,
batch_size=4,
is_training=True,
collate_fn=FastCollateMixup(**mixup_args),
device=device,
)
for images, targets in loader:
... # images normalized on device, targets (4, 1000)
# Prefetcher disabled, mixed in the training loop.
loader = create_loader(dataset, **data_config, batch_size=4, is_training=True, use_prefetcher=False)
mixup_fn = Mixup(**mixup_args)
for images, targets in loader:
images, targets = mixup_fn(images.to(device), targets.to(device))Controles de Mixup e CutMix:
mixup_alpha > 0habilita o Mixup.cutmix_alpha > 0habilita o CutMix.cutmix_minmaxhabilita o CutMix com um intervalo de tamanho de caixa.switch_probdefine a probabilidade de escolher CutMix quando ambos os métodos estão habilitados.probdefine a probabilidade de misturar.modedesenha os parâmetros uma vez porbatch, porpairde elementos ou porelem(elemento).multi_label=Truemistura alvos multirótulo densos, suavizando cada rótulo em direção a 0,5.mixup_enabled = Falsedesativa a mistura, por exemplo, para os últimos epochs (--mixup-off-epoch). ParaFastCollateMixup, o valor é lido nos processos de worker; workers persistentes mantêm o valor com o qual iniciaram.
Resolução de variáveis do NaFlex
create_naflex_loader carrega imagens como sequências de comprimento variável de patches,
sem redimensionar para um tamanho quadrado fixo, para modelos que aceitam entradas de patch NaFlex (por exemplo, os modelos naflexvit_*). Cada
lote é um dicionário de patches, patch_coord, patch_valid e seq_len, preenchido até o comprimento da sequência do lote.
- Treinamento. O conjunto de dados é envolvido em um
NaFlexMapDatasetWrapper(apenas para conjuntos de dados em estilo mapa), que seleciona um dostrain_seq_lenspor lote e aplica redimensionamento e recorte aleatórios em cada imagem para que ela se ajuste a esse número de patches.batch_sizeé o tamanho do lote no comprimento de sequência mais longo; comprimentos menores recebem lotes proporcionalmente maiores (arredondados para baixo para um múltiplo de 8), de modo que o número de tokens por lote permaneça aproximadamente constante.patch_size_choices(compatch_size_choice_probs) também varia o tamanho do patch por lote, para modelos que suportam essa funcionalidade. - Eval. As imagens são redimensionadas para caber em
max_seq_lenpatches nopatch_sizeespecificado (obrigatório para avaliação) e preenchidas atémax_seq_len. - Mixup. Passe um
NaFlexMixupcomomixup_fn; ele mistura dentro de cada lote e não suportamodeoucutmix_minmax.
As opções do train.py são:
--naflex-loaderhabilita o carregador NaFlex.--naflex-train-seq-lensdefine os comprimentos das sequências de treinamento.--naflex-max-seq-lendefine o comprimento máximo da sequência de avaliação.--naflex-patch-sizesdefine os tamanhos de patch para o treinamento com tamanho de patch variável.--naflex-patch-size-probsdefine as probabilidades para esses tamanhos de patch.--naflex-loss-scaleseleciona a escala de perda pelo tamanho do lote (none,sqrtoulinear).
API
Configuração de dados
timm.data.resolve_data_config
< source >( args = Nonepretrained_cfg = Nonemodel = Noneuse_test_size = Falseverbose = False )
timm.data.resolve_model_data_config
< source >( modelargs = Nonepretrained_cfg = Noneuse_test_size = Falseverbose = False )
Parâmetros
- model (nn.Module) — a instância do modelo
- args (dict) — argumentos de linha de comando / configuração em formato de dict (sobrepõe pretrained_cfg)
- pretrained_cfg (dict) — configuração do modelo pré-treinado (sobrepõe o pretrained_cfg anexado ao modelo)
- use_test_size (bool) — usa a resolução de entrada do tempo de teste (se existir) em vez da resolução padrão de treinamento
- verbose (bool) — habilita o registro extra de valores resolvidos
Resolve Model Data Config Isso é equivalente a resolve_data_config(), mas com os argumentos reordenados para colocar o modelo primeiro.
timm.data.resolve_input_data_config
< source >( modelargs: typing.Optional[typing.Dict[str, typing.Any]] = Nonepretrained_cfg: typing.Optional[typing.Dict[str, typing.Any]] = Noneuse_test_size: bool = Falseverbose: bool = False )
Resolve o pré-processamento em relação às restrições de entrada do modelo atual.
As dimensões e os canais fixos devem corresponder às solicitações explícitas. Modelos flexíveis mantêm as recomendações de pré-processamento de treino/teste, a menos que sejam substituídas. A normalização utiliza a política de adaptação de canais existente dos carregadores de pré-busca.
Transformações
timm.data.create_transform
< source >( input_size: typing.Union[int, typing.Tuple[int, int], typing.Tuple[int, int, int]] = 224is_training: bool = Falseno_aug: bool = Falsetrain_crop_mode: typing.Optional[str] = Nonescale: typing.Optional[typing.Tuple[float, float]] = Noneratio: typing.Optional[typing.Tuple[float, float]] = Nonehflip: float = 0.5vflip: float = 0.0color_jitter: typing.Union[float, typing.Tuple[float, ...]] = 0.4color_jitter_prob: typing.Optional[float] = Nonegrayscale_prob: float = 0.0gaussian_blur_prob: float = 0.0auto_augment: typing.Optional[str] = Noneinterpolation: str = 'bilinear'mean: typing.Tuple[float, ...] = (0.485, 0.456, 0.406)std: typing.Tuple[float, ...] = (0.229, 0.224, 0.225)re_prob: float = 0.0re_mode: str = 'const're_count: int = 1re_num_splits: int = 0crop_pct: typing.Optional[float] = Nonecrop_mode: typing.Optional[str] = Nonecrop_border_pixels: typing.Optional[int] = Nonetf_preprocessing: bool = Falseuse_prefetcher: bool = Falsenormalize: bool = Trueseparate: bool = Falsenaflex: bool = Falsepatch_size: typing.Union[int, typing.Tuple[int, int]] = 16max_seq_len: int = 576patchify: bool = Falsepatchify_channels_last: bool = Truepatchify_flatten: bool = True )
Parâmetros
- input_size — Tamanho de entrada alvo (canais, altura, largura) em tupla ou escalar.
- is_training — Retorna as transformações de treinamento (aleatórias).
- no_aug — Desativa a aumentação para o treinamento (útil para depuração).
- train_crop_mode — Modo de recorte aleatório para treinamento (‘rrc’, ‘rkrc’, ‘rkrr’).
- scale — Intervalo de escala para redimensionamento aleatório (área de recorte, < 1.0 => zoom in).
- ratio — Intervalo aleatório de proporção de aspecto (proporção de recorte para RRC, fator de ajuste de proporção para RKR).
- hflip — Probabilidade de inversão horizontal.
- vflip — Probabilidade de inversão vertical.
- color_jitter — Fatores de componentes de jitter de cor aleatório (brilho, contraste, saturação, matiz). Um escalar é aplicado como (escalar,) * 3 (sem matiz).
- color_jitter_prob — Aplique color jitter com esta probabilidade, se não for None (para aumentos semelhantes ao SimCLR).
- grayscale_prob — Probabilidade de converter a imagem para escala de cinza (para aumentos semelhantes ao SimCLR).
- gaussian_blur_prob — Probabilidade de aplicar gaussian blur (para aumentos semelhantes ao SimCLR).
- auto_augment — String de configuração de auto augment (veja auto_augment.py).
- interpolation — Modo de interpolação de imagem.
- mean — Média de normalização da imagem.
- std — Desvio padrão da normalização da imagem.
- re_prob — Probabilidade de apagamento aleatório.
- re_mode — Modo de preenchimento do apagamento aleatório.
- re_count — Número de regiões de apagamento aleatório.
- re_num_splits — Controla a divisão do random erasing em relação ao tamanho do lote.
- crop_pct — Porcentagem de recorte na inferência (tamanho de saída / tamanho de redimensionamento).
- crop_mode — Modo de recorte para inferência. Um de [‘squash’, ‘border’, ‘center’]. O padrão é ‘center’ quando None.
- crop_border_pixels — Recorte de borda para inferência de # pixels especificados ao redor da borda da imagem original.
- tf_preprocessing — Use o pré-processamento de inferência do TF 1.0 para testar portagens de modelos
- use_prefetcher — Pré-busca ativada. Não converta a imagem em tensor nem normalize.
- normalize — Tensor de normalização de saída com média/desvio padrão fornecidos (se o prefetcher não for usado).
- separate — Saída em tupla de 3 estágios.
- patchify — Aplique a operação de divisão em patches à saída em vez de depender do prefetcher.
- patchify_channels_last — Use o layout channels-last dentro de cada patch.
- patchify_flatten — Achata os patches de avaliação em vetores. Desative quando o modelo precisar das suas dimensões espaciais para interpolação de tamanho de patch.
timm.data.rand_augment_transform
< source >( config_str: strhparams: typing.Optional[typing.Dict] = Nonetransforms: typing.Union[str, typing.Dict, typing.List, NoneType] = None )
Parâmetros
- config_str (str) — String que define a configuração do aumento aleatório. Consiste em várias seções separadas por traços ('-'). A primeira seção define a variante específica de rand augment (atualmente apenas 'rand'). As seções restantes, sem ordem específica, determinam
- ‘m’ - magnitude inteira do rand augment
- ‘n’ - número inteiro de camadas (número de operações de transformação selecionadas por imagem)
- ‘p’ - probabilidade flutuante de aplicar cada camada (padrão 0.5)
- ‘mstd’ - desvio padrão flutuante do ruído de magnitude aplicado, ou amostragem uniforme se infinito (ou > 100)
- ‘mmax’ - define o limite superior da magnitude para um valor diferente do padrão de _LEVEL_DENOM (10)
- ‘inc’ - inteiro (bool), use aumentos que aumentam em gravidade com a magnitude (padrão: 0)
- ‘t’ - str nome do conjunto de transformações a ser usado
- hparams (dict) — Outros hparams (kwargs) para o esquema de RandAugmentation
Crie uma transformação RandAugment
Exemplos:
'rand-m9-n3-mstd0.5'é RandAugment com magnitude 9, 3 camadas e um desvio padrão de magnitude de 0,5.'rand-mstd1-tweights'é o RandAugment com um desvio padrão de magnitude de 1.0 e seleção ponderada de transformações, na magnitude padrão de 10 e 2 camadas.
timm.data.auto_augment_transform
< source >( config_str: strhparams: typing.Optional[typing.Dict] = None )
Parâmetros
- config_str — String que define a configuração do auto augmentation. Consiste em várias seções separadas por traços ('-'). A primeira seção define a política do AutoAugment (uma de 'v0', 'v0r', 'original', 'originalr'). As seções restantes definem outros argumentos
- ‘mstd’ - desvio padrão flutuante do ruído de magnitude aplicado
- hparams — Outros hparams (kwargs) para o esquema AutoAugmentation
Crie uma transformação AutoAugment
Exemplos:
'original-mstd0.5'é o AutoAugment com a política original e um desvio padrão de magnitude de 0,5.
timm.data.auto_augment.augment_and_mix_transform
< source >( config_str: strhparams: typing.Optional[typing.Dict] = None )
Parâmetros
- config_str (str) — String que define a configuração do aumento aleatório. Consiste em múltiplas seções separadas por traços (’-’). A primeira seção define a variante específica de rand augment (atualmente apenas ‘rand’). As seções restantes, sem ordem específica, determinam ‘m’ - magnitude (severidade) inteira da mistura de aumento (padrão: 3) ‘w’ - largura inteira da cadeia de aumento (padrão: 3) ‘d’ - profundidade inteira da cadeia de aumento (-1 é aleatório [1, 3], padrão: -1) ‘b’ - inteiro (bool), mesclar cada ramo da cadeia no resultado final sem uma mesclagem final, menos CPU (padrão: 0) ‘mstd’ - desvio padrão flutuante do ruído de magnitude aplicado (padrão: 0) Ex ‘augmix-m5-w4-d2’ resulta em AugMix com severidade 5, largura da cadeia 4, profundidade da cadeia 2
- hparams — Outros hparams (kwargs) para as transformações de Augmentation
Criar transformação AugMix do PyTorch
classe timm.data.random_erasing.RandomErasing
< source >( probability = 0.5min_area = 0.02max_area = 0.3333333333333333min_aspect = 0.3max_aspect = Nonemode = 'const'min_count = 1max_count = Nonenum_splits = 0device = 'cuda' )
Parâmetros
- probability — Probabilidade de a operação Random Erasing ser executada.
- min_area — Porcentagem mínima da área apagada em relação à área da imagem de entrada.
- max_area — Porcentagem máxima da área apagada em relação à área da imagem de entrada.
- min_aspect — Proporção mínima da área apagada.
- mode — modo de cor do pixel, um de ‘const’, ‘rand’ ou ‘pixel’ ‘const’ - o bloco de apagamento tem cor constante 0 para todos os canais ‘rand’ - o bloco de apagamento tem a mesma cor aleatória (normal) por canal ‘pixel’ - o bloco de apagamento tem cor aleatória (normal) por pixel
Seleciona aleatoriamente uma região retangular em uma imagem e apaga seus pixels. ‘Random Erasing Data Augmentation’ de Zhong et al. Veja https://arxiv.org/pdf/1708.04896.pdf
Esta variante de RandomErasing destina-se a ser aplicada a um tensor de lote ou de imagem única após ele ter sido normalizado pela média e pelo desvio padrão do conjunto de dados.
max_count: número máximo de blocos de apagamento por imagem, a área por caixa é escalada pelo count. O count por imagem é escolhido aleatoriamente entre 1 e esse valor.
Conjuntos de dados
timm.data.create_dataset
< source >( name: strroot: typing.Optional[str] = Nonesplit: str = 'validation'search_split: bool = Trueclass_map: dict = Noneload_bytes: bool = Falseis_training: bool = Falsedownload: bool = Falsebatch_size: int = 1num_samples: typing.Optional[int] = Noneseed: int = 42repeats: int = 0input_img_mode: str = 'RGB'trust_remote_code: bool = False**kwargs )
Parâmetros
- name — Nome do dataset, pode ser vazio para datasets baseados em pastas. O prefixo (por exemplo,
hfds/) não diferencia maiúsculas de minúsculas, o restante é passado como está (diferenciando maiúsculas de minúsculas), exceto para nomes detorch/. - root — Pasta raiz do conjunto de dados (Todos)
- split — Divisão do conjunto de dados (Todos)
- search_split — Busca por uma dobra de subnível específica do split a partir da raiz, permitindo especificar
imagenet/em vez de/imagenet/val, etc. na linha de comando / configuração. (Pasta, Torch) - class_map — Especifique o mapeamento de classe -> índice por meio de um arquivo de texto ou dict (Folder)
- load_bytes — Carrega dados, retorna imagens como bytes não decodificados (Folder)
- download — Baixa o conjunto de dados, caso não esteja presente e seja suportado (HFIDS, TFDS, Torch)
- is_training — Cria o dataset em modo de treinamento, o que é diferente do split. Para Iterable / TDFS, isso habilita o shuffle, sendo ignorado para outros datasets. (TFDS, WDS, HFIDS)
- batch_size — Dica de tamanho de lote para conjuntos de dados iteráveis (TFDS, WDS, HFIDS)
- seed — Semente para conjuntos de dados iteráveis (TFDS, WDS, HFIDS)
- repeats — Repetições do dataset por iteração, ou seja, por epoch (TFDS, WDS, HFIDS)
- input_img_mode — Modo de conversão de cor da imagem de entrada, por exemplo, ‘RGB’, ‘L’ (pasta, TFDS, WDS, HFDS, HFIDS)
- trust_remote_code — Confie em código remoto em Hugging Face Datasets se True (HFDS, HFIDS)
- **kwargs — Outros argumentos para passar às classes subjacentes Dataset e/ou Reader
Método de fábrica de Dataset
Entre parênteses após cada arg estão os tipos de dataset suportados para cada arg, um dos seguintes:
- Pasta - default, pasta timm (ou tar) com base em ImageDataset
- Torch - conjuntos de dados baseados em torchvision
- HFDS - Hugging Face Datasets
- HFIDS - Hugging Face Datasets Iterável (modo de streaming, com IterableDataset)
- TFDS - Wrapper do Tensorflow-datasets na interface IterableDataset via IterableImageDataset
- WDS - Webdataset
- Todos - qualquer um dos acima
classe timm.data.ImageDataset
< source >( rootreader = Nonesplit = 'train'class_map = Noneload_bytes = Falseinput_img_mode = 'RGB'transform = Nonetarget_transform = Noneadditional_features = None**kwargs )
classe timm.data.IterableImageDataset
< source >( rootreader = Nonesplit = 'train'class_map = Noneis_training = Falsebatch_size = 1num_samples = Noneseed = 42repeats = 0download = Falseinput_img_mode = 'RGB'input_key = Nonetarget_key = Nonetransform = Nonetarget_transform = Nonemax_steps = None**kwargs )
Wrapper de dataset para executar AugMix ou outras misturas de dados limpos/aumentados
Codifique um alvo multi-rótulo como um tensor multi-hot float32 de comprimento num_classes.
Por padrão, o alvo é uma sequência de índices de classes positivas: uma sequência vazia significa que não há rótulos positivos, repetições são permitidas e valores negativos, fora do intervalo ou não inteiros são rejeitados. Com dense=True, o alvo já é um vetor de comprimento num_classes contendo valores bool, int ou float em [0, 1]; ele é validado e convertido para float32, mantendo os valores suaves.
Carregadores
timm.data.create_loader
< source >( dataset: typing.Union[timm.data.dataset.ImageDataset, timm.data.dataset.IterableImageDataset]input_size: typing.Union[int, typing.Tuple[int, int], typing.Tuple[int, int, int]]batch_size: intis_training: bool = Falseno_aug: bool = Falsere_prob: float = 0.0re_mode: str = 'const're_count: int = 1re_split: bool = Falsetrain_crop_mode: typing.Optional[str] = Nonescale: typing.Optional[typing.Tuple[float, float]] = Noneratio: typing.Optional[typing.Tuple[float, float]] = Nonehflip: float = 0.5vflip: float = 0.0color_jitter: float = 0.4color_jitter_prob: typing.Optional[float] = Nonegrayscale_prob: float = 0.0gaussian_blur_prob: float = 0.0auto_augment: typing.Optional[str] = Nonenum_aug_repeats: int = 0num_aug_splits: int = 0interpolation: str = 'bilinear'mean: typing.Tuple[float, ...] = (0.485, 0.456, 0.406)std: typing.Tuple[float, ...] = (0.229, 0.224, 0.225)num_workers: int = 1distributed: bool = Falsecrop_pct: typing.Optional[float] = Nonecrop_mode: typing.Optional[str] = Nonecrop_border_pixels: typing.Optional[int] = Nonecollate_fn: typing.Optional[typing.Callable] = Nonepin_memory: bool = Falsefp16: bool = Falseimg_dtype: dtype = torch.float32device: device = torch.device()use_prefetcher: bool = Trueuse_multi_epochs_loader: bool = Falsepersistent_workers: bool = Trueworker_seeding: str = 'all'tf_preprocessing: bool = Falseinput_size_choices: typing.Optional[typing.Sequence[typing.Union[int, typing.Tuple[int, int], typing.Tuple[int, int, int]]]] = Nonebatch_size_choices: typing.Optional[typing.Sequence[int]] = Nonebatch_choice_weights: typing.Optional[typing.Sequence[float]] = Nonebatch_choice_seed: int = 0batch_choice_schedule: str = 'constant'batch_schedule_epochs: typing.Optional[int] = Nonebatch_schedule_spread: float = 0.65batch_schedule_random_mix: float = 0.1num_batches: typing.Optional[int] = None )
Parâmetros
- dataset — O conjunto de dados de imagens a ser carregado.
- input_size — Tamanho de entrada alvo (canais, altura, largura) em tupla ou escalar.
- batch_size — Número de amostras em um lote.
- is_training — Retorna as transformações de treinamento (aleatórias).
- no_aug — Desativa a aumentação para o treinamento (útil para depuração).
- re_prob — Probabilidade de apagamento aleatório.
- re_mode — Modo de preenchimento do apagamento aleatório.
- re_count — Número de regiões de apagamento aleatório.
- re_split — Controla a divisão do random erasing em relação ao tamanho do lote.
- scale — Intervalo de escala para redimensionamento aleatório (área de recorte, < 1.0 => zoom in).
- ratio — Intervalo aleatório de proporção de aspecto (proporção de recorte para RRC, fator de ajuste de proporção para RKR).
- hflip — Probabilidade de inversão horizontal.
- vflip — Probabilidade de inversão vertical.
- color_jitter — Fatores de componentes de jitter de cor aleatório (brilho, contraste, saturação, matiz). Um escalar é aplicado como (escalar,) * 3 (sem matiz).
- color_jitter_prob — Aplique jitter de cor com esta probabilidade, se não for None (para aument
- grayscale_prob — Probabilidade de converter a imagem para escala de cinza (para aumentos semelhantes ao SimCLR).
- gaussian_blur_prob — Probabilidade de aplicar gaussian blur (para aumentos semelhantes ao SimCLR).
- auto_augment — String de configuração de auto augment (veja auto_augment.py).
- num_aug_repeats — Ativa um sampler especial para repetir a mesma augmentação em GPUs distribuídas.
- num_aug_splits — Ativa o modo em que as aumentações podem ser divididas entre o lote.
- interpolation — Modo de interpolação de imagem.
- mean — Média de normalização da imagem.
- std — Desvio padrão da normalização da imagem.
- num_workers — Número de processos de worker por DataLoader.
- distributed — Ativa o carregamento de dados para treinamento distribuído.
- crop_pct — Porcentagem de recorte na inferência (tamanho de saída / tamanho de redimensionamento).
- crop_mode — Modo de recorte para inferência. Um de [‘squash’, ‘border’, ‘center’]. O padrão é ‘center’ quando None.
- crop_border_pixels — Recorte de borda para inferência de # pixels especificados ao redor da borda da imagem original.
- collate_fn — Substitui o collate_fn padrão.
- pin_memory — Fixa a memória para transferência de dispositivo.
- fp16 — Argumento obsoleto para o dtype de entrada de meia precisão. Use img_dtype.
- img_dtype — Tipo de dados para a imagem de entrada.
- device — Dispositivo para o qual os inputs e targets serão transferidos.
- use_prefetcher — Use um pré-carregador eficiente para carregar amostras no dispositivo.
- use_multi_epochs_loader —
- persistent_workers — Ativa processos de worker persistentes quando
num_workersé maior que zero. - worker_seeding — Controla a semeadura aleatória dos workers na inicialização.
- tf_preprocessing — Use o pré-processamento de inferência do TF 1.0 para testar portagens de modelos.
- input_size_choices — Escolhas de tamanho de entrada por lote para o treinamento de resolução agendada.
- batch_size_choices — Tamanho do lote correspondente a cada escolha de tamanho de entrada. Usa
batch_sizepara todas as escolhas quando não especificado. - batch_choice_weights — Pesos de amostragem para as escolhas de tamanho de entrada. Uniformes quando não especificados.
- batch_choice_seed — Semente aleatória usada para criar e embaralhar o agendamento do lote.
- batch_choice_schedule — Modo de agendamento de escolha, seja
constantouprogressive. - batch_schedule_epochs — Número de épocas ao longo das quais um cronograma progressivo percorre suas escolhas.
- batch_schedule_spread — Desvio padrão da janela de escolha progressiva, em unidades de índice de escolha.
- batch_schedule_random_mix — Fração de exploração aleatória uniforme sobre as escolhas com peso não nulo em um progressive schedule.
- num_batches — Número fixo de lotes do loader por época. Inferido a partir do tamanho médio do lote do agendamento para agendamentos progressivos quando não especificado.
Mixup e CutMix
classe timm.data.Mixup
< source >( mixup_alpha = 1.0cutmix_alpha = 0.0cutmix_minmax = Noneprob = 1.0switch_prob = 0.5mode = 'batch'correct_lam = Truelabel_smoothing = 0.1num_classes = 1000multi_label = False )
Parâmetros
- mixup_alpha (float) — valor alpha do mixup, o mixup está ativo se > 0.
- cutmix_alpha (float) — valor do alpha do cutmix, o cutmix está ativo se > 0.
- cutmix_minmax (List[float]) — proporção mínima/máxima de imagem para cutmix, o cutmix está ativo e usa isso em vez de alpha, se não for None.
- prob (float) — probabilidade de aplicar mixup ou cutmix por lote ou elemento
- switch_prob (float) — probabilidade de alternar para cutmix em vez de mixup quando ambos estão ativos
- mode (str) — como aplicar os parâmetros de mixup/cutmix (por ‘batch’, ‘pair’ (par de elementos), ‘elem’ (elemento)
- correct_lam (bool) — aplica a correção lambda quando o bbox do cutmix é cortado pelas bordas da imagem
- label_smoothing (float) — aplica label smoothing ao tensor de destino misturado
- num_classes (int) — número de classes para o alvo
- multi_label (bool) — Misture alvos multi-rótulo densos, suavizando cada rótulo em direção a 0,5.
Mixup/Cutmix que aplica parâmetros diferentes a cada elemento ou ao lote inteiro
classe timm.data.FastCollateMixup
< source >( mixup_alpha = 1.0cutmix_alpha = 0.0cutmix_minmax = Noneprob = 1.0switch_prob = 0.5mode = 'batch'correct_lam = Truelabel_smoothing = 0.1num_classes = 1000multi_label = False )
Fast Collate com Mixup/Cutmix que aplica parâmetros diferentes a cada elemento ou ao lote inteiro
Uma implementação de Mixup que é executada durante a montagem dos lotes.
NaFlex
timm.data.create_naflex_loader
< source >( datasetpatch_size: typing.Union[int, typing.Tuple[int, int], NoneType] = Nonepatch_size_choices: typing.Optional[typing.List[int]] = Nonepatch_size_choice_probs: typing.Optional[typing.List[float]] = Nonetrain_seq_lens: typing.Tuple[int, ...] = (128, 256, 576, 784, 1024)max_seq_len: int = 576batch_size: int = 32is_training: bool = Falsemixup_fn: typing.Optional[typing.Callable] = Noneno_aug: bool = Falsere_prob: float = 0.0re_mode: str = 'const're_count: int = 1re_split: bool = Falsetrain_crop_mode: typing.Optional[str] = Nonescale: typing.Optional[typing.Tuple[float, float]] = Noneratio: typing.Optional[typing.Tuple[float, float]] = Nonehflip: float = 0.5vflip: float = 0.0color_jitter: float = 0.4color_jitter_prob: typing.Optional[float] = Nonegrayscale_prob: float = 0.0gaussian_blur_prob: float = 0.0auto_augment: typing.Optional[str] = Nonenum_aug_repeats: int = 0num_aug_splits: int = 0interpolation: str = 'bilinear'mean: typing.Tuple[float, ...] = (0.485, 0.456, 0.406)std: typing.Tuple[float, ...] = (0.229, 0.224, 0.225)channels: int = 3crop_pct: typing.Optional[float] = Nonecrop_mode: typing.Optional[str] = Nonecrop_border_pixels: typing.Optional[int] = Nonenum_workers: int = 4distributed: bool = Falserank: int = 0world_size: int = 1seed: int = 42epoch: int = 0use_prefetcher: bool = Truepin_memory: bool = Trueimg_dtype: dtype = torch.float32device: typing.Union[str, torch.device] = torch.device()persistent_workers: bool = Trueworker_seeding: str = 'all'patchify_channels_last: bool = True )
Parâmetros
- dataset — Dataset a ser carregado.
- patch_size — Tamanho único de patch a ser usado.
- patch_size_choices — Lista de tamanhos de patch para treinamento com tamanho de patch variável.
- patch_size_choice_probs — Probabilidades para cada escolha de tamanho de patch.
- train_seq_lens — Comprimentos de sequência de treinamento para loteamento dinâmico.
- max_seq_len — Comprimento fixo da sequência para validação.
- batch_size — Tamanho do lote para validação e comprimento máximo da sequência de treinamento.
- is_training — Indica se é para treinamento (ativa o loteamento dinâmico).
- mixup_fn — Função de mixup opcional.
- no_aug — Desativa a aumentação.
- re_prob — Probabilidade de apagamento aleatório.
- re_mode — Modo de apagamento aleatório.
- re_count — Número máximo de retângulos de apagamento.
- re_split — Sinalizador de divisão para apagamento aleatório.
- train_crop_mode — Modo de recorte para treinamento.
- scale — Intervalo de escala para o recorte de redimensionamento aleatório.
- ratio — Faixa de proporção de aspecto para o recorte de redimensionamento aleatório.
- hflip — Probabilidade de inversão horizontal.
- vflip — Probabilidade de inversão vertical.
- color_jitter — Fator de jitter de cor.
- color_jitter_prob — Probabilidade de jitter de cor.
- grayscale_prob — Probabilidade de conversão para escala de cinza.
- gaussian_blur_prob — Probabilidade de desfoque gaussiano.
- auto_augment — Política AutoAugment.
- num_aug_repeats — Número de repetições de aumento.
- num_aug_splits — Número de divisões de aumento.
- interpolation — Método de interpolação.
- mean — Valores médios de normalização.
- std — Valores de desvio padrão da normalização.
- channels — Número de canais da imagem, usado para normalização por canal no prefetcher.
- crop_pct — Porcentagem de recorte para validação.
- crop_mode — Modo de recorte.
- crop_border_pixels — Recorta os pixels da borda.
- num_workers — Número de workers de carregamento de dados.
- distributed — Se está usando treinamento distribuído.
- rank — Rank do processo para treinamento distribuído.
- world_size — Número total de processos.
- seed — Semente aleatória.
- epoch — Época inicial.
- use_prefetcher — Se deve usar pré-busca.
- pin_memory — Se deve fixar a memória.
- img_dtype — Tipo de dados da imagem.
- device — Dispositivo para onde mover os tensores.
- persistent_workers — Se deve usar workers persistentes quando
num_workersfor maior que zero. - worker_seeding — Modo de semeadura dos workers.
- patchify_channels_last — Layout plano por patch.
True(padrão): o índice do canal varia mais rapidamente (padrão do NaFlex).False: C-P-P (canais primeiro — layout nativo do Gemma4 / HF). Encaminhado para oPatchifyupstream e para o layout de normalização do prefetcher.
Crie um carregador de dados com amostragem de comprimento de sequência dinâmico para treinamento.
classe timm.data.NaFlexMapDatasetWrapper
< source >( base_dataset: Datasetpatch_size: typing.Union[int, typing.Tuple[int, int], NoneType] = Nonepatch_size_choices: typing.Optional[typing.List[int]] = Nonepatch_size_choice_probs: typing.Optional[typing.List[float]] = Noneseq_lens: typing.Tuple[int, ...] = (128, 256, 576, 784, 1024)max_tokens_per_batch: int = 16384transform_factory: typing.Optional[typing.Callable] = Nonemixup_fn: typing.Optional[typing.Callable] = Noneseed: int = 42shuffle: bool = Truedistributed: bool = Falserank: int = 0world_size: int = 1epoch: int = 0batch_divisor: int = 8patchify_channels_last: bool = True )
Wrapper de IterableDataset para um dataset base de estilo mapa.
Gera lotes com comprimentos de sequência variáveis. Ele calcula uma agenda de lote canônica (pares de comprimento de sequência e tamanho do lote) uma única vez com base no tamanho total do conjunto de dados (preenchido para distribuição). A cada época, ele embaralha a ordem dessa agenda canônica e os índices do conjunto de dados. Isso garante um número consistente de lotes e amostras por época em todos os ranks. Trata o treinamento distribuído e múltiplos workers.
Defina a leitura de epoch segura para multiprocessamento pelos workers do DataLoader.
classe timm.data.NaFlexMixup
< source >( num_classes: intmixup_alpha: float = 0.8cutmix_alpha: float = 1.0switch_prob: float = 0.5prob: float = 1.0local_shuffle: int = 4label_smoothing: float = 0.0mixup_off_epoch: int = 0multi_label: bool = False )
Wrapper chamável que combina a mistura e a geração de alvos.
Atualize o estado do mixup para a epoch fornecida.