Transformers documentation
HGNet-V2
Este modelo foi contribuído para o Hugging Face Transformers em 29/04/2025.
HGNet-V2
HGNetV2 é um backbone de rede neural convolucional (CNN) de próxima geração, projetado para o melhor compromisso entre precisão e latência em GPUs NVIDIA. Baseado no HGNet original, o HGNetV2 oferece alta precisão com velocidades de inferência rápidas e apresenta bom desempenho em tarefas como classificação de imagens, detecção de objetos e segmentação, tornando-o uma escolha prática para aplicações de visão computacional baseadas em GPU.
Você pode encontrar todos os modelos originais do HGNet V2 na organização USTC.
Este modelo foi contribuído por VladOS95-cyber. Clique nos modelos HGNet V2 na barra lateral à direita para ver mais exemplos de como aplicar o HGNet V2 a diferentes tarefas de visão computacional.
O exemplo abaixo demonstra como classificar uma imagem com Pipeline ou a classe AutoModel.
from transformers import pipeline
pipeline = pipeline(
task="image-classification",
model="ustc-community/hgnet-v2",
device=0
)
pipeline("http://images.cocodataset.org/val2017/000000039769.jpg")import requests
import torch
from PIL import Image
from transformers import AutoImageProcessor, HGNetV2ForImageClassification
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
model = HGNetV2ForImageClassification.from_pretrained("ustc-community/hgnet-v2", device_map="auto")
processor = AutoImageProcessor.from_pretrained("ustc-community/hgnet-v2")
inputs = processor(images=image, return_tensors="pt").to(model.device)
with torch.no_grad():
logits = model(**inputs).logits
predicted_class_id = logits.argmax(dim=-1).item()
class_labels = model.config.id2label
predicted_class_label = class_labels[predicted_class_id]
print(f"The predicted class label is: {predicted_class_label}")HGNetV2Config
classe transformers.HGNetV2Config
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonenum_channels: int = 3embedding_size: int = 64depths: list[int] | tuple[int, ...] = (3, 4, 6, 3)hidden_sizes: list[int] | tuple[int, ...] = (256, 512, 1024, 2048)hidden_act: str = 'relu'_out_features: list[str] | None = None_out_indices: list[int] | None = Nonestem_channels: list[int] | tuple[int, ...] = (3, 32, 48)stem_strides: Sequence = (2, 1, 1, 2, 1)stage_in_channels: list[int] | tuple[int, ...] = (48, 128, 512, 1024)stage_mid_channels: list[int] | tuple[int, ...] = (48, 96, 192, 384)stage_out_channels: list[int] | tuple[int, ...] = (128, 512, 1024, 2048)stage_num_blocks: list[int] | tuple[int, ...] = (1, 1, 3, 1)stage_downsample: list[bool] | tuple[bool, ...] = (False, True, True, True)stage_downsample_strides: Sequence = (2, 2, 2, 2)stage_light_block: list[bool] | tuple[bool, ...] = (False, False, True, True)stage_kernel_size: list[int] | tuple[int, ...] = (3, 3, 5, 5)stage_numb_of_layers: list[int] | tuple[int, ...] = (6, 6, 6, 6)use_learnable_affine_block: bool = Falseinitializer_range: float = 0.02 )
Parâmetros
- num_channels (
int, opcional, padrão3) — O número de canais de entrada. - embedding_size (
int, opcional, padrão64) — Dimensão dos embeddings e dos estados ocultos. - depths (
Union[list[int], tuple[int, ...]], opcional, padrão(3, 4, 6, 3)) — Profundidade de cada camada no Transformer. - hidden_sizes (
Union[list[int], tuple[int, ...]], opcional, padrão(256, 512, 1024, 2048)) — Dimensão (tamanho oculto) em cada etapa do modelo. - hidden_act (
str, opcional, padrãorelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo,"gelu","relu","silu", etc. - stem_channels (
list[int], opcional, padrão[3, 32, 48]) — Dimensões dos canais para as camadas do stem:- O primeiro número (3) é o número de canais da imagem de entrada
- O segundo número (32) são os canais intermediários do caule
- O terceiro número (48) são os canais do cauda de saída
- stem_strides (
Sequence[int | list[int] | tuple[int, ...]], opcional, padrão(2, 1, 1, 2, 1)) — Padrões de stride para as camadas do stem. - stage_in_channels (
list[int], opcional, padrão[48, 128, 512, 1024]) — Dimensões dos canais de entrada para cada estágio do backbone. Isso define quantos canais a entrada de cada estágio terá. - stage_mid_channels (
list[int], opcional, padrão[48, 96, 192, 384]) — Dimensões dos canais intermediários para cada estágio do backbone. Isso define o número de canais usados nas camadas intermediárias de cada estágio. - stage_out_channels (
list[int], opcional, padrão[128, 512, 1024, 2048]) — Dimensões dos canais de saída para cada estágio do backbone. Isso define quantos canais a saída de cada estágio terá. - stage_num_blocks (
list[int], opcional, padrão[1, 1, 3, 1]) — Número de blocos a serem usados em cada estágio do backbone. Isso controla a profundidade de cada estágio, especificando quantos blocos convolucionais empilhar. - stage_downsample (
list[bool], opcional, padrão[False, True, True, True]) — Indica se as feature maps devem ser reduzidas em cada estágio. SeTrue, as dimensões espaciais das feature maps serão reduzidas. - stage_downsample_strides (
Sequence[int | list[int] | tuple[int, ...]], opcional, padrão(2, 2, 2, 2)) — Padrões de stride para cada camada de estágio. - stage_light_block (
list[bool], opcional, padrão[False, False, True, True]) — Indica se os blocos leves devem ser usados em cada estágio. Os blocos leves são uma variante dos blocos convolucionais que podem ter menos parâmetros. - stage_kernel_size (
list[int], opcional, padrão[3, 3, 5, 5]) — Tamanhos dos kernels para as camadas convolucionais em cada estágio. - stage_numb_of_layers (
list[int], opcional, padrão[6, 6, 6, 6]) — Número de camadas a serem usadas em cada bloco do estágio. - use_learnable_affine_block (
bool, opcional, padrãoFalse) — Indica se deve usar Learnable Affine Blocks (LAB) na rede. LAB adiciona parâmetros de escala e viés aprendíveis após certas operações. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
Esta é a classe de configuração para armazenar a configuração de um HGNetV2Backbone. Ela é usada para instanciar um modelo Hgnet V2 de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os valores padrão resultará em uma configuração semelhante à do ustc-community/dfine_x_coco
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
HGNetV2Backbone
forward
< source >( pixel_values: Tensoroutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BackboneOutput or tuple(torch.Tensor)
Parâmetros
- pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size)) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usandoimage_processor_class. Consulteimage_processor_class.__call__para mais detalhes (processor_classusaimage_processor_classpara processar as imagens). - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - return_dict (
bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.
Retorna
BackboneOutput ou tuple(torch.Tensor)
Um BackboneOutput 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 (HGNetV2Config) e das entradas.
O método forward de HGNetV2Backbone 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
Moduleem 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.
feature_maps (
tuple(torch.Tensor)de forma(batch_size, num_channels, height, width)) — Mapas de características dos estágios.hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size)ou(batch_size, num_channels, height, width), dependendo do backbone.Estados ocultos do modelo na saída de cada estágio, além das saídas do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length). Aplicável apenas se o backbone usar atenção.Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
Exemplos:
>>> from transformers import HGNetV2Config, HGNetV2Backbone
>>> import torch
>>> config = HGNetV2Config()
>>> model = HGNetV2Backbone(config)
>>> pixel_values = torch.randn(1, 3, 224, 224)
>>> with torch.no_grad():
... outputs = model(pixel_values)
>>> feature_maps = outputs.feature_maps
>>> list(feature_maps[-1].shape)
[1, 2048, 7, 7]HGNetV2ForImageClassification
classe transformers.HGNetV2ForImageClassification
< source >( config: HGNetV2Config )
Parâmetros
- config (HGNetV2Config) — 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 HGNetV2 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 geral e ao comportamento.
forward
< source >( pixel_values: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → ImageClassifierOutputWithNoAttention or tuple(torch.Tensor)
Parâmetros
- pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usandoimage_processor_class. Consulteimage_processor_class.__call__para mais detalhes (processor_classusaimage_processor_classpara processar as imagens). - labels (
torch.LongTensorde 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]. Seconfig.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio); seconfig.num_labels > 1, uma perda de classificação é calculada (entropia cruzada). - output_hidden_states (
bool, opcional) — Indica se as hidden states de todas as camadas devem ser retornadas. Consultehidden_statesem tensors retornados para mais detalhes. - return_dict (
bool, opcional) — Indica se deve 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 (HGNetV2Config) e das entradas.
O método forward de HGNetV2ForImageClassification 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
Moduleem 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.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de classificação (ou regressão se config.num_labels==1). - logits (
torch.Tensorde 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 quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.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). Hidden-states (também chamados de feature maps) do modelo na saída de cada estágio.
Exemplos:
>>> import torch
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import HGNetV2ForImageClassification, AutoImageProcessor
>>> from PIL import Image
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> model = HGNetV2ForImageClassification.from_pretrained("ustc-community/hgnet-v2")
>>> processor = AutoImageProcessor.from_pretrained("ustc-community/hgnet-v2")
>>> inputs = processor(images=image, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> outputs.logits.shape
torch.Size([1, 2])