hf-doc-build/doc / transformers /main /pt /model_doc /bit.md

|

46.3 kB

Big Transfer (BiT)

Visão geral

O modelo BiT foi proposto em Big Transfer (BiT): General Visual Representation Learning por Alexander Kolesnikov, Lucas Beyer, Xiaohua Zhai, Joan Puigcerver, Jessica Yung, Sylvain Gelly e Neil Houlsby. O BiT é uma receita simples para escalar o pré-treinamento de arquiteturas semelhantes a ResNet (especificamente, ResNetv2). O método resulta em melhorias significativas para o transfer learning.

O resumo do artigo é o seguinte:

A transferência de representações pré-treinadas melhora a eficiência de amostras e simplifica o ajuste de hiperparâmetros ao treinar redes neurais profundas para visão. Revisitamos o paradigma de pré-treino em grandes datasets supervisionados e ajuste fino do modelo em uma tarefa-alvo. Escalamos o pré-treino e propomos uma receita simples que chamamos de Big Transfer (BiT). Ao combinar alguns componentes cuidadosamente selecionados e transferir usando uma heurística simples, alcançamos forte desempenho em mais de 20 datasets. O BiT apresenta bom desempenho em uma faixa surpreendentemente ampla de regimes de dados — de 1 exemplo por classe a 1M de exemplos no total. O BiT atinge 87,5% de precisão top-1 no ILSVRC-2012, 99,4% no CIFAR-10 e 76,3% no Visual Task Adaptation Benchmark (VTAB) de 19 tarefas. Em datasets pequenos, o BiT atinge 76,8% no ILSVRC-2012 com 10 exemplos por classe e 97,0% no CIFAR-10 com 10 exemplos por classe. Realizamos uma análise detalhada dos principais componentes que levam a um alto desempenho de transferência.

Este modelo foi contribuído por nielsr. O código original pode ser encontrado aqui.

Dicas de uso

Os modelos BiT são equivalentes ao ResNetv2 em termos de arquitetura, exceto que: 1) todas as camadas de normalização de lote são substituídas por normalização de grupo,

normalização de pesos é usada para camadas convolucionais. Os autores mostram que a combinação de ambos é útil para o treinamento com tamanhos de lote grandes e tem um impacto no aprendizado por transferência.

Recursos

Uma lista de recursos oficiais da Hugging Face e da comunidade (indicados por 🌎) para ajudar você a começar com o BiT.

O BitForImageClassification é suportado por este notebook.
Veja também: Guia da tarefa de classificação de imagens

Se você tiver interesse em enviar um recurso para ser incluído aqui, sinta-se à vontade para abrir um Pull Request e faremos a revisão! O recurso deve, idealmente, demonstrar algo novo, em vez de duplicar um recurso existente.

BitConfig[[transformers.BitConfig]]

transformers.BitConfig[[transformers.BitConfig]]

transformers.BitConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, num_channels: int = 3, embedding_size: int = 64, hidden_sizes: list[int] | tuple[int, ...] = (256, 512, 1024, 2048), depths: list[int] | tuple[int, ...] = (3, 4, 6, 3), layer_type: str = 'preactivation', hidden_act: str = 'relu', global_padding: str | None = None, num_groups: int = 32, drop_path_rate: float | int = 0.0, embedding_dynamic_padding: bool = False, output_stride: int = 32, width_factor: int = 1, _out_features: list[str] | None = None, _out_indices: list[int] | None = None)

Origem

Parâmetros:

num_channels (int, opcional, padrão 3) : O número de canais de entrada.

embedding_size (int, opcional, padrão 64) : Dimensionalidade dos embeddings e dos estados ocultos.

hidden_sizes (Union[list[int], tuple[int, ...]], opcional, padrão (256, 512, 1024, 2048)) : Dimensionalidade (tamanho oculto) em cada etapa do modelo.

depths (Union[list[int], tuple[int, ...]], opcional, padrão (3, 4, 6, 3)) : Profundidade de cada camada no Transformer.

layer_type (str, opcional, padrão "preactivation") : A camada a ser usada, pode ser "preactivation" ou "bottleneck".

hidden_act (str, opcional, padrão relu) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.

global_padding (str, opcional) : Estratégia de preenchimento a ser usada para as camadas convolucionais. Pode ser "valid", "same" ou None.

num_groups (int, opcional, padrão 32) : Número de grupos usados nas camadas BitGroupNormActivation.

drop_path_rate (Union[float, int], opcional, padrão 0.0) : Taxa de drop path para a fusão de patches.

embedding_dynamic_padding (bool, opcional, padrão False) : Indica se deve ou não utilizar padding dinâmico para a camada de incorporação.

output_stride (int, opcional, padrão 32) : A proporção entre a resolução espacial dos mapas de recursos de entrada e de saída.

width_factor (int, opcional, padrão 1) : O fator de largura para o modelo.

Esta é a classe de configuração para armazenar a configuração de um BitModel. Ela é usada para instanciar um modelo Bit de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do google/bit-50

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Leia a documentação de PreTrainedConfig para mais informações.

Exemplo:

>>> from transformers import BitConfig, BitModel

>>> # Initializing a BiT bit-50 style configuration
>>> configuration = BitConfig()

>>> # Initializing a model (with random weights) from the bit-50 style configuration
>>> model = BitModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

BitImageProcessor[[transformers.BitImageProcessor]]

transformers.BitImageProcessor[[transformers.BitImageProcessor]]

transformers.BitImageProcessor(**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)

Origem

Parâmetros:

do_convert_rgb (bool, kwargs, opcional, padrão True) : Se deve converter a imagem para RGB.

do_resize (bool, kwargs, opcional, padrão True) : Se deve redimensionar a imagem.

size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão {'shortest_edge' : 224}): Descreve as dimensões máximas de entrada para o modelo.

default_to_square (bool, kwargs, opcional, padrão False) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.

crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão {'height' : 224, 'width': 224}): Tamanho da imagem de saída após aplicar center_crop.

resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, padrão 3) : Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.

do_rescale (bool, kwargs, opcional, padrão True) : Se deve reescalar a imagem.

rescale_factor (float, kwargs, opcional, padrão 0.00392156862745098) : Fator de redimensionamento para redimensionar a imagem, caso do_rescale esteja definido como True.

do_normalize (bool, kwargs, opcional, padrão True) : Se a imagem deve ser normalizada.

image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão [0.48145466, 0.4578275, 0.40821073]) : Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.

image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão [0.26862954, 0.26130258, 0.27577711]) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.

do_pad (bool, kwargs, opcional) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo.

pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) : O tamanho em {"height": int, "width" int} para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se pad_size não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando do_pad=True.

do_center_crop (bool, kwargs, opcional, padrão True) : Se deve aplicar um recorte centralizado na imagem.

data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) : Apenas ChannelDimension.FIRST é suportado. Adicionado para compatibilidade com processadores lentos.

input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - "channels_first" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width). - "channels_last" ou ChannelDimension.LAST: imagem no formato (height, width, num_channels). - "none" ou ChannelDimension.NONE: imagem no formato (height, width).

device (Annotated[Union[str, torch.device, NoneType], None], kwargs) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.

return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) : Retorna tensores empilhados se definido como 'pt', caso contrário, retorna uma lista de tensores.

disable_grouping (bool, kwargs, opcional) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157

image_seq_length (int, kwargs, opcional) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. Retorna tensores empilhados se definido como 'pt', caso contrário, retorna uma lista de tensores.