Transformers documentation
HGNet-V2
Ce modèle a été contribué à Hugging Face Transformers le 2025-04-29.
HGNet-V2
HGNetV2 est un backbone de réseau de neurones convolutif (CNN) de nouvelle génération, conçu pour offrir un compromis optimal entre précision et latence sur les GPU NVIDIA. S’appuyant sur le HGNet original, HGNetV2 délivre une haute précision à des vitesses d’inférence rapides et obtient de solides résultats sur des tâches telles que la classification d’images, la détection d’objets et la segmentation, ce qui en fait un choix pratique pour les applications de vision par ordinateur basées sur GPU.
Vous pouvez trouver tous les modèles originaux de HGNet V2 sous l'organisation USTC.
Ce modèle a été contribué par VladOS95-cyber. Cliquez sur les modèles HGNet V2 dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer HGNet V2 à différentes tâches de vision par ordinateur.
L'exemple ci-dessous montre comment classifier une image avec Pipeline ou la 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 )
Paramètres
- num_channels (
int, facultatif, par défaut3) — Le nombre de canaux d'entrée. - embedding_size (
int, facultatif, par défaut64) — Dimension des embeddings et des états cachés. - depths (
Union[list[int], tuple[int, ...]], facultatif, par défaut(3, 4, 6, 3)) — Profondeur de chaque couche du Transformer. - hidden_sizes (
Union[list[int], tuple[int, ...]], facultatif, par défaut(256, 512, 1024, 2048)) — Dimension (taille cachée) à chaque étape du modèle. - hidden_act (
str, facultatif, par défautrelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple,"gelu","relu","silu", etc. - stem_channels (
list[int], facultatif, par défaut[3, 32, 48]) — Dimensions des canaux pour les couches de tige :- Le premier nombre (3) correspond aux canaux de l'image d'entrée
- Le deuxième nombre (32) correspond aux canaux intermédiaires de la tige
- Le troisième nombre (48) correspond aux canaux de la tige de sortie
- stem_strides (
Sequence[int | list[int] | tuple[int, ...]], facultatif, par défaut(2, 1, 1, 2, 1)) — Motifs de pas pour les couches de tige. - stage_in_channels (
list[int], facultatif, par défaut[48, 128, 512, 1024]) — Dimensions des canaux d'entrée pour chaque étape du backbone. Cela définit le nombre de canaux que l'entrée de chaque étape aura. - stage_mid_channels (
list[int], facultatif, par défaut[48, 96, 192, 384]) — Dimensions des canaux intermédiaires pour chaque étape du backbone. Cela définit le nombre de canaux utilisés dans les couches intermédiaires de chaque étape. - stage_out_channels (
list[int], facultatif, par défaut[128, 512, 1024, 2048]) — Dimensions des canaux de sortie pour chaque étape du backbone. Cela définit le nombre de canaux que la sortie de chaque étape aura. - stage_num_blocks (
list[int], facultatif, par défaut[1, 1, 3, 1]) — Nombre de blocs à utiliser dans chaque étape du backbone. Cela contrôle la profondeur de chaque étape en spécifiant le nombre de blocs convolutifs à empiler. - stage_downsample (
list[bool], facultatif, par défaut[False, True, True, True]) — Indique s'il faut effectuer un sous-échantillonnage des cartes de caractéristiques à chaque étape. SiTrue, les dimensions spatiales des cartes de caractéristiques seront réduites. - stage_downsample_strides (
Sequence[int | list[int] | tuple[int, ...]], facultatif, par défaut(2, 2, 2, 2)) — Motifs de pas pour chaque couche de stage. - stage_light_block (
list[bool], facultatif, par défaut[False, False, True, True]) — Indique s'il faut utiliser des blocs légers à chaque étape. Les blocs légers sont une variante des blocs convolutifs qui peuvent avoir moins de paramètres. - stage_kernel_size (
list[int], facultatif, par défaut[3, 3, 5, 5]) — Tailles des noyaux pour les couches de convolution de chaque étape. - stage_numb_of_layers (
list[int], facultatif, par défaut[6, 6, 6, 6]) — Nombre de couches à utiliser dans chaque bloc de l'étape. - use_learnable_affine_block (
bool, facultatif, par défautFalse) — Indique s'il faut utiliser des Learnable Affine Blocks (LAB) dans le réseau. LAB ajoute des paramètres d'échelle et de biais apprenables après certaines opérations. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
Ceci est la classe de configuration destinée à stocker la configuration d'un HGNetV2Backbone. Elle est utilisée pour instancier un modèle Hgnet V2 en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de ustc-community/dfine_x_coco
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
HGNetV2Backbone
forward
< source >( pixel_values: Tensoroutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BackboneOutput or tuple(torch.Tensor)
Paramètres
- pixel_values (
torch.Tensorde forme(batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide deimage_processor_class. Voirimage_processor_class.__call__pour plus de détails (processor_classutiliseimage_processor_classpour le traitement des images). - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
BackboneOutput ou tuple(torch.Tensor)
Un BackboneOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (HGNetV2Config) et des entrées.
La méthode forward de HGNetV2Backbone redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
feature_maps (
tuple(torch.Tensor)de forme(batch_size, num_channels, height, width)) — Cartes de caractéristiques des étapes.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size)ou(batch_size, num_channels, height, width), selon le backbone.États cachés du modèle à la sortie de chaque étape, ainsi que les sorties des embeddings initiaux.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length). Applicable uniquement si le backbone utilise l'attention.Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemples :
>>> 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 )
Paramètres
- config (HGNetV2Config) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Modèle HGNetV2 avec une tête de classification d'images au sommet (une couche linéaire au-dessus des fonctionnalités agrégées), par exemple pour ImageNet.
Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
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)
Paramètres
- pixel_values (
torch.Tensorde forme(batch_size, num_channels, image_size, image_size), facultatif) — Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide deimage_processor_class. Voirimage_processor_class.__call__pour plus de détails (processor_classutiliseimage_processor_classpour le traitement des images). - labels (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression d'image. Les indices doivent être dans[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Siconfig.num_labels > 1, une perte de classification est calculée (entropie croisée). - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
ImageClassifierOutputWithNoAttention ou tuple(torch.Tensor)
Un ImageClassifierOutputWithNoAttention ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (HGNetV2Config) et des entrées.
La méthode forward de HGNetV2ForImageClassification redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
- loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de classification (ou de régression si config.num_labels==1). - logits (
torch.Tensorde forme(batch_size, config.num_labels)) — Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax). - hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque étape) de forme(batch_size, num_channels, height, width). États cachés (aussi appelés cartes de caractéristiques) du modèle à la sortie de chaque étape.
Exemples :
>>> 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])