transformers/main/pt/model_doc/efficientnet.md

EfficientNet

Visão geral

O modelo EfficientNet foi proposto em EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks por Mingxing Tan e Quoc V. Le. Os EfficientNets são uma família de modelos de classificação de imagens que alcançam precisão de estado da arte, sendo, no entanto, uma ordem de magnitude menores e mais rápidos do que os modelos anteriores.

O resumo do artigo é o seguinte:

Redes Neurais Convolucionais (ConvNets) são comumente desenvolvidas com um orçamento de recursos fixo e, em seguida, ampliadas para obter melhor precisão quando mais recursos estão disponíveis. Neste artigo, estudamos sistematicamente a escalação de modelos e identificamos que equilibrar cuidadosamente a profundidade, a largura e a resolução da rede pode levar a um melhor desempenho. Com base nessa observação, propomos um novo método de escalação que escala uniformemente todas as dimensões de profundidade/largura/resolução usando um coeficiente composto simples, porém altamente eficaz. Demonstramos a eficácia desse método na escalação de MobileNets e ResNet. Para ir ainda mais longe, usamos a busca de arquitetura neural para projetar uma nova rede de referência e a escalamos para obter uma família de modelos, chamada EfficientNets, que alcança muito melhor precisão e eficiência do que as ConvNets anteriores. Em particular, nosso EfficientNet-B7 alcança a precisão top-1 de 84,3% no ImageNet, sendo 8,4x menor e 6,1x mais rápido na inferência do que a melhor ConvNet existente. Nossos EfficientNets também se transferem bem e alcançam a precisão de estado da arte no CIFAR-100 (91,7%), Flowers (98,8%) e outros 3 conjuntos de dados de aprendizado por transferência, com uma ordem de grandeza a menos de parâmetros.

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

EfficientNetConfig[[transformers.EfficientNetConfig]]

transformers.EfficientNetConfig[[transformers.EfficientNetConfig]]

transformers.EfficientNetConfig(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, image_size: int | list[int] | tuple[int, int] = 600, width_coefficient: float = 2.0, depth_coefficient: float = 3.1, depth_divisor: int = 8, kernel_sizes: list[int] | tuple[int, ...] = (3, 3, 5, 3, 5, 5, 3), in_channels: list[int] | tuple[int, ...] = (32, 16, 24, 40, 80, 112, 192), out_channels: list[int] | tuple[int, ...] = (16, 24, 40, 80, 112, 192, 320), depthwise_padding: list[int] | tuple[int, ...] = (), strides: list[int] | tuple[int, ...] = (1, 2, 2, 2, 1, 2, 1), num_block_repeats: list[int] | tuple[int, ...] = (1, 2, 2, 3, 3, 4, 1), expand_ratios: list[int] | tuple[int, ...] = (1, 6, 6, 6, 6, 6, 6), squeeze_expansion_ratio: float = 0.25, hidden_act: str = 'swish', hidden_dim: int = 2560, pooling_type: str = 'mean', initializer_range: float = 0.02, batch_norm_eps: float = 0.001, batch_norm_momentum: float = 0.99, dropout_rate: float | int = 0.5, drop_connect_rate: float | int = 0.2)

Origem

Parâmetros:

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

image_size (Union[int, list[int], tuple[int, int]], opcional, padrão 600) : O tamanho (resolução) de cada imagem.

width_coefficient (float, opcional, padrão 2.0) : Coeficiente de escala para a largura da rede em cada estágio.

depth_coefficient (float, opcional, padrão 3.1) : Coeficiente de escala para a profundidade da rede em cada estágio.

depth_divisor (int, opcional, padrão 8) : Uma unidade de largura da rede.

kernel_sizes (list[int], opcional, padrão [3, 3, 5, 3, 5, 5, 3]) : Lista de tamanhos de kernel a serem usados em cada bloco.

in_channels (Union[list[int], tuple[int, ...]], opcional, padrão (32, 16, 24, 40, 80, 112, 192)) : O número de canais de entrada.

out_channels (list[int], opcional, padrão [16, 24, 40, 80, 112, 192, 320]) : Lista de tamanhos de canais de saída a serem usados em cada bloco para as camadas convolucionais.

depthwise_padding (list[int], opcional, padrão []) : Lista de índices de blocos com preenchimento quadrado.

strides (Union[list[int], tuple[int, ...]], opcional, padrão (1, 2, 2, 2, 1, 2, 1)) : Stride em cada estágio do modelo.

num_block_repeats (list[int], opcional, padrão [1, 2, 2, 3, 3, 4, 1]) : Lista com o número de vezes que cada bloco deve ser repetido.

expand_ratios (list[int], opcional, padrão [1, 6, 6, 6, 6, 6, 6]) : Lista dos coeficientes de escala de cada bloco.

squeeze_expansion_ratio (float, opcional, padrão 0.25) : Razão de expansão do squeeze.

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

hidden_dim (int, opcional, padrão 2560) : Dimensão das representações ocultas.

pooling_type (str ou function, opcional, padrão "mean") : Tipo de pooling final a ser aplicado antes da cabeça de classificação densa. As opções disponíveis são ["mean", "max"]

initializer_range (float, opcional, padrão 0.02) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

batch_norm_eps (float, opcional, padrão 0.001) : O epsilon usado pelas camadas de normalização de lote.

batch_norm_momentum (float, opcional, padrão 0.99) : O momento usado pelas camadas de normalização de lote.

dropout_rate (Union[float, int], opcional, padrão 0.5) : A proporção para todas as camadas de dropout.

drop_connect_rate (float, opcional, padrão 0.2) : A taxa de descarte para conexões de atalho.

Esta é a classe de configuração para armazenar a configuração de um EfficientNetModel. Ela é usada para instanciar um modelo Efficientnet 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/efficientnet-b7

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 EfficientNetConfig, EfficientNetModel

>>> # Initializing a EfficientNet efficientnet-b7 style configuration
>>> configuration = EfficientNetConfig()

>>> # Initializing a model (with random weights) from the efficientnet-b7 style configuration
>>> model = EfficientNetModel(configuration)

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

EfficientNetImageProcessor[[transformers.EfficientNetImageProcessor]]

transformers.EfficientNetImageProcessor[[transformers.EfficientNetImageProcessor]]

transformers.EfficientNetImageProcessor(**kwargs: *<class 'transformers.models.efficientnet.image_processing_efficientnet.EfficientNetImageProcessorKwargs'>)

Origem

Parâmetros:

do_convert_rgb (bool, kwargs, opcional) : 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 {'height' : 346, 'width': 346}): Descreve as dimensões máximas de entrada para o modelo.

default_to_square (bool, kwargs, opcional, padrão True) : 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' : 289, 'width': 289}): 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.5, 0.5, 0.5]) : 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.5, 0.5, 0.5]) : 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 False) : 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.

rescale_offset (bool, kwargs, opcional, padrão self.rescale_offset) : Se deve reescalar a imagem entre [-max_range/2, scale_range/2] em vez de [0, scale_range].

include_top (bool, kwargs, opcional, padrão self.include_top) : Normaliza a imagem novamente apenas com o desvio padrão para classificação de imagem, se definido como True.

Constrói um processador de imagem EfficientNetImageProcessor.

preprocess[[transformers.EfficientNetImageProcessor.preprocess]]

preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], *args, image_like_kwargs: dict[str, typing.Any] | None = None, **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)

Origem

Parâmetros:

images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina do_rescale=False.

image_like_kwargs (dict[str, Any], opcional) : Sinalizador do desenvolvedor para entradas adicionais semelhantes a imagens que também serão pré-processadas. Use isso apenas se a passagem das entradas como kwarg não funcionar. Por exemplo, preprocess(images, masks=masks) é a opção preferida, mas resulta em problemas de prioridade de argumentos para alguns modelos. Nesses casos, preprocess(images, image_like_inputs={"masks": masks}) pode ser usado em vez disso.

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

do_resize (bool, kwargs, opcional) : Se deve redimensionar a imagem.

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

default_to_square (bool, kwargs, opcional) : 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) : Tamanho da imagem de saída após aplicar center_crop.

resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) : Filtro de redimensionamento 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) : Se deve reescalar a imagem.

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

do_normalize (bool, kwargs, opcional) : Se a imagem deve ser normalizada.

image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional) : 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) : 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) : Se deve centralizar o recorte da 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: ~image_processing_base.BatchFeature

• data (dict) -- Dicionário de listas/arrays/tensors retornados pelo método call ('pixel_values', etc.).
• tensor_type (Union[None, str, TensorType], opcional) -- Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.

Pré-processa uma imagem ou um lote de imagens.

EfficientNetImageProcessorPil[[transformers.EfficientNetImageProcessorPil]]

transformers.EfficientNetImageProcessorPil[[transformers.EfficientNetImageProcessorPil]]

transformers.EfficientNetImageProcessorPil(**kwargs: *<class 'transformers.models.efficientnet.image_processing_pil_efficientnet.EfficientNetImageProcessorKwargs'>)

Origem

Parâmetros:

do_convert_rgb (bool, kwargs, opcional) : 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 {'height' : 346, 'width': 346}): Descreve as dimensões máximas de entrada para o modelo.

default_to_square (bool, kwargs, opcional, padrão True) : 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' : 289, 'width': 289}): 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.5, 0.5, 0.5]) : 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.5, 0.5, 0.5]) : 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 False) : 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.

rescale_offset (bool, kwargs, opcional, padrão self.rescale_offset) : Se deve reescalar a imagem entre [-max_range/2, scale_range/2] em vez de [0, scale_range].

include_top (bool, kwargs, opcional, padrão self.include_top) : Normaliza a imagem novamente apenas com o desvio padrão para classificação de imagem, se definido como True.

Constrói um processador de imagem EfficientNetImageProcessor.

preprocess[[transformers.EfficientNetImageProcessorPil.preprocess]]

preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], *args, image_like_kwargs: dict[str, typing.Any] | None = None, **kwargs: *<class 'transformers.processing_utils.ImagesKwargs'>)

Origem

Parâmetros:

images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina do_rescale=False.

image_like_kwargs (dict[str, Any], opcional) : Sinalizador do desenvolvedor para entradas adicionais semelhantes a imagens que também serão pré-processadas. Use isso apenas se a passagem das entradas como kwarg não funcionar. Por exemplo, preprocess(images, masks=masks) é a opção preferida, mas resulta em problemas de prioridade de argumentos para alguns modelos. Nesses casos, preprocess(images, image_like_inputs={"masks": masks}) pode ser usado em vez disso.

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

do_resize (bool, kwargs, opcional) : Se deve redimensionar a imagem.

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

default_to_square (bool, kwargs, opcional) : 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) : Tamanho da imagem de saída após aplicar center_crop.

resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) : Filtro de redimensionamento 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) : Se deve reescalar a imagem.

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

do_normalize (bool, kwargs, opcional) : Se a imagem deve ser normalizada.

image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional) : 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) : 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) : Se deve centralizar o recorte da 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: ~image_processing_base.BatchFeature

• data (dict) -- Dicionário de listas/arrays/tensors retornados pelo método call ('pixel_values', etc.).
• tensor_type (Union[None, str, TensorType], opcional) -- Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.

Pré-processa uma imagem ou um lote de imagens.

EfficientNetModel[[transformers.EfficientNetModel]]

transformers.EfficientNetModel[[transformers.EfficientNetModel]]

transformers.EfficientNetModel(config: EfficientNetConfig)

Origem

Parâmetros:

config (EfficientNetConfig) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo Efficientnet puro que produz estados ocultos brutos, sem nenhum cabeçalho específico no topo.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

forward[[transformers.EfficientNetModel.forward]]

forward(pixel_values: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)

Origem

Parâmetros:

pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size), opcional) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando EfficientNetImageProcessor. Veja EfficientNetImageProcessor.call() para detalhes (processor_class usa EfficientNetImageProcessor para processar imagens).

output_hidden_states (bool, opcional) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte hidden_states em tensores retornados para mais detalhes.

return_dict (bool, opcional) : Se deve ou não retornar um ModelOutput em vez de uma tupla simples.

Retorna: BaseModelOutputWithPoolingAndNoAttention ou tuple(torch.Tensor)

Um BaseModelOutputWithPoolingAndNoAttention ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos dependendo da configuração (EfficientNetConfig) e das entradas.

O método forward do EfficientNetModel substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

• last_hidden_state (torch.Tensor de forma (batch_size, num_channels, height, width)) -- Sequência de estados ocultos na saída da última camada do modelo.

• pooler_output (torch.Tensor de forma (batch_size, hidden_size)) -- Estado oculto da última camada após uma operação de pooling nas dimensões espaciais.

• hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) -- Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma (batch_size, num_channels, height, width).

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

Exemplo:

EfficientNetForImageClassification[[transformers.EfficientNetForImageClassification]]

transformers.EfficientNetForImageClassification[[transformers.EfficientNetForImageClassification]]

transformers.EfficientNetForImageClassification(config: EfficientNetConfig)

Origem

Parâmetros:

config (EfficientNetConfig) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Modelo EfficientNet com uma cabeça de classificação de imagem no topo (uma camada linear sobre os recursos agregados), por exemplo, para o ImageNet.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

forward[[transformers.EfficientNetForImageClassification.forward]]

forward(pixel_values: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)

Origem

Parâmetros:

pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size), opcional) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando EfficientNetImageProcessor. Veja EfficientNetImageProcessor.call() para detalhes (processor_class usa EfficientNetImageProcessor para processar imagens).

labels (torch.LongTensor de forma (batch_size,), opcional) : Rótulos para o cálculo da perda de classificação/regressão de imagem. Os índices devem estar em [0, ..., config.num_labels - 1]. Se config.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio). Se config.num_labels > 1, uma perda de classificação é calculada (entropia cruzada).

output_hidden_states (bool, opcional) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte hidden_states em tensores retornados para mais detalhes.

return_dict (bool, opcional) : Se deve ou não retornar um ModelOutput em vez de uma tupla simples.

Retorna: ImageClassifierOutputWithNoAttention ou tuple(torch.Tensor)

Um ImageClassifierOutputWithNoAttention ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos dependendo da configuração (EfficientNetConfig) e das entradas.

O método forward de EfficientNetForImageClassification substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

• loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) -- Perda de classificação (ou de regressão se config.num_labels==1).
• logits (torch.Tensor de forma (batch_size, config.num_labels)) -- Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).
• hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) -- Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada estágio) de forma (batch_size, num_channels, height, width). Estados ocultos (também chamados de mapas de características) do modelo na saída de cada estágio.

Exemplo:

>>> from transformers import AutoImageProcessor, EfficientNetForImageClassification
>>> import torch
>>> from datasets import load_dataset

>>> dataset = load_dataset("huggingface/cats-image")
>>> image = dataset["test"]["image"][0]

>>> image_processor = AutoImageProcessor.from_pretrained("google/efficientnet-b7")
>>> model = EfficientNetForImageClassification.from_pretrained("google/efficientnet-b7")

>>> inputs = image_processor(image, return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # model predicts one of the 1000 ImageNet classes
>>> predicted_label = logits.argmax(-1).item()
>>> print(model.config.id2label[predicted_label])
...