timm documentation

Dados

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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-size define a forma de entrada (C, H, W).
  • --img-size é o atalho quadrado para --input-size, mantendo a contagem de canais do modelo.
  • --in-chans define os canais de entrada.
  • --interpolation define a interpolação de redimensionamento.
  • --mean define a média de normalização.
  • --std define o desvio padrão da normalização.
  • --crop-pct define a fração de recorte para avaliação.

Criação do dataset (create_dataset) e configuração do alvo:

  • --dataset seleciona o conjunto de dados e o leitor.
  • --data-dir define a raiz do conjunto de dados.
  • --train-split seleciona o split de treinamento.
  • --val-split seleciona a divisão de validação.
  • --class-map fornece o mapeamento de classes.
  • --input-img-mode define o modo de conversão de cor da imagem.
  • --input-key seleciona o campo da imagem.
  • --target-key seleciona o campo ou os campos de rótulo.
  • --target-format seleciona índices de classe ou alvos multi-hot densos.

As opções de carregador e aumento de dados (create_loader) incluem:

  • --aa seleciona a política de auto-aumento.
  • --reprob define a probabilidade de apagamento aleatório.
  • --remode seleciona o modo de preenchimento do apagamento aleatório.
  • --scale define o intervalo de escala para o recorte redimensionado aleatório.
  • --ratio define o intervalo da proporção de aspecto para o recorte redimensionado aleatório.
  • --hflip define a probabilidade de inversão horizontal.
  • --color-jitter define a intensidade da variação de cor.
  • --train-interpolation define a interpolação de redimensionamento para o treinamento.
  • --workers define o número de workers do loader.
  • --no-prefetcher desativa o prefetcher.

Mixup e CutMix (Mixup):

  • --mixup define o alpha do Mixup.
  • --cutmix define o alpha do CutMix.
  • --cutmix-minmax define o intervalo de tamanho da caixa do CutMix.
  • --mixup-prob define a probabilidade de mistura.
  • --mixup-switch-prob define a probabilidade de escolher o CutMix quando ambos os métodos estão habilitados.
  • --mixup-mode seleciona a mistura por lote, por par ou elemento a elemento.
  • --smoothing define 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).

Chavechaves de argsDescriçãoPadrão
input_sizeinput_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)
interpolationinterpolationInterpolação de redimensionamento, bilinear, bicubic, …bicubic
mean, stdmean, stdNormalização, um único valor é repetido para cada canalMédia / desvio padrão do ImageNet
crop_pctcrop_pctNo 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_modecrop_modeModo de recorte de avaliação, center, squash ou bordercenter

Os modos de recorte de avaliação, para um size de saída e scale_size = floor(size / crop_pct):

crop_modeComportamento
centerRedimensione a aresta mais curta para scale_size (mantendo a proporção) e faça um recorte centralizado para size
squashRedimensione ambas as bordas para scale_size (a proporção não é preservada), faça um recorte centralizado para size
borderRedimensione 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 do train.py para treinamento) seleciona bilinear ou bicúbico para cada imagem.
  • no_aug=True reduz o treinamento a um redimensionamento e um recorte centralizado.
auto_augmentAumento
rand-m9-mstd0.5-inc1RandAugment via rand_augment_transform
augmix-m5-w4-d2AugMix via augment_and_mix_transform
original, originalr, v0, v0r, 3aPolítica AutoAugment via auto_augment_transform

Tokens de opções de RandAugment:

  • m define a magnitude (padrão 10).
  • n define o número de operações por imagem (padrão 2).
  • p define a probabilidade por operação (padrão 0.5).
  • mstd define o desvio padrão do ruído de magnitude.
  • inc1 seleciona 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:

  • m define a severidade (padrão 3).
  • w define a largura (padrão 3).
  • d define a profundidade (padrão -1, aleatório 1-3).
  • b1 permite a ampliação mista.
  • mstd define 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_augment está definido, a menos que a string contenha 3a.
  • RandomErasing (re_prob, re_count) é executado no tensor normalizado. re_mode preenche com zeros (const, o padrão), uma cor normal aleatória por região (rand) ou pixels normais aleatórios (pixel, o padrão do train.py).
  • use_prefetcher=True encerra a transformação em um tensor uint8, e a normalização e o apagamento aleatório são então executados pelo loader no dispositivo.
  • create_transform e create_loader usam por padrão a interpolação bilinear e 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:

nameConjunto de dadosrootExige
'' ou sem prefixoImageDataset, imagens em subpastas de classes (busca recursiva, o nome da pasta folha é a classe) ou um único arquivo .tar com o mesmoPasta 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_datasetDiretório de cache (opcional)datasets
hfids/<name>IterableImageDataset, o dataset do Hugging Face transmitido em streaming, ou baixado e preparado primeiro com download=TrueDiretório de cache (opcional)datasets
tfds/<name>IterableImageDataset no TensorFlow Datasets, download=True baixa e criaDiretório de dados do TFDStensorflow, tensorflow-datasets
wds/<name>IterableImageDataset em shards tar do WebDatasetPasta de shards com um _info.json (ou info.json) descrevendo as divisõeswebdataset

Opções de dataset:

  • split seleciona o split do dataset (padrão validation). 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 de root chamada split ou, 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_extensions adiciona às extensões de imagem padrão (.png, .jpg e .jpeg).
  • class_map remapeia 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_training habilita a embaralhamento.
  • batch_size arredonda para cima a parte de cada worker dos exemplos para lotes inteiros durante o treinamento.
  • num_samples define a contagem de amostras, necessária quando o leitor não consegue determiná-la (hfids sem informações de divisão).
  • seed define a semente aleatória.
  • repeats multiplica 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_key seleciona o campo de imagem (por padrão, image; para wds, uma imagem jpg, png ou webp).
  • target_key seleciona o campo de rótulo (por padrão, label; para wds, o arquivo .cls ou um campo lateral .json nomeado por target_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. Passe dense=True para MultiLabelTarget para 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 tensores uint8, os lotes são movidos para o device (padrão cuda, em um stream lateral para CUDA), convertidos para img_dtype, normalizados e aleatoriamente apagados ali. Defina device para o dispositivo de treinamento, ou use_prefetcher=False para um DataLoader simples de tensores normalizados.
  • Distribuído. distributed=True usa um DistributedSampler para conjuntos de dados de treinamento em estilo mapa (ou um sampler de aumento repetido com num_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_fn substitui o padrão (fast_collate com o prefetcher, default_collate sem), por exemplo, por um FastCollateMixup.
  • Divisões de aumento. Para o AugMix com a perda JSD (--aug-splits), envolva o dataset em AugMixDataset(dataset, num_splits=n) e passe num_aug_splits=n. Cada lote contém uma divisão limpa e n - 1 divisõ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 agendamento progressive da 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 > 0 habilita o Mixup.
  • cutmix_alpha > 0 habilita o CutMix.
  • cutmix_minmax habilita o CutMix com um intervalo de tamanho de caixa.
  • switch_prob define a probabilidade de escolher CutMix quando ambos os métodos estão habilitados.
  • prob define a probabilidade de misturar.
  • mode desenha os parâmetros uma vez por batch, por pair de elementos ou por elem (elemento).
  • multi_label=True mistura alvos multirótulo densos, suavizando cada rótulo em direção a 0,5.
  • mixup_enabled = False desativa a mistura, por exemplo, para os últimos epochs (--mixup-off-epoch). Para FastCollateMixup, 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 dos train_seq_lens por 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 (com patch_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_len patches no patch_size especificado (obrigatório para avaliação) e preenchidas até max_seq_len.
  • Mixup. Passe um NaFlexMixup como mixup_fn; ele mistura dentro de cada lote e não suporta mode ou cutmix_minmax.

As opções do train.py são:

  • --naflex-loader habilita o carregador NaFlex.
  • --naflex-train-seq-lens define os comprimentos das sequências de treinamento.
  • --naflex-max-seq-len define o comprimento máximo da sequência de avaliação.
  • --naflex-patch-sizes define os tamanhos de patch para o treinamento com tamanho de patch variável.
  • --naflex-patch-size-probs define as probabilidades para esses tamanhos de patch.
  • --naflex-loss-scale seleciona a escala de perda pelo tamanho do lote (none, sqrt ou linear).

API

Configuração de dados

timm.data.resolve_data_config

< >

( args = Nonepretrained_cfg = Nonemodel = Noneuse_test_size = Falseverbose = False )

timm.data.resolve_model_data_config

< >

( 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

< >

( 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

< >

( 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

< >

( 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

< >

( 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

< >

( 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

< >

( 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

< >

( 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 de torch/.
  • 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

< >

( rootreader = Nonesplit = 'train'class_map = Noneload_bytes = Falseinput_img_mode = 'RGB'transform = Nonetarget_transform = Noneadditional_features = None**kwargs )

classe timm.data.IterableImageDataset

< >

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

classe timm.data.AugMixDataset

< >

( datasetnum_splits = 2 )

Wrapper de dataset para executar AugMix ou outras misturas de dados limpos/aumentados

classe timm.data.MultiLabelTarget

< >

( num_classes: intdense: bool = False )

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

< >

( 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_size para 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 constant ou progressive.
  • 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

< >

( 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

< >

( 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

< >

( 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_workers for 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 o Patchify upstream 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

< >

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

set_epoch

< >

( epoch: int )

Parâmetros

  • epoch — Novo número de epoch.

Defina a leitura de epoch segura para multiprocessamento pelos workers do DataLoader.

classe timm.data.NaFlexMixup

< >

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

set_epoch

< >

( epoch: int )

Atualize o estado do mixup para a epoch fornecida.

Update on GitHub